From 9334ad0db28f62c3e1d33d6b12e03720a76fb1eb Mon Sep 17 00:00:00 2001
From: Aleksandar Pokopec <aleksandar.prokopec@epfl.ch>
Date: Wed, 13 Apr 2011 16:32:01 +0000
Subject: Fixed some tests, renamed from Any to Gen.

No review.
---
 test/files/neg/t3774.check                                          | 4 ++--
 test/files/pos/spec-List.scala                                      | 2 +-
 test/files/run/pc-conversions.scala                                 | 6 +++---
 .../scalacheck/parallel-collections/ParallelIterableCheck.scala     | 6 +++---
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/test/files/neg/t3774.check b/test/files/neg/t3774.check
index a3953133bc..ea35c50541 100644
--- a/test/files/neg/t3774.check
+++ b/test/files/neg/t3774.check
@@ -1,6 +1,6 @@
 t3774.scala:4: error: overloaded method value ++ with alternatives:
-  [B1 >: List[Int]](xs: scala.collection.AnyTraversableOnce[((Int, Int), B1)])scala.collection.immutable.Map[(Int, Int),B1] <and>
-  [B >: ((Int, Int), List[Int]),That](that: scala.collection.AnyTraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.Map[(Int, Int),List[Int]],B,That])That
+  [B1 >: List[Int]](xs: scala.collection.GenTraversableOnce[((Int, Int), B1)])scala.collection.immutable.Map[(Int, Int),B1] <and>
+  [B >: ((Int, Int), List[Int]),That](that: scala.collection.GenTraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.Map[(Int, Int),List[Int]],B,That])That
  cannot be applied to (scala.collection.immutable.IndexedSeq[((Int, Int), scala.collection.immutable.Range.Inclusive)])
   Map[(Int,Int),List[Int]]() ++ (for(x <- 0 to 1 ; y <- 0 to 1) yield {(x,y)-> (0 to 1)})
                              ^
diff --git a/test/files/pos/spec-List.scala b/test/files/pos/spec-List.scala
index 6a39632451..04ab7d1543 100644
--- a/test/files/pos/spec-List.scala
+++ b/test/files/pos/spec-List.scala
@@ -144,7 +144,7 @@ sealed trait List[@specialized +A] extends LinearSeq[A]
   /** Create a new list which contains all elements of this list
    *  followed by all elements of Traversable `that'
    */
-  override def ++[B >: A, That](xs: AnyTraversableOnce[B])(implicit bf: CanBuildFrom[List[A], B, That]): That = {
+  override def ++[B >: A, That](xs: GenTraversableOnce[B])(implicit bf: CanBuildFrom[List[A], B, That]): That = {
     val b = bf(this)
     if (b.isInstanceOf[ListBuffer[_]]) (this ::: xs.toList).asInstanceOf[That]
     else super.++(xs)
diff --git a/test/files/run/pc-conversions.scala b/test/files/run/pc-conversions.scala
index 64e0720572..8f6a7744d9 100644
--- a/test/files/run/pc-conversions.scala
+++ b/test/files/run/pc-conversions.scala
@@ -53,9 +53,9 @@ object Test {
 
   def assertSeq[T](pc: parallel.ParIterable[T]) = assert(pc.seq == pc)
 
-  def assertPar[T, P <: Parallel](xs: AnyIterable[T]) = assert(xs == xs.par)
+  def assertPar[T, P <: Parallel](xs: GenIterable[T]) = assert(xs == xs.par)
 
-  def assertToPar[K, V](xs: AnyTraversable[(K, V)]) {
+  def assertToPar[K, V](xs: GenTraversable[(K, V)]) {
     xs match {
       case _: Seq[_] =>
         assert(xs.toIterable.par == xs)
@@ -73,7 +73,7 @@ object Test {
     assert(xs.par.toMap == xs.toMap)
   }
 
-  def assertToParWoMap[T](xs: AnySeq[T]) {
+  def assertToParWoMap[T](xs: GenSeq[T]) {
     assert(xs.toIterable.par == xs.toIterable)
     assert(xs.par.toIterable == xs.toIterable)
 
diff --git a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
index bdab66449d..ac3493e56c 100644
--- a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
@@ -71,11 +71,11 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
     (inst, fromTraversable(inst), modif)
   }
 
-  def areEqual(t1: AnyTraversable[T], t2: AnyTraversable[T]) = if (hasStrictOrder) {
+  def areEqual(t1: GenTraversable[T], t2: GenTraversable[T]) = if (hasStrictOrder) {
     t1 == t2 && t2 == t1
   } else (t1, t2) match { // it is slightly delicate what `equal` means if the order is not strict
-    case (m1: AnyMap[_, _], m2: AnyMap[_, _]) => m1 == m2 && m2 == m1
-    case (i1: AnyIterable[_], i2: AnyIterable[_]) =>
+    case (m1: GenMap[_, _], m2: GenMap[_, _]) => m1 == m2 && m2 == m1
+    case (i1: GenIterable[_], i2: GenIterable[_]) =>
       val i1s = i1.toSet
       val i2s = i2.toSet
       i1s == i2s && i2s == i1s
-- 
cgit v1.2.3