Merge pull request #65 from samuelgruetter/scala-tests-raw

Add untried tests from scala/test/files/{pos,neg}

Author: odersky

tests/untried/.gitignore

@@ -0,0 +1,2 @@
+*.log
+*.obj/

tests/untried/filters

@@ -0,0 +1,8 @@
+#
+#Java HotSpot(TM) 64-Bit Server VM warning: Failed to reserve shared memory (errno = 28).
+Java HotSpot\(TM\) .* warning:
+# Hotspot receiving VM options through the $_JAVA_OPTIONS
+# env variable outputs them on stderr
+Picked up _JAVA_OPTIONS:
+# Filter out a message caused by this bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=8021205
+objc\[\d+\]: Class JavaLaunchHelper is implemented in both .* and .*\. One of the two will be used\. Which one is undefined\.

tests/untried/neg/abstract-class-2.check

@@ -0,0 +1,5 @@
+abstract-class-2.scala:11: error: object creation impossible, since method f in trait S2 of type (x: P2.this.p.S1)Int is not defined
+(Note that P.this.p.S1 does not match P2.this.S1: their prefixes (i.e. enclosing instances) differ)
+  object O2 extends S2 {
+         ^
+one error found

tests/untried/neg/abstract-class-2.scala

@@ -0,0 +1,14 @@
+class P {
+  trait S1
+  val p = new P
+
+  trait S2 {
+    def f(x: p.S1): Int
+  }
+}
+
+class P2 extends P {
+  object O2 extends S2 {
+    def f(x: S1) = 5
+  }
+}

tests/untried/neg/abstract-class-error.check

@@ -0,0 +1,5 @@
+S.scala:1: error: class S needs to be abstract, since method g in class J of type (y: Int, z: java.util.List)Int is not defined
+(Note that java.util.List does not match java.util.List[String]. To implement a raw type, use java.util.List[_])
+class S extends J {
+      ^
+one error found

tests/untried/neg/abstract-class-error/J.java

@@ -0,0 +1,4 @@
+public abstract class J {
+  public abstract int f();
+  public abstract int g(int y, java.util.List z);
+}

tests/untried/neg/abstract-class-error/S.scala

@@ -0,0 +1,4 @@
+class S extends J {
+  def f() = 55
+  def g(y: Int, z: java.util.List[String]) = 11
+}

tests/untried/neg/abstract-concrete-methods.check

@@ -0,0 +1,5 @@
+abstract-concrete-methods.scala:7: error: class Outer2 needs to be abstract, since method score in trait Outer of type (i: Outer2#Inner)Double is not defined
+(Note that This#Inner does not match Outer2#Inner: class Inner in class Outer2 is a subclass of trait Inner in trait Outer, but method parameter types must match exactly.)
+class Outer2 extends Outer[Outer2] {
+      ^
+one error found

tests/untried/neg/abstract-concrete-methods.scala

@@ -0,0 +1,10 @@
+trait Outer[This <: Outer[This]] {
+  self: This =>
+
+  trait Inner
+  def score(i: This#Inner): Double
+}
+class Outer2 extends Outer[Outer2] {
+  class Inner extends super.Inner
+  def score(i: Outer2#Inner) = 0.0
+}

tests/untried/neg/abstract-explaintypes.check

@@ -0,0 +1,15 @@
+abstract-explaintypes.scala:6: error: type mismatch;
+ found   : A
+ required: A.this.T
+  def foo2: T = bar().baz();
+                         ^
+A <: A.this.T?
+false
+abstract-explaintypes.scala:9: error: type mismatch;
+ found   : A
+ required: A.this.T
+  def foo5: T = baz().baz();
+                         ^
+A <: A.this.T?
+false
+two errors found

tests/untried/neg/abstract-explaintypes.flags

@@ -0,0 +1 @@
+-explaintypes

tests/untried/neg/abstract-explaintypes.scala

@@ -0,0 +1,11 @@
+trait A {
+  type T <: A;
+  def baz(): A;
+  def bar(): T;
+  def foo1: A = bar().bar();
+  def foo2: T = bar().baz();
+  def foo3 = bar().baz();
+  def foo4: A = baz().bar();
+  def foo5: T = baz().baz();
+  def foo6 = baz().baz();
+}

tests/untried/neg/abstract-inaccessible.check

@@ -0,0 +1,15 @@
+abstract-inaccessible.scala:5: warning: method implementMe in trait YourTrait references private[foo] trait Bippy.
+Classes which cannot access Bippy may be unable to provide a concrete implementation of implementMe.
+    def implementMe(f: Int => (String, Bippy)): Unit
+        ^
+abstract-inaccessible.scala:6: warning: method overrideMe in trait YourTrait references private[foo] trait Bippy.
+Classes which cannot access Bippy may be unable to override overrideMe.
+    def overrideMe[T <: Bippy](x: T): T = x
+        ^
+abstract-inaccessible.scala:7: warning: method overrideMeAlso in trait YourTrait references private[foo] trait Bippy.
+Classes which cannot access Bippy may be unable to override overrideMeAlso.
+    def overrideMeAlso(x: Map[Int, Set[Bippy]]) = 5
+        ^
+error: No warnings can be incurred under -Xfatal-warnings.
+three warnings found
+one error found

tests/untried/neg/abstract-inaccessible.flags

@@ -0,0 +1 @@
+-Xfatal-warnings -Xlint

tests/untried/neg/abstract-inaccessible.scala

@@ -0,0 +1,9 @@
+package foo {
+  private[foo] trait Bippy { }
+
+  trait YourTrait {
+    def implementMe(f: Int => (String, Bippy)): Unit
+    def overrideMe[T <: Bippy](x: T): T = x
+    def overrideMeAlso(x: Map[Int, Set[Bippy]]) = 5
+  }
+}

tests/untried/neg/abstract-report.check

@@ -0,0 +1,24 @@
+abstract-report.scala:1: error: class Unimplemented needs to be abstract, since:
+it has 12 unimplemented members.
+/** As seen from class Unimplemented, the missing signatures are as follows.
+ *  For convenience, these are usable as stub implementations.
+ */
+  // Members declared in scala.collection.GenTraversableOnce
+  def isTraversableAgain: Boolean = ???
+  def toIterator: Iterator[String] = ???
+  def toStream: Stream[String] = ???
+
+  // Members declared in scala.collection.TraversableOnce
+  def copyToArray[B >: String](xs: Array[B],start: Int,len: Int): Unit = ???
+  def exists(p: String => Boolean): Boolean = ???
+  def find(p: String => Boolean): Option[String] = ???
+  def forall(p: String => Boolean): Boolean = ???
+  def foreach[U](f: String => U): Unit = ???
+  def hasDefiniteSize: Boolean = ???
+  def isEmpty: Boolean = ???
+  def seq: scala.collection.TraversableOnce[String] = ???
+  def toTraversable: Traversable[String] = ???
+
+class Unimplemented extends TraversableOnce[String] { }
+      ^
+one error found

tests/untried/neg/abstract-report.scala

@@ -0,0 +1 @@
+class Unimplemented extends TraversableOnce[String] { }

tests/untried/neg/abstract-report2.check

@@ -0,0 +1,103 @@
+abstract-report2.scala:3: error: class Foo needs to be abstract, since:
+it has 13 unimplemented members.
+/** As seen from class Foo, the missing signatures are as follows.
+ *  For convenience, these are usable as stub implementations.
+ */
+  def add(x$1: Int): Boolean = ???
+  def addAll(x$1: java.util.Collection[_ <: Int]): Boolean = ???
+  def clear(): Unit = ???
+  def contains(x$1: Any): Boolean = ???
+  def containsAll(x$1: java.util.Collection[_]): Boolean = ???
+  def isEmpty(): Boolean = ???
+  def iterator(): java.util.Iterator[Int] = ???
+  def remove(x$1: Any): Boolean = ???
+  def removeAll(x$1: java.util.Collection[_]): Boolean = ???
+  def retainAll(x$1: java.util.Collection[_]): Boolean = ???
+  def size(): Int = ???
+  def toArray[T](x$1: Array[T with Object]): Array[T with Object] = ???
+  def toArray(): Array[Object] = ???
+
+class Foo extends Collection[Int]
+      ^
+abstract-report2.scala:5: error: class Bar needs to be abstract, since:
+it has 13 unimplemented members.
+/** As seen from class Bar, the missing signatures are as follows.
+ *  For convenience, these are usable as stub implementations.
+ */
+  def add(x$1: List[_ <: String]): Boolean = ???
+  def addAll(x$1: java.util.Collection[_ <: List[_ <: String]]): Boolean = ???
+  def clear(): Unit = ???
+  def contains(x$1: Any): Boolean = ???
+  def containsAll(x$1: java.util.Collection[_]): Boolean = ???
+  def isEmpty(): Boolean = ???
+  def iterator(): java.util.Iterator[List[_ <: String]] = ???
+  def remove(x$1: Any): Boolean = ???
+  def removeAll(x$1: java.util.Collection[_]): Boolean = ???
+  def retainAll(x$1: java.util.Collection[_]): Boolean = ???
+  def size(): Int = ???
+  def toArray[T](x$1: Array[T with Object]): Array[T with Object] = ???
+  def toArray(): Array[Object] = ???
+
+class Bar extends Collection[List[_ <: String]]
+      ^
+abstract-report2.scala:7: error: class Baz needs to be abstract, since:
+it has 13 unimplemented members.
+/** As seen from class Baz, the missing signatures are as follows.
+ *  For convenience, these are usable as stub implementations.
+ */
+  def add(x$1: T): Boolean = ???
+  def addAll(x$1: java.util.Collection[_ <: T]): Boolean = ???
+  def clear(): Unit = ???
+  def contains(x$1: Any): Boolean = ???
+  def containsAll(x$1: java.util.Collection[_]): Boolean = ???
+  def isEmpty(): Boolean = ???
+  def iterator(): java.util.Iterator[T] = ???
+  def remove(x$1: Any): Boolean = ???
+  def removeAll(x$1: java.util.Collection[_]): Boolean = ???
+  def retainAll(x$1: java.util.Collection[_]): Boolean = ???
+  def size(): Int = ???
+  def toArray[T](x$1: Array[T with Object]): Array[T with Object] = ???
+  def toArray(): Array[Object] = ???
+
+class Baz[T] extends Collection[T]
+      ^
+abstract-report2.scala:15: error: class Dingus needs to be abstract, since:
+it has 24 unimplemented members.
+/** As seen from class Dingus, the missing signatures are as follows.
+ *  For convenience, these are usable as stub implementations.
+ */
+  // Members declared in java.util.Collection
+  def add(x$1: String): Boolean = ???
+  def addAll(x$1: java.util.Collection[_ <: String]): Boolean = ???
+  def clear(): Unit = ???
+  def contains(x$1: Any): Boolean = ???
+  def containsAll(x$1: java.util.Collection[_]): Boolean = ???
+  def iterator(): java.util.Iterator[String] = ???
+  def remove(x$1: Any): Boolean = ???
+  def removeAll(x$1: java.util.Collection[_]): Boolean = ???
+  def retainAll(x$1: java.util.Collection[_]): Boolean = ???
+  def toArray[T](x$1: Array[T with Object]): Array[T with Object] = ???
+  def toArray(): Array[Object] = ???
+
+  // Members declared in scala.collection.GenTraversableOnce
+  def isTraversableAgain: Boolean = ???
+  def toIterator: Iterator[(Set[Int], String)] = ???
+  def toStream: Stream[(Set[Int], String)] = ???
+
+  // Members declared in scala.collection.TraversableOnce
+  def copyToArray[B >: (Set[Int], String)](xs: Array[B],start: Int,len: Int): Unit = ???
+  def exists(p: ((Set[Int], String)) => Boolean): Boolean = ???
+  def find(p: ((Set[Int], String)) => Boolean): Option[(Set[Int], String)] = ???
+  def forall(p: ((Set[Int], String)) => Boolean): Boolean = ???
+  def foreach[U](f: ((Set[Int], String)) => U): Unit = ???
+  def hasDefiniteSize: Boolean = ???
+  def isEmpty: Boolean = ???
+  def seq: scala.collection.TraversableOnce[(Set[Int], String)] = ???
+  def toTraversable: Traversable[(Set[Int], String)] = ???
+
+  // Members declared in Xyz
+  def foo(x: List[Int]): Boolean = ???
+
+class Dingus extends Bippy[String, Set[Int], List[Int]]
+      ^
+four errors found

tests/untried/neg/abstract-report2.scala

@@ -0,0 +1,15 @@
+import java.util.Collection
+
+class Foo extends Collection[Int]
+
+class Bar extends Collection[List[_ <: String]]
+
+class Baz[T] extends Collection[T]
+
+trait Xyz[T] {
+  def foo(x: T): Boolean
+}
+
+trait Bippy[T1, T2, T3] extends Collection[T1] with TraversableOnce[(T2, String)] with Xyz[T3]
+
+class Dingus extends Bippy[String, Set[Int], List[Int]]

tests/untried/neg/abstract-vars.check

@@ -0,0 +1,21 @@
+abstract-vars.scala:5: error: class Fail1 needs to be abstract, since variable x is not defined
+(Note that variables need to be initialized to be defined)
+class Fail1 extends A {
+      ^
+abstract-vars.scala:9: error: class Fail2 needs to be abstract, since variable x in class A of type Int is not defined
+(Note that variables need to be initialized to be defined)
+class Fail2 extends A { }
+      ^
+abstract-vars.scala:11: error: class Fail3 needs to be abstract, since variable x in class A of type Int is not defined
+(Note that an abstract var requires a setter in addition to the getter)
+class Fail3 extends A {
+      ^
+abstract-vars.scala:14: error: class Fail4 needs to be abstract, since variable x in class A of type Int is not defined
+(Note that an abstract var requires a setter in addition to the getter)
+class Fail4 extends A {
+      ^
+abstract-vars.scala:18: error: class Fail5 needs to be abstract, since variable x in class A of type Int is not defined
+(Note that an abstract var requires a getter in addition to the setter)
+class Fail5 extends A {
+      ^
+5 errors found

tests/untried/neg/abstract-vars.scala

@@ -0,0 +1,29 @@
+abstract class A {
+  var x: Int
+}
+
+class Fail1 extends A {
+  var x: Int
+}
+
+class Fail2 extends A { }
+
+class Fail3 extends A {
+  val x: Int = 5
+}
+class Fail4 extends A {
+  def x: Int = 5
+}
+
+class Fail5 extends A {
+  def x_=(y: Int) = ()
+}
+
+class Success1 extends A {
+  val x: Int = 5
+  def x_=(y: Int) = ()
+}
+
+class Success2 extends A {
+  var x: Int = 5
+}

tests/untried/neg/abstract.check

@@ -0,0 +1,11 @@
+abstract.scala:6: error: type mismatch;
+ found   : A
+ required: A.this.T
+  def foo2: T = bar().baz();
+                         ^
+abstract.scala:9: error: type mismatch;
+ found   : A
+ required: A.this.T
+  def foo5: T = baz().baz();
+                         ^
+two errors found

tests/untried/neg/abstract.scala

@@ -0,0 +1,11 @@
+trait A {
+  type T <: A;
+  def baz(): A;
+  def bar(): T;
+  def foo1: A = bar().bar();
+  def foo2: T = bar().baz();
+  def foo3 = bar().baz();
+  def foo4: A = baz().bar();
+  def foo5: T = baz().baz();
+  def foo6 = baz().baz();
+}

tests/untried/neg/abstraction-from-volatile-type-error.check

@@ -0,0 +1,4 @@
+abstraction-from-volatile-type-error.scala:9: error: illegal abstraction from value with volatile type a.Tv
+    val tv : a.Tv
+        ^
+one error found

tests/untried/neg/abstraction-from-volatile-type-error.scala

@@ -0,0 +1,11 @@
+class A {
+  type T
+  type Tv = AnyRef with T
+}
+
+object Test {
+  type B = a.type forSome {
+    val a : A
+    val tv : a.Tv
+  }
+}

tests/untried/neg/accesses.check

@@ -0,0 +1,17 @@
+accesses.scala:23: error: overriding method f2 in class A of type ()Unit;
+ method f2 has weaker access privileges; it should not be private
+  private def f2(): Unit = ()
+              ^
+accesses.scala:24: error: overriding method f3 in class A of type ()Unit;
+ method f3 has weaker access privileges; it should be at least protected
+  private[p2] def f3(): Unit = ()
+                  ^
+accesses.scala:25: error: overriding method f4 in class A of type ()Unit;
+ method f4 has weaker access privileges; it should be at least private[p1]
+  private[p2] def f4(): Unit
+                  ^
+accesses.scala:26: error: overriding method f5 in class A of type ()Unit;
+ method f5 has weaker access privileges; it should be at least protected[p1]
+  protected[p2] def f5(): Unit
+                    ^
+four errors found