diff options
Diffstat (limited to 'test/disabled')
-rw-r--r-- | test/disabled/pos/spec-traits.scala | 83 | ||||
-rw-r--r-- | test/disabled/pos/t1254/t1254.java | 28 | ||||
-rw-r--r-- | test/disabled/run/stream_length.check | 1 | ||||
-rw-r--r-- | test/disabled/run/stream_length.scala | 15 | ||||
-rw-r--r-- | test/disabled/run/t2946/Parsers.scala | 4 | ||||
-rw-r--r-- | test/disabled/run/t2946/ResponseCommon.scala | 14 | ||||
-rw-r--r-- | test/disabled/run/t2946/Test.scala | 7 | ||||
-rw-r--r-- | test/disabled/scalacheck/redblack.scala | 157 |
8 files changed, 309 insertions, 0 deletions
diff --git a/test/disabled/pos/spec-traits.scala b/test/disabled/pos/spec-traits.scala new file mode 100644 index 0000000000..9e339a14ad --- /dev/null +++ b/test/disabled/pos/spec-traits.scala @@ -0,0 +1,83 @@ +trait A[@specialized(Int) T] { def foo: T } +class B extends A[Int] { val foo = 10 } +class C extends B + +// issue 3309 +class Lazy { + def test[U](block: => U): Unit = { block } + + test { lazy val x = 1 } +} + +// issue 3307 +class Bug3307 { + def f[Z](block: String => Z) { + block("abc") + } + + ({ () => + f { implicit x => println(x) } })() +} + +// issue 3301 + trait T[X] + +class Bug3301 { + def t[A]: T[A] = error("stub") + + () => { + type X = Int + + def foo[X] = t[X] + () + } +} +// issue 3299 +object Failure { + def thunk() { + for (i <- 1 to 2) { + val Array(a, b) = Array(1,2) + () + } + } +} + +// issue 3296 + +object AA +{ + def f(block: => Unit) {} + + object BB + { + f { + object CC + + () + } + } + + def foo[T](x: T) = { object A; false } +} + +// issue 3292 +import scala.swing._ +import scala.swing.GridBagPanel._ + +object Grid { + + def later(code : => Unit) = + javax.swing.SwingUtilities.invokeLater(new Runnable { def run { code }}) + + def test = later { + val frame = new Dialog { + contents = new GridBagPanel { + val c = new Constraints + } + } + } + +} + +// issue 3325 +object O { def f[@specialized T] { for(k <- Nil: List[T]) { } } } diff --git a/test/disabled/pos/t1254/t1254.java b/test/disabled/pos/t1254/t1254.java new file mode 100644 index 0000000000..25b733cf28 --- /dev/null +++ b/test/disabled/pos/t1254/t1254.java @@ -0,0 +1,28 @@ +/* Taken from ticket #1254. Tests Java signatures in mirror classes and that + Nothing is translated to Nothing$. +*/ + +import scala.None; + +// This compiles with javac but fails with Eclipse java compiler: +// 'The type scala.Nothing cannot be resolved. It is indirectly referenced from required .class files' +class NothingBug3 { + public NothingBug3() { + scala.Option<?> o = scala.None$.MODULE$; + + test(o); + None.toLeft(new scala.Function0<Integer>() { + public Integer apply() { return 0; } + }); + } + + public <T>void test(scala.Option<T> f) {} +} + +// This compiles with javac but fails with Eclipse java compiler: +// 'The type scala.Nothing cannot be resolved. It is indirectly referenced from required .class files' +class NothingBug4 { + public NothingBug4() { + scala.Option o = scala.None$.MODULE$; + } +} diff --git a/test/disabled/run/stream_length.check b/test/disabled/run/stream_length.check new file mode 100644 index 0000000000..9906de773c --- /dev/null +++ b/test/disabled/run/stream_length.check @@ -0,0 +1 @@ +Length: 970299 diff --git a/test/disabled/run/stream_length.scala b/test/disabled/run/stream_length.scala new file mode 100644 index 0000000000..68e9cad5ac --- /dev/null +++ b/test/disabled/run/stream_length.scala @@ -0,0 +1,15 @@ + + +object Test { + def walk(depth: Int, bias: String): Stream[String] = { + if (depth == 0) + Stream(bias) + else { + Stream.concat(Stream.range(1, 100).map((x: Int) => walk(depth-1, bias + x))) + } + } + + def main(args: Array[String]) { + println("Length: " + walk(3, "---").length) + } +} diff --git a/test/disabled/run/t2946/Parsers.scala b/test/disabled/run/t2946/Parsers.scala new file mode 100644 index 0000000000..c0961034c4 --- /dev/null +++ b/test/disabled/run/t2946/Parsers.scala @@ -0,0 +1,4 @@ +class Parser { + def parse(t: Any): Unit = { + } +} diff --git a/test/disabled/run/t2946/ResponseCommon.scala b/test/disabled/run/t2946/ResponseCommon.scala new file mode 100644 index 0000000000..fa9d8acccb --- /dev/null +++ b/test/disabled/run/t2946/ResponseCommon.scala @@ -0,0 +1,14 @@ +trait ResponseCommon extends Parser { + private[this] var paramsParser: Parser = null + def withParamsParser(parser: Parser) = {paramsParser = parser; this} + + class Foo { + println(paramsParser) + } + + override abstract def parse(t: Any): Unit = t match { + case ("params", value: List[_]) => value.foreach {paramsParser.parse(_)} + case _ => super.parse(t) + } +} + diff --git a/test/disabled/run/t2946/Test.scala b/test/disabled/run/t2946/Test.scala new file mode 100644 index 0000000000..e9d9896a0e --- /dev/null +++ b/test/disabled/run/t2946/Test.scala @@ -0,0 +1,7 @@ +class Test extends Parser with ResponseCommon + +object Test { + def main(args: Array[String]) { + new Test + } +} diff --git a/test/disabled/scalacheck/redblack.scala b/test/disabled/scalacheck/redblack.scala new file mode 100644 index 0000000000..0334c1218d --- /dev/null +++ b/test/disabled/scalacheck/redblack.scala @@ -0,0 +1,157 @@ +import org.scalacheck._ +import Prop._ +import Gen._ + +/* +Properties of a Red & Black Tree: + +A node is either red or black. +The root is black. (This rule is used in some definitions and not others. Since the +root can always be changed from red to black but not necessarily vice-versa this +rule has little effect on analysis.) +All leaves are black. +Both children of every red node are black. +Every simple path from a given node to any of its descendant leaves contains the same number of black nodes. +*/ + +abstract class RedBlackTest extends Properties("RedBlack") { + object RedBlackTest extends scala.collection.immutable.RedBlack[Int] { + def isSmaller(x: Int, y: Int) = x < y + } + + import RedBlackTest._ + + def rootIsBlack[A](t: Tree[A]) = t.isBlack + + def areAllLeavesBlack[A](t: Tree[A]): Boolean = t match { + case Empty => t.isBlack + case ne: NonEmpty[_] => List(ne.left, ne.right) forall areAllLeavesBlack + } + + def areRedNodeChildrenBlack[A](t: Tree[A]): Boolean = t match { + case RedTree(_, _, left, right) => List(left, right) forall (t => t.isBlack && areRedNodeChildrenBlack(t)) + case BlackTree(_, _, left, right) => List(left, right) forall areRedNodeChildrenBlack + case Empty => true + } + + def blackNodesToLeaves[A](t: Tree[A]): List[Int] = t match { + case Empty => List(1) + case BlackTree(_, _, left, right) => List(left, right) flatMap blackNodesToLeaves map (_ + 1) + case RedTree(_, _, left, right) => List(left, right) flatMap blackNodesToLeaves + } + + def areBlackNodesToLeavesEqual[A](t: Tree[A]): Boolean = t match { + case Empty => true + case ne: NonEmpty[_] => + ( + blackNodesToLeaves(ne).removeDuplicates.size == 1 + && areBlackNodesToLeavesEqual(ne.left) + && areBlackNodesToLeavesEqual(ne.right) + ) + } + + def orderIsPreserved[A](t: Tree[A]): Boolean = t match { + case Empty => true + case ne: NonEmpty[_] => + ( + (ne.left.iterator map (_._1) forall (isSmaller(_, ne.key))) + && (ne.right.iterator map (_._1) forall (isSmaller(ne.key, _))) + && (List(ne.left, ne.right) forall orderIsPreserved) + ) + } + + def setup(l: List[Int], invariant: Tree[Unit] => Boolean): (Boolean, Tree[Unit]) + + def listNoRepetitions(size: Int) = for { + s <- Gen.choose(1, size) + l <- Gen.listOfN(size, Gen.choose(0, Int.MaxValue)) suchThat (l => l.size == l.removeDuplicates.size) + } yield l + def listFewRepetitions(size: Int) = for { + s <- Gen.choose(1, size) + l <- Gen.listOfN(s, Gen.choose(0, size * 4)) suchThat (l => l.size != l.removeDuplicates.size) + } yield l + def listManyRepetitions(size: Int) = for { + s <- Gen.choose(1, size) + l <- Gen.listOfN(s, Gen.choose(0, size)) suchThat (l => l.size != l.removeDuplicates.size) + } yield l + def listEvenRepetitions(size: Int) = listFewRepetitions(size) map (x => + scala.util.Random.shuffle(x zip x flatMap { case (a, b) => List(a, b) }) + ) + + // Arbitrarily weighted list distribution types + val seqType: Gen[Int => Gen[List[Int]]] + + def myGen(sized: Int) = for { + size <- Gen.choose(0, sized) + seq <- seqType + list <- seq(size) + } yield list + + property("root is black") = forAll(myGen(10)) { l => + setup(l, rootIsBlack)._1 :| setup(l, rootIsBlack)._2.toString + } + property("all leaves are black") = forAll(myGen(50)) { l => + setup(l, areAllLeavesBlack)._1 :| setup(l, areAllLeavesBlack)._2.toString + } + property("children of red nodes are black") = forAll(myGen(50)) { l => + setup(l, areRedNodeChildrenBlack)._1 :| setup(l, areRedNodeChildrenBlack)._2.toString + } + property("Every path from a node to its descendant leaves contains the same number of black nodes") = forAll(myGen(50)) { l => + setup(l, areBlackNodesToLeavesEqual)._1 :| setup(l, areBlackNodesToLeavesEqual)._2.toString + } + property("Ordering of keys is preserved") = forAll(myGen(50)) { l => + setup(l, orderIsPreserved)._1 :| setup(l, orderIsPreserved)._2.toString + } +} + +object TestInsertion extends RedBlackTest { + import RedBlackTest._ + override val seqType = Gen.frequency( + (1, listNoRepetitions _), + (1, listManyRepetitions _) + ) + + property("update adds elements") = forAll(myGen(50)) { l => + val tree = l.foldLeft(Empty: Tree[Unit])((acc, n) => acc update (n, ())) + forAll(Gen.pick(1, l)) ( n => !(tree lookup n.head isEmpty) :| "Tree: "+tree+" N: "+n.head ) + } + + override def setup(l: List[Int], invariant: Tree[Unit] => Boolean) = l.foldLeft((true, Empty: Tree[Unit])) { + case ((true, acc), n) => + val newRoot = acc update (n, ()) + (invariant(newRoot), newRoot) + case (failed, _) => failed + } +} + +object TestDeletion extends RedBlackTest { + import RedBlackTest._ + override val seqType = Gen.frequency( + (2, listFewRepetitions _), + (3, listManyRepetitions _), + (1, listEvenRepetitions _) + ) + + property("delete removes elements") = forAll(myGen(50)) { l => + val tree = l.foldLeft(Empty: Tree[Unit])((acc, n) => acc update (n, ())) + forAll(Gen.choose(1, l.size)) { numberOfElementsToRemove => + forAll(Gen.pick(numberOfElementsToRemove, l)) { elementsToRemove => + val newTree = elementsToRemove.foldLeft(tree)((acc, n) => acc delete n) + (elementsToRemove forall (n => newTree lookup n isEmpty)) :| "Tree: "+tree+"New Tree: "+newTree+" Elements to Remove: "+elementsToRemove + } + } + } + + override def setup(l: List[Int], invariant: Tree[Unit] => Boolean) = l.foldLeft((true, Empty: Tree[Unit])) { + case ((true, acc), n) => + val newRoot = if (acc lookup n isEmpty) acc update (n, ()) else acc delete n + (invariant(newRoot), newRoot) + case (failed, _) => failed + } +} + +object Test extends Properties("RedBlack") { + include(TestInsertion) + include(TestDeletion) +} + |