diff options
Diffstat (limited to 'test')
27 files changed, 355 insertions, 5 deletions
diff --git a/test/files/neg/t0903.check b/test/files/neg/t0903.check index 2dd05cd3ee..f9dc28bf16 100644 --- a/test/files/neg/t0903.check +++ b/test/files/neg/t0903.check @@ -1,4 +1,5 @@ t0903.scala:3: error: value += is not a member of Int + Expression does not convert to assignment because receiver is not assignable. x += 1 ^ t0903.scala:4: error: reassignment to val diff --git a/test/files/neg/t1215.check b/test/files/neg/t1215.check index 1f9dd6bf38..4cbd0d85f3 100644 --- a/test/files/neg/t1215.check +++ b/test/files/neg/t1215.check @@ -1,4 +1,5 @@ t1215.scala:2: error: value += is not a member of Int + Expression does not convert to assignment because receiver is not assignable. val x = 1 += 1 ^ one error found diff --git a/test/files/neg/t3236-neg.check b/test/files/neg/t3236-neg.check new file mode 100644 index 0000000000..ef28574d45 --- /dev/null +++ b/test/files/neg/t3236-neg.check @@ -0,0 +1,34 @@ +AnnotationTest.scala:3: error: annotation argument needs to be a constant; found: Constants.ConstIdent + @IntAnnotation(Constants.ConstIdent) + ^ +AnnotationTest.scala:4: error: annotation argument needs to be a constant; found: Constants.ConstSelect + @IntAnnotation(Constants.ConstSelect) + ^ +AnnotationTest.scala:6: error: annotation argument needs to be a constant; found: Constants.ConstOpExpr1 + @IntAnnotation(Constants.ConstOpExpr1) + ^ +AnnotationTest.scala:7: error: annotation argument needs to be a constant; found: Constants.ConstOpExpr2 + @IntAnnotation(Constants.ConstOpExpr2) + ^ +AnnotationTest.scala:8: error: annotation argument needs to be a constant; found: Constants.ConstOpExpr3 + @BooleanAnnotation(Constants.ConstOpExpr3) + ^ +AnnotationTest.scala:9: error: annotation argument needs to be a constant; found: Constants.ConstOpExpr4 + @IntAnnotation(Constants.ConstOpExpr4) + ^ +AnnotationTest.scala:10: error: annotation argument needs to be a constant; found: Constants.NonFinalConst + @IntAnnotation(Constants.NonFinalConst) + ^ +AnnotationTest.scala:11: error: value NonStaticConst is not a member of object Constants + @IntAnnotation(Constants.NonStaticConst) + ^ +AnnotationTest.scala:12: error: value NonConst is not a member of object Constants + @IntAnnotation(Constants.NonConst) + ^ +AnnotationTest.scala:13: error: annotation argument needs to be a constant; found: Constants.ConstCastExpr + @ShortAnnotation(Constants.ConstCastExpr) + ^ +AnnotationTest.scala:15: error: annotation argument needs to be a constant; found: Constants.StringAdd + @StringAnnotation(Constants.StringAdd) + ^ +11 errors found diff --git a/test/files/neg/t3236-neg/AnnotationTest.scala b/test/files/neg/t3236-neg/AnnotationTest.scala new file mode 100644 index 0000000000..aec2a99020 --- /dev/null +++ b/test/files/neg/t3236-neg/AnnotationTest.scala @@ -0,0 +1,17 @@ +trait AnnotationTest { + @IntAnnotation(Constants.ConstInt) // ok + @IntAnnotation(Constants.ConstIdent) + @IntAnnotation(Constants.ConstSelect) + @IntAnnotation(Constants.NegatedInt) // ok + @IntAnnotation(Constants.ConstOpExpr1) + @IntAnnotation(Constants.ConstOpExpr2) + @BooleanAnnotation(Constants.ConstOpExpr3) + @IntAnnotation(Constants.ConstOpExpr4) + @IntAnnotation(Constants.NonFinalConst) + @IntAnnotation(Constants.NonStaticConst) + @IntAnnotation(Constants.NonConst) + @ShortAnnotation(Constants.ConstCastExpr) + @StringAnnotation(Constants.ConstString) // ok + @StringAnnotation(Constants.StringAdd) + def test: Unit +}
\ No newline at end of file diff --git a/test/files/neg/t3236-neg/BooleanAnnotation.java b/test/files/neg/t3236-neg/BooleanAnnotation.java new file mode 100644 index 0000000000..7e57a5e0db --- /dev/null +++ b/test/files/neg/t3236-neg/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/test/files/neg/t3236-neg/Constants.java b/test/files/neg/t3236-neg/Constants.java new file mode 100644 index 0000000000..01d2d70dd7 --- /dev/null +++ b/test/files/neg/t3236-neg/Constants.java @@ -0,0 +1,25 @@ +// https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.28 +public class Constants { + public static final int ConstInt = 1; + + public static final int ConstIdent = ConstInt; + public static final int ConstSelect = Constants.ConstInt; + + // this is a known limitation in scala's javac parser for constants, it will be treated as -1. + // the java compiler will flag an error. + public static final int NegatedInt = !1; + + public static final int ConstOpExpr1 = 1 + 2; + public static final int ConstOpExpr2 = 1 << 2; + public static final boolean ConstOpExpr3 = 1 == 1; + public static final int ConstOpExpr4 = true ? 1 : 2; + + public static int NonFinalConst = 1; + public final int NonStaticConst = 1; + public int NonConst = 1; + + public static final short ConstCastExpr = (short)(1*2*3*4*5*6); + + public static final String ConstString = "a"; + public static final String StringAdd = "a" + 1; +} diff --git a/test/files/neg/t3236-neg/IntAnnotation.java b/test/files/neg/t3236-neg/IntAnnotation.java new file mode 100644 index 0000000000..2ffad8890c --- /dev/null +++ b/test/files/neg/t3236-neg/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/test/files/neg/t3236-neg/ShortAnnotation.java b/test/files/neg/t3236-neg/ShortAnnotation.java new file mode 100644 index 0000000000..f0a35892c7 --- /dev/null +++ b/test/files/neg/t3236-neg/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/test/files/neg/t3236-neg/StringAnnotation.java b/test/files/neg/t3236-neg/StringAnnotation.java new file mode 100644 index 0000000000..0fdc1ead38 --- /dev/null +++ b/test/files/neg/t3236-neg/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/test/files/neg/t8763.check b/test/files/neg/t8763.check new file mode 100644 index 0000000000..4659e57be6 --- /dev/null +++ b/test/files/neg/t8763.check @@ -0,0 +1,6 @@ +t8763.scala:9: error: type mismatch; + found : Char + required: String + names_times(fields(0)) += fields(1).toLong + ^ +one error found diff --git a/test/files/neg/t8763.scala b/test/files/neg/t8763.scala new file mode 100644 index 0000000000..08ce1b471a --- /dev/null +++ b/test/files/neg/t8763.scala @@ -0,0 +1,11 @@ + +import collection.mutable + +object Foo { + def bar() { + val names_times = mutable.Map[String, mutable.Set[Long]]() + val line = "" + val Array(fields) = line.split("\t") + names_times(fields(0)) += fields(1).toLong + } +} diff --git a/test/files/neg/t9834.check b/test/files/neg/t9834.check new file mode 100644 index 0000000000..d07eb7f155 --- /dev/null +++ b/test/files/neg/t9834.check @@ -0,0 +1,9 @@ +t9834.scala:5: error: value += is not a member of Int + Expression does not convert to assignment because: + type mismatch; + found : String + required: Int + expansion: x.update(x.apply().+("42")) + x() += "42" + ^ +one error found diff --git a/test/files/neg/t9834.scala b/test/files/neg/t9834.scala new file mode 100644 index 0000000000..1ecda7a2b8 --- /dev/null +++ b/test/files/neg/t9834.scala @@ -0,0 +1,6 @@ + +object x { def apply() = 42 ; def update(i: Int) = () } + +trait Test { + x() += "42" +} diff --git a/test/files/run/t3236/AnnotationTest.scala b/test/files/run/t3236/AnnotationTest.scala new file mode 100644 index 0000000000..c2f9ae7837 --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/BooleanAnnotation.java b/test/files/run/t3236/BooleanAnnotation.java new file mode 100644 index 0000000000..7e57a5e0db --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/ByteAnnotation.java b/test/files/run/t3236/ByteAnnotation.java new file mode 100644 index 0000000000..c986fa5d27 --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/CharAnnotation.java b/test/files/run/t3236/CharAnnotation.java new file mode 100644 index 0000000000..1715f1b7de --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/Constants.java b/test/files/run/t3236/Constants.java new file mode 100644 index 0000000000..16b4001f76 --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/DoubleAnnotation.java b/test/files/run/t3236/DoubleAnnotation.java new file mode 100644 index 0000000000..1eb8223f4e --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/FloatAnnotation.java b/test/files/run/t3236/FloatAnnotation.java new file mode 100644 index 0000000000..c723a25fad --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/IntAnnotation.java b/test/files/run/t3236/IntAnnotation.java new file mode 100644 index 0000000000..2ffad8890c --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/LongAnnotation.java b/test/files/run/t3236/LongAnnotation.java new file mode 100644 index 0000000000..9f80b41398 --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/ShortAnnotation.java b/test/files/run/t3236/ShortAnnotation.java new file mode 100644 index 0000000000..f0a35892c7 --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/StringAnnotation.java b/test/files/run/t3236/StringAnnotation.java new file mode 100644 index 0000000000..0fdc1ead38 --- /dev/null +++ b/test/files/run/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/test/files/run/t3236/Test.scala b/test/files/run/t3236/Test.scala new file mode 100644 index 0000000000..7e351e0b6b --- /dev/null +++ b/test/files/run/t3236/Test.scala @@ -0,0 +1,44 @@ +import scala.language.reflectiveCalls + +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) +} diff --git a/test/junit/scala/collection/immutable/RangeConsistencyTest.scala b/test/junit/scala/collection/immutable/RangeConsistencyTest.scala index 760498c162..a997fd14ab 100644 --- a/test/junit/scala/collection/immutable/RangeConsistencyTest.scala +++ b/test/junit/scala/collection/immutable/RangeConsistencyTest.scala @@ -172,4 +172,43 @@ class RangeConsistencyTest { assert(r.sum(possiblyNotDefaultNumeric) == Int.MinValue) assert(nr.sum(possiblyNotDefaultNumeric) == Int.MinValue) } + + @Test + def test_SI10086() { + implicit val customIntegral = + new Numeric.IntIsIntegral with Ordering.IntOrdering {} + + val nr = NumericRange(1, 10, 1) + assert(nr.min == 1) + assert(nr.max == 9) + + // Also test with custom ordering. + assert(nr.min(customIntegral.reverse) == 9) + assert(nr.max(customIntegral.reverse) == 1) + + case class A(v: Int) + + implicit object aIsIntegral extends scala.math.Integral[A] { + def compare(x: A, y: A): Int = x.v.compare(y.v) + def fromInt(x: Int): A = A(x) + def minus(x: A, y: A): A = A(x.v - y.v) + def negate(x: A): A = A(-x.v) + def plus(x: A, y: A): A = A(x.v + y.v) + def times(x: A, y: A): A = A(x.v * y.v) + def quot(x: A, y: A): A = A(x.v / y.v) + def rem(x: A, y: A): A = A(x.v % y.v) + def toDouble(x: A): Double = x.v.toDouble + def toFloat(x: A): Float = x.v.toFloat + def toInt(x: A): Int = x.v + def toLong(x: A): Long = x.v.toLong + } + + val r = NumericRange(A(1), A(10), A(1)) + assert(r.min == A(1)) + assert(r.max == A(9)) + + // Also test with custom ordering. + assert(r.min(aIsIntegral.reverse) == A(9)) + assert(r.max(aIsIntegral.reverse) == A(1)) + } } diff --git a/test/junit/scala/tools/testing/AssertUtil.scala b/test/junit/scala/tools/testing/AssertUtil.scala index d798f2e53e..c9b2fb8e4d 100644 --- a/test/junit/scala/tools/testing/AssertUtil.scala +++ b/test/junit/scala/tools/testing/AssertUtil.scala @@ -3,6 +3,7 @@ package testing import org.junit.Assert import Assert._ +import scala.reflect.ClassTag import scala.runtime.ScalaRunTime.stringOf import scala.collection.{ GenIterable, IterableLike } import scala.collection.JavaConverters._ @@ -40,15 +41,13 @@ object AssertUtil { * and that its message satisfies the `checkMessage` predicate. * Any other exception is propagated. */ - def assertThrows[T <: Throwable](body: => Any, - checkMessage: String => Boolean = s => true) - (implicit manifest: Manifest[T]): Unit = { + def assertThrows[T <: Throwable: ClassTag](body: => Any, + checkMessage: String => Boolean = s => true): Unit = { try { body fail("Expression did not throw!") } catch { - case e: Throwable if (manifest.runtimeClass isAssignableFrom e.getClass) && - checkMessage(e.getMessage) => + case e: T if checkMessage(e.getMessage) => } } |