diff options
Diffstat (limited to 'test/files')
30 files changed, 494 insertions, 3 deletions
diff --git a/test/files/jvm/signum.scala b/test/files/jvm/signum.scala new file mode 100644 index 0000000000..feb28d3e43 --- /dev/null +++ b/test/files/jvm/signum.scala @@ -0,0 +1,15 @@ +object Test { + def main(args: Array[String]) { + assert(math.signum(Long.MaxValue) == 1L) + assert(math.signum(1L) == 1L) + assert(math.signum(0L) == 0L) + assert(math.signum(-1L) == -1L) + assert(math.signum(Long.MinValue) == -1L) + + assert(math.signum(Int.MaxValue) == 1) + assert(math.signum(1) == 1) + assert(math.signum(0) == 0) + assert(math.signum(-1) == -1) + assert(math.signum(Int.MinValue) == -1) + } +} diff --git a/test/files/neg/nopredefs.check b/test/files/neg/nopredefs.check index 0a0ab34482..e6c1af78a0 100644 --- a/test/files/neg/nopredefs.check +++ b/test/files/neg/nopredefs.check @@ -1,4 +1,4 @@ -nopredefs.scala:5: error: not found: value Set +nopredefs.scala:5: error: not found: value Set (similar: Seq) val y = Set(3) ^ one error found diff --git a/test/files/neg/reassignment.check b/test/files/neg/reassignment.check new file mode 100644 index 0000000000..f0effd1459 --- /dev/null +++ b/test/files/neg/reassignment.check @@ -0,0 +1,13 @@ +reassignment.scala:2: error: not found: value x + x = 5 + ^ +reassignment.scala:3: error: not found: value y + y := 45 + ^ +reassignment.scala:4: error: not found: value y + y += 45 + ^ +reassignment.scala:6: error: reassignment to val + z = 51 + ^ +four errors found diff --git a/test/files/neg/reassignment.scala b/test/files/neg/reassignment.scala new file mode 100644 index 0000000000..e31eefbf3f --- /dev/null +++ b/test/files/neg/reassignment.scala @@ -0,0 +1,7 @@ +class A { + x = 5 + y := 45 + y += 45 + val z = 50 + z = 51 +}
\ No newline at end of file diff --git a/test/files/neg/suggest-similar.check b/test/files/neg/suggest-similar.check new file mode 100644 index 0000000000..0a858aaf2e --- /dev/null +++ b/test/files/neg/suggest-similar.check @@ -0,0 +1,10 @@ +suggest-similar.scala:8: error: not found: value flippitx (similar: flippity) + flippitx = 123 + ^ +suggest-similar.scala:9: error: not found: value identiyt (similar: identity) + Nil map identiyt + ^ +suggest-similar.scala:10: error: not found: type Bingus (similar: Dingus) + new Bingus + ^ +three errors found diff --git a/test/files/neg/suggest-similar.scala b/test/files/neg/suggest-similar.scala new file mode 100644 index 0000000000..ff327478fe --- /dev/null +++ b/test/files/neg/suggest-similar.scala @@ -0,0 +1,11 @@ +class Dingus +object Dingus { + var flippity = 1 +} +import Dingus._ + +class A { + flippitx = 123 + Nil map identiyt + new Bingus +} diff --git a/test/files/neg/t0903.check b/test/files/neg/t0903.check index db4cd94d2c..2dd05cd3ee 100644 --- a/test/files/neg/t0903.check +++ b/test/files/neg/t0903.check @@ -1,4 +1,4 @@ -t0903.scala:3: error: reassignment to val +t0903.scala:3: error: value += is not a member of Int x += 1 ^ t0903.scala:4: error: reassignment to val diff --git a/test/files/neg/t2870.check b/test/files/neg/t2870.check index 6577577d3f..72bc0d98a1 100644 --- a/test/files/neg/t2870.check +++ b/test/files/neg/t2870.check @@ -1,4 +1,4 @@ -t2870.scala:1: error: not found: type Jar +t2870.scala:1: error: not found: type Jar (similar: Jars) class Jars(jar: Jar) ^ t2870.scala:6: error: illegal cyclic reference involving value <import> diff --git a/test/files/pos/t4758.scala b/test/files/pos/t4758.scala new file mode 100644 index 0000000000..627dfd7a23 --- /dev/null +++ b/test/files/pos/t4758.scala @@ -0,0 +1,17 @@ +// /scala/trac/4758/a.scala +// Fri Dec 2 13:41:54 PST 2011 + +package bar { + // works + trait M[F[_]] + class S[X[_] <: M[X], A](val x:X[A]) + object S { + def apply[X[_] <: M[X], A](x: X[A]): S[X, A] = new S[X, A](x) + def unapply[X[_] <: M[X], A](p: S[X, A]) = Some(p.x) + } +} +package foo { + // seemingly equivalent, doesn't work + trait M[F[_]] + case class S[X[_] <: M[X], A](x: X[A]) +} diff --git a/test/files/pos/t5084.scala b/test/files/pos/t5084.scala new file mode 100644 index 0000000000..17d0a68adf --- /dev/null +++ b/test/files/pos/t5084.scala @@ -0,0 +1,5 @@ +case class Search(tpe: Search.Value) + +object Search { + type Value = String +} diff --git a/test/files/run/enums.check b/test/files/run/enums.check index f53aba8794..93eadae6e3 100644 --- a/test/files/run/enums.check +++ b/test/files/run/enums.check @@ -3,3 +3,13 @@ test Test2 was successful test Test3 was successful test Test4 was successful +D1.ValueSet(North, East) +D2.ValueSet(North, East) +D1.ValueSet(North, East, West) +D2.ValueSet(North, East, West) +List(101) +List(101) +D1.ValueSet(North, East) +D2.ValueSet(North, East) +WeekDays.ValueSet(Tue, Wed, Thu, Fri) + diff --git a/test/files/run/enums.scala b/test/files/run/enums.scala index 6dda8cbc6e..9cdeed2691 100644 --- a/test/files/run/enums.scala +++ b/test/files/run/enums.scala @@ -65,6 +65,58 @@ object Test4 { } } +object Test5 { + + object D1 extends Enumeration(0) { + val North, South, East, West = Value; + } + + object D2 extends Enumeration(-2) { + val North, South, East, West = Value; + } + + object WeekDays extends Enumeration { + val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value + } + + def run { + val s1 = D1.ValueSet(D1.North, D1.East) + val s2 = D2.North + D2.East + println(s1) + println(s2) + println(s1 + D1.West) + println(s2 + D2.West) + println(s1.toBitMask.map(_.toBinaryString).toList) + println(s2.toBitMask.map(_.toBinaryString).toList) + println(D1.ValueSet.fromBitMask(s1.toBitMask)) + println(D2.ValueSet.fromBitMask(s2.toBitMask)) + println(WeekDays.values.range(WeekDays.Tue, WeekDays.Sat)) + } +} + +object SerializationTest { + object Types extends Enumeration { val X, Y = Value } + class A extends java.io.Serializable { val types = Types.values } + class B extends java.io.Serializable { val types = Set(Types.X, Types.Y) } + + def serialize(obj: AnyRef) = { + val baos = new java.io.ByteArrayOutputStream() + val oos = new java.io.ObjectOutputStream(baos) + oos.writeObject(obj) + oos.close() + val bais = new java.io.ByteArrayInputStream(baos.toByteArray) + val ois = new java.io.ObjectInputStream(bais) + val prime = ois.readObject() + ois.close() + prime + } + + def run { + serialize(new B()) + serialize(new A()) + } +} + //############################################################################ // Test code @@ -94,6 +146,9 @@ object Test { check_success("Test3", Test3.run, 1); check_success("Test4", Test4.run, 0); Console.println; + Test5.run; + Console.println; + SerializationTest.run; } } diff --git a/test/files/run/parserFilter.check b/test/files/run/parserFilter.check new file mode 100644 index 0000000000..be04454426 --- /dev/null +++ b/test/files/run/parserFilter.check @@ -0,0 +1,9 @@ +[1.3] failure: Input doesn't match filter: false + +if false + ^ +[1.1] failure: Input doesn't match filter: not + +not true +^ +[1.8] parsed: (if~true) diff --git a/test/files/run/parserFilter.scala b/test/files/run/parserFilter.scala new file mode 100644 index 0000000000..d007d441f4 --- /dev/null +++ b/test/files/run/parserFilter.scala @@ -0,0 +1,15 @@ +object Test extends scala.util.parsing.combinator.RegexParsers { + val keywords = Set("if", "false") + def word: Parser[String] = "\\w+".r + + def keyword: Parser[String] = word filter (keywords.contains) + def ident: Parser[String] = word filter(!keywords.contains(_)) + + def test = keyword ~ ident + + def main(args: Array[String]) { + println(parseAll(test, "if false")) + println(parseAll(test, "not true")) + println(parseAll(test, "if true")) + } +} diff --git a/test/files/run/parserForFilter.check b/test/files/run/parserForFilter.check new file mode 100644 index 0000000000..a53c147719 --- /dev/null +++ b/test/files/run/parserForFilter.check @@ -0,0 +1 @@ +[1.13] parsed: (second,first) diff --git a/test/files/run/parserForFilter.scala b/test/files/run/parserForFilter.scala new file mode 100644 index 0000000000..1bc44f8033 --- /dev/null +++ b/test/files/run/parserForFilter.scala @@ -0,0 +1,12 @@ +object Test extends scala.util.parsing.combinator.RegexParsers { + def word: Parser[String] = "\\w+".r + + def twoWords = for { + (a ~ b) <- word ~ word + } yield (b, a) + + def main(args: Array[String]) { + println(parseAll(twoWords, "first second")) + } +} + diff --git a/test/files/run/parserNoSuccessMessage.check b/test/files/run/parserNoSuccessMessage.check new file mode 100644 index 0000000000..fe00d2fd3a --- /dev/null +++ b/test/files/run/parserNoSuccessMessage.check @@ -0,0 +1,20 @@ +[1.2] failure: string matching regex `\d+' expected but `x' found + +-x + ^ +[1.1] failure: string matching regex `\d+' expected but `x' found + +x +^ +[1.3] parsed: (Some(-)~5) +[1.2] parsed: (None~5) +[1.2] error: Number expected! + +-x + ^ +[1.1] error: Number expected! + +x +^ +[1.3] parsed: (Some(-)~5) +[1.2] parsed: (None~5) diff --git a/test/files/run/parserNoSuccessMessage.scala b/test/files/run/parserNoSuccessMessage.scala new file mode 100644 index 0000000000..93aa252db0 --- /dev/null +++ b/test/files/run/parserNoSuccessMessage.scala @@ -0,0 +1,19 @@ +object Test extends scala.util.parsing.combinator.RegexParsers { + def sign = "-" + def number = "\\d+".r + def p = sign.? ~ number withErrorMessage "Number expected!" + def q = sign.? ~! number withErrorMessage "Number expected!" + + def main(args: Array[String]) { + println(parseAll(p, "-x")) + println(parseAll(p, "x")) + println(parseAll(p, "-5")) + println(parseAll(p, "5")) + println(parseAll(q, "-x")) + println(parseAll(q, "x")) + println(parseAll(q, "-5")) + println(parseAll(q, "5")) + } +} + + diff --git a/test/files/run/reify_anonymous.check b/test/files/run/reify_anonymous.check new file mode 100644 index 0000000000..b8626c4cff --- /dev/null +++ b/test/files/run/reify_anonymous.check @@ -0,0 +1 @@ +4 diff --git a/test/files/run/reify_anonymous.scala b/test/files/run/reify_anonymous.scala new file mode 100644 index 0000000000..1e7f3fe856 --- /dev/null +++ b/test/files/run/reify_anonymous.scala @@ -0,0 +1,14 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + println(new {def x = 2; def y = x * x}.y) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/files/run/reify_generic.check b/test/files/run/reify_generic.check new file mode 100644 index 0000000000..b8626c4cff --- /dev/null +++ b/test/files/run/reify_generic.check @@ -0,0 +1 @@ +4 diff --git a/test/files/run/reify_generic.scala b/test/files/run/reify_generic.scala new file mode 100644 index 0000000000..aef038b2d8 --- /dev/null +++ b/test/files/run/reify_generic.scala @@ -0,0 +1,15 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + val product = List(1, 2, 3).head * List[Any](4, 2, 0).head.asInstanceOf[Int] + println(product) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/files/run/reify_inheritance.check b/test/files/run/reify_inheritance.check new file mode 100644 index 0000000000..25bf17fc5a --- /dev/null +++ b/test/files/run/reify_inheritance.check @@ -0,0 +1 @@ +18
\ No newline at end of file diff --git a/test/files/run/reify_inheritance.scala b/test/files/run/reify_inheritance.scala new file mode 100644 index 0000000000..2a1b5f764f --- /dev/null +++ b/test/files/run/reify_inheritance.scala @@ -0,0 +1,23 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + class C { + def x = 2 + def y = x * x + } + + class D extends C { + override def x = 3 + } + + println(new D().y * new C().x) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + toolbox.runExpr(ttree) +} diff --git a/test/files/run/reify_printf.check b/test/files/run/reify_printf.check new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/test/files/run/reify_printf.check diff --git a/test/files/run/reify_printf.scala b/test/files/run/reify_printf.scala new file mode 100644 index 0000000000..30901b98c2 --- /dev/null +++ b/test/files/run/reify_printf.scala @@ -0,0 +1,75 @@ +import java.io.{ ByteArrayOutputStream, PrintStream } +import scala.reflect.Code +import scala.reflect.mirror._ +import scala.reflect.api._ +import scala.reflect.api.Trees +import scala.reflect.internal.Types +import reflect.runtime.Mirror.ToolBox +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import scala.util.matching.Regex + +object Test extends App { + val tree = tree_printf(Code.lift("hello %s").tree, Code.lift("world").tree) + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter, args mkString " ") + val ttree = toolbox.typeCheck(tree) + + val output = new ByteArrayOutputStream() + Console.setOut(new PrintStream(output)) + val evaluated = toolbox.runExpr(ttree) + + assert(output.toString() == "hello world", output.toString() +" == hello world") + + /* + macro def printf(format: String, params: Any*) : String = tree_printf(format: Tree, (params: Seq[Tree]): _*) + */ + + var i = 0 + def gensym(name: String) = { i += 1; newTermName(name + i) } + + def createTempValDef( value : Tree, tpe : Type ) : (Option[Tree],Tree) = { + val local = gensym("temp") + ( + Some( + ValDef( + Modifiers() + , local + , TypeTree().setType(tpe) + , value + ) + ) + , Ident(local) + ) + } + + def tree_printf(format: Tree, params: Tree*) = { + val Literal(Constant(s_format: String)) = format + val paramsStack = scala.collection.mutable.Stack(params: _*) + val parsed = s_format.split("(?<=%[\\w%])|(?=%[\\w%])") map { + case "%d" => createTempValDef( paramsStack.pop, classToType(classOf[Int]) ) + case "%s" => createTempValDef( paramsStack.pop, classToType(classOf[String]) ) + case "%%" => { + (None:Option[Tree], Literal(Constant("%"))) + } + case part => { + (None:Option[Tree], Literal(Constant(part))) + } + } + + val evals = for ((Some(eval), _) <- parsed if eval != None) yield (eval: Tree) + val prints = for ((_, ref) <- parsed) yield + Apply( + Select( + Select( + Ident( newTermName("scala") ) + , newTermName("Predef") + ) + , newTermName("print") + ) + , List(ref) + ): Tree + Block((evals ++ prints).toList, Literal(Constant(()))) + } +} diff --git a/test/files/run/t4658.check b/test/files/run/t4658.check new file mode 100644 index 0000000000..743b0faee3 --- /dev/null +++ b/test/files/run/t4658.check @@ -0,0 +1,80 @@ +Ranges: +1073741824 +1073741824 +0 +0 +55 +25 +1 +-45 +-55 +0 +-24 +-30 +0 +-40 +-55 +-10 +-24 +-30 +-10 +IntRanges: +Disabled #1 +Disabled #2 +0 +0 +55 +25 +1 +-45 +-55 +0 +-24 +-30 +0 +-40 +-55 +-10 +-24 +-30 +-10 +LongRanges: +Disabled #1 +Disabled #2 +0 +0 +55 +25 +1 +-45 +-55 +0 +-24 +-30 +0 +-40 +-55 +-10 +-24 +-30 +-10 +BigIntRanges: +Disabled #1 +Disabled #2 +0 +0 +55 +25 +1 +-45 +-55 +0 +-24 +-30 +0 +-40 +-55 +-10 +-24 +-30 +-10 diff --git a/test/files/run/t4658.scala b/test/files/run/t4658.scala new file mode 100644 index 0000000000..e1799fae9b --- /dev/null +++ b/test/files/run/t4658.scala @@ -0,0 +1,41 @@ +import scala.collection.immutable.NumericRange +//#4658 +object Test { + + case class R(start: Int, end: Int, step: Int = 1, inclusive: Boolean = true) + + val rangeData = Array( + R(1, Int.MaxValue), R(-Int.MaxValue, -1), R(0, 0), R(0,0, inclusive = false), R(1,10), + R(1,10,2), R(1,10,11), R(-10, -5), R(-10, 0), R(-10, 10), R(-10, -5, 2), R(-10, 0, 2), R(-10, 10, 2), + R(-10, -5, inclusive = false), R(-10, 0, inclusive = false), R(-10, 10, inclusive = false), + R(-10, -5, 2, inclusive = false), R(-10, 0, 2, inclusive = false), R(-10, 10, 2, inclusive = false) + ) + + def ranges = rangeData.map(r => if (r.inclusive) r.start to r.end by r.step else r.start until r.end by r.step) + + def numericIntRanges = rangeData.map(r => if (r.inclusive) NumericRange.inclusive(r.start, r.end, r.step) else NumericRange(r.start, r.end, r.step)) + + def numericLongRanges = rangeData.map(r => if (r.inclusive) NumericRange.inclusive(r.start.toLong, r.end, r.step) else NumericRange(r.start.toLong, r.end, r.step)) + + def numericBigIntRanges = rangeData.map(r => if (r.inclusive) NumericRange.inclusive(BigInt(r.start), BigInt(r.end), BigInt(r.step)) else NumericRange(BigInt(r.start), BigInt(r.end), BigInt(r.step))) + + def main(args: Array[String]) { + // We drop the first two tests for all ranges which don't have a decent sum implementation, + // because it is just too slow. + println("Ranges:") + ranges.foreach{range => println(range.sum)} + println("IntRanges:") + println("Disabled #1") + println("Disabled #2") + numericIntRanges.drop(2).foreach{range => println(range.sum)} + println("LongRanges:") + println("Disabled #1") + println("Disabled #2") + numericLongRanges.drop(2).foreach{range => println(range.sum)} + println("BigIntRanges:") + println("Disabled #1") + println("Disabled #2") + numericBigIntRanges.drop(2).foreach{range => println(range.sum)} + } + +}
\ No newline at end of file diff --git a/test/files/run/t5230.check b/test/files/run/t5230.check new file mode 100644 index 0000000000..5db6ec9b38 --- /dev/null +++ b/test/files/run/t5230.check @@ -0,0 +1,2 @@ +2 +evaluated = null diff --git a/test/files/run/t5230.scala b/test/files/run/t5230.scala new file mode 100644 index 0000000000..5aab8f9290 --- /dev/null +++ b/test/files/run/t5230.scala @@ -0,0 +1,19 @@ +import scala.tools.nsc.reporters._ +import scala.tools.nsc.Settings +import reflect.runtime.Mirror.ToolBox + +object Test extends App { + val code = scala.reflect.Code.lift{ + class C { + val x = 2 + } + + println(new C().x) + }; + + val reporter = new ConsoleReporter(new Settings) + val toolbox = new ToolBox(reporter) + val ttree = toolbox.typeCheck(code.tree) + val evaluated = toolbox.runExpr(ttree) + println("evaluated = " + evaluated) +} |