port SI-3236 tests

noti0na1 · noti0na1 · commit 30cc3e92bd0a · 2019-11-07T14:19:26.000-05:00
diff --git a/tests/pos/literal-constant-fields-java/J.java b/tests/pos/literal-constant-fields-java/J.java
diff --git a/tests/pos/literal-constant-fields-java/S.scala b/tests/pos/literal-constant-fields-java/S.scala
diff --git a/tests/pos/t3236/AnnotationTest.scala b/tests/pos/t3236/AnnotationTest.scala
@@ -0,0 +1,33 @@
+trait AnnotationTest {
+  @BooleanAnnotation(Constants.BooleanTrue)
+  @ByteAnnotation(Constants.Byte)
+  @CharAnnotation(Constants.Char)
+  @ShortAnnotation(Constants.Short)
+  @IntAnnotation(Constants.Int)
+  @LongAnnotation(Constants.Long)
+  @FloatAnnotation(Constants.Float)
+  @DoubleAnnotation(Constants.Double)
+  @StringAnnotation(Constants.String)
+  def test1: Unit
+
+  @BooleanAnnotation(Constants.InvertedBoolean)
+  @ByteAnnotation(Constants.NegativeByte)
+  @ShortAnnotation(Constants.NegativeShort)
+  @IntAnnotation(Constants.NegativeInt)
+  @LongAnnotation(Constants.NegativeLong)
+  @FloatAnnotation(Constants.NegativeFloat)
+  @DoubleAnnotation(Constants.NegativeDouble)
+  @StringAnnotation(Constants.NegativeString)
+  def test2: Unit
+
+  @BooleanAnnotation(Constants.BooleanFalse)
+  @ByteAnnotation(Constants.LiteralCharAsByte)
+  @CharAnnotation(Constants.LiteralChar)
+  @ShortAnnotation(Constants.LiteralCharAsShort)
+  @IntAnnotation(Constants.LiteralCharAsInt)
+  @LongAnnotation(Constants.LiteralCharAsLong)
+  def test3: Unit
+
+  @LongAnnotation(Constants.LiteralIntAsLong)
+  def test4: Unit
+}
diff --git a/tests/pos/t3236/BooleanAnnotation.java b/tests/pos/t3236/BooleanAnnotation.java
@@ -0,0 +1,7 @@
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BooleanAnnotation {
+    boolean value();
+}
diff --git a/tests/pos/t3236/ByteAnnotation.java b/tests/pos/t3236/ByteAnnotation.java
@@ -0,0 +1,7 @@
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ByteAnnotation {
+    byte value();
+}
diff --git a/tests/pos/t3236/CharAnnotation.java b/tests/pos/t3236/CharAnnotation.java
@@ -0,0 +1,7 @@
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CharAnnotation {
+    char value();
+}
diff --git a/tests/pos/t3236/Constants.java b/tests/pos/t3236/Constants.java
@@ -0,0 +1,34 @@
+public class Constants {
+    public static final boolean BooleanTrue = true;
+    public static final boolean BooleanFalse = false;
+    public static final boolean InvertedBoolean = !true;
+
+    public static final byte Byte = 23;
+    public static final byte NegativeByte = -42;
+    public static final byte LiteralCharAsByte = 'a';
+
+    public static final char Char = 33;
+    public static final char LiteralChar = 'b';
+
+    public static final short Short = 0x1234;
+    public static final short NegativeShort= -0x5678;
+    public static final short LiteralCharAsShort = 'c';
+
+    public static final int Int = 0xabcdef;
+    public static final int NegativeInt = -12345678;
+    public static final int LiteralCharAsInt = 'd';
+
+    public static final long Long = 0x1234567890abcdefL;
+    public static final long NegativeLong = -0xfedcba09876L;
+    public static final long LiteralCharAsLong = 'e';
+    public static final long LiteralIntAsLong = 0x12345678;
+
+    public static final float Float = 42.232323f;
+    public static final float NegativeFloat = -3.1415f;
+
+    public static final double Double = 23.4243598374594d;
+    public static final double NegativeDouble = -42.2324358934589734859d;
+
+    public static final String String = "testConstant";
+    public static final String NegativeString = "!#!$!grml%!%!$#@@@";
+}
diff --git a/tests/pos/t3236/DoubleAnnotation.java b/tests/pos/t3236/DoubleAnnotation.java
@@ -0,0 +1,7 @@
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DoubleAnnotation {
+    double value();
+}
diff --git a/tests/pos/t3236/FloatAnnotation.java b/tests/pos/t3236/FloatAnnotation.java
@@ -0,0 +1,7 @@
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface FloatAnnotation {
+    float value();
+}
diff --git a/tests/pos/t3236/IntAnnotation.java b/tests/pos/t3236/IntAnnotation.java
@@ -0,0 +1,7 @@
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface IntAnnotation {
+    int value();
+}
diff --git a/tests/pos/t3236/LongAnnotation.java b/tests/pos/t3236/LongAnnotation.java
@@ -0,0 +1,7 @@
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface LongAnnotation {
+    long value();
+}
diff --git a/tests/pos/t3236/ShortAnnotation.java b/tests/pos/t3236/ShortAnnotation.java
@@ -0,0 +1,7 @@
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ShortAnnotation {
+    short value();
+}
diff --git a/tests/pos/t3236/StringAnnotation.java b/tests/pos/t3236/StringAnnotation.java
@@ -0,0 +1,7 @@
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface StringAnnotation {
+    String value();
+}
diff --git a/tests/pos/t3236/Test.scala b/tests/pos/t3236/Test.scala
@@ -0,0 +1,44 @@
+import scala.reflect.Selectable.reflectiveSelectable
+
+object Test extends App {
+  val theClass = classOf[AnnotationTest]
+
+  def annotation[T <: java.lang.annotation.Annotation](annotationClass: Class[T], methodName: String): T =
+    theClass.getDeclaredMethod(methodName)
+      .getAnnotation[T](annotationClass)
+
+  def check[T, U <: java.lang.annotation.Annotation & { def value(): T } ](annotationClass: Class[U], methodName: String, expected: T): Unit = {
+    val a = annotation(annotationClass, methodName)
+    assert(a != null, s"No annotation of type $annotationClass found on method $methodName")
+    assert(a.value() == expected, s"Actual value of annotation $a on $methodName was not of expected value $expected")
+  }
+
+  check(classOf[BooleanAnnotation], "test1", Constants.BooleanTrue)
+  check(classOf[ByteAnnotation], "test1", Constants.Byte)
+  check(classOf[CharAnnotation], "test1", Constants.Char)
+  check(classOf[ShortAnnotation], "test1", Constants.Short)
+  check(classOf[IntAnnotation], "test1", Constants.Int)
+  check(classOf[LongAnnotation], "test1", Constants.Long)
+  check(classOf[FloatAnnotation], "test1", Constants.Float)
+  check(classOf[DoubleAnnotation], "test1", Constants.Double)
+  check(classOf[StringAnnotation], "test1", Constants.String)
+
+  check(classOf[BooleanAnnotation], "test2", Constants.InvertedBoolean)
+  check(classOf[ByteAnnotation], "test2", Constants.NegativeByte)
+  // no negative char possible
+  check(classOf[ShortAnnotation], "test2", Constants.NegativeShort)
+  check(classOf[IntAnnotation], "test2", Constants.NegativeInt)
+  check(classOf[LongAnnotation], "test2", Constants.NegativeLong)
+  check(classOf[FloatAnnotation], "test2", Constants.NegativeFloat)
+  check(classOf[DoubleAnnotation], "test2", Constants.NegativeDouble)
+  check(classOf[StringAnnotation], "test2", Constants.NegativeString)
+
+  check(classOf[BooleanAnnotation], "test3", Constants.BooleanFalse)
+  check(classOf[ByteAnnotation], "test3", Constants.LiteralCharAsByte)
+  check(classOf[CharAnnotation], "test3", Constants.LiteralChar)
+  check(classOf[ShortAnnotation], "test3", Constants.LiteralCharAsShort)
+  check(classOf[IntAnnotation], "test3", Constants.LiteralCharAsInt)
+  check(classOf[LongAnnotation], "test3", Constants.LiteralCharAsLong)
+
+  check(classOf[LongAnnotation], "test4", Constants.LiteralIntAsLong)
+}
