Mostly refactored existing test functionality f...

Mostly refactored existing test functionality for parallel collections.
Added immutable hash set tests.

No review.

11 files changed, 516 insertions, 276 deletions

diff --git a/test/files/scalacheck/parallel-collections/IntOperators.scala b/test/files/scalacheck/parallel-collections/IntOperators.scala
index bd937808db..2b7e0191a2 100644
--- a/test/files/scalacheck/parallel-collections/IntOperators.scala
+++ b/test/files/scalacheck/parallel-collections/IntOperators.scala
@@ -5,7 +5,7 @@ import scala.collection.parallel._
 
 
 trait IntOperators extends Operators[Int] {
-  def reduceOperators = List(_ + _, _ * _, Math.min(_, _), Math.max(_, _))
+  def reduceOperators = List(_ + _, _ * _, math.min(_, _), math.max(_, _))
   def countPredicates = List(_ >= 0, _ < 0, _ < 50, _ < 500, _ < 5000, _ < 50000, _ % 2 == 0, _ == 99)
   def forallPredicates = List(_ >= 0, _ < 0, _ % 2 == 0, _ != 55, _ != 505, _ != 5005)
   def existsPredicates = List(_ >= 0, _ < 0, _ % 2 == 0, _ == 55, _ == 505, _ == 5005)
@@ -34,7 +34,7 @@ trait IntOperators extends Operators[Int] {
   def foldArguments = List(
       (0, _ + _),
       (1, _ * _),
-      (Int.MinValue, Math.max(_, _))
+      (Int.MinValue, math.max(_, _))
       )
   def addAllTraversables = List(
       List[Int](),
diff --git a/test/files/scalacheck/parallel-collections/IntValues.scala b/test/files/scalacheck/parallel-collections/IntValues.scala
index b9263a2bbc..cab60ead76 100644
--- a/test/files/scalacheck/parallel-collections/IntValues.scala
+++ b/test/files/scalacheck/parallel-collections/IntValues.scala
@@ -21,6 +21,9 @@ trait IntValues {
       arbitrary[Int] suchThat (_ < 0),
       choose(0, 0),
       choose(0, 10),
-      choose(0, 100)
+      choose(0, 100),
+      choose(0, 1000) suchThat (_ % 2 == 0),
+      choose(0, 1000) suchThat (_ % 2 != 0),
+      choose(0, 1000) suchThat (n => (n % 2 == 0) || (n % 3 == 0))
       )
 }
diff --git a/test/files/scalacheck/parallel-collections/ParallelArrayCheck.scala b/test/files/scalacheck/parallel-collections/ParallelArrayCheck.scala
index 01e40ed62b..019e8c4fde 100644
--- a/test/files/scalacheck/parallel-collections/ParallelArrayCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelArrayCheck.scala
@@ -24,7 +24,7 @@ abstract class ParallelArrayCheck[T](tp: String) extends ParallelSeqCheck[T]("Pa
 
   def hasStrictOrder = true
 
-  def instances(vals: Seq[Gen[T]]): Gen[Seq[T]] = sized { sz =>
+  def ofSize(vals: Seq[Gen[T]], sz: Int) = {
     val a = new mutable.ArrayBuffer[T](sz)
     val gen = vals(rnd.nextInt(vals.size))
     for (i <- 0 until sz) a += sample(gen)
diff --git a/test/files/scalacheck/parallel-collections/ParallelHashMapCheck.scala b/test/files/scalacheck/parallel-collections/ParallelHashMapCheck.scala
index 51c35140dd..5278d28f0f 100644
--- a/test/files/scalacheck/parallel-collections/ParallelHashMapCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelHashMapCheck.scala
@@ -1,5 +1,5 @@
 package scala.collection.parallel
-package immutable
+package mutable
 
 
 
@@ -14,7 +14,7 @@ import scala.collection._
 import scala.collection.parallel.ops._
 
 
-abstract class ParallelHashMapCheck[K, V](tp: String) extends ParallelMapCheck[K, V]("immutable.ParHashMap[" + tp + "]") {
+abstract class ParallelHashMapCheck[K, V](tp: String) extends ParallelMapCheck[K, V]("mutable.ParHashMap[" + tp + "]") {
   ForkJoinTasks.defaultForkJoinPool.setMaximumPoolSize(Runtime.getRuntime.availableProcessors * 2)
   ForkJoinTasks.defaultForkJoinPool.setParallelism(Runtime.getRuntime.availableProcessors * 2)
 
@@ -24,15 +24,15 @@ abstract class ParallelHashMapCheck[K, V](tp: String) extends ParallelMapCheck[K
 
   def hasStrictOrder = false
 
-  def instances(vals: Seq[Gen[(K, V)]]): Gen[Iterable[(K, V)]] = sized { sz =>
-    var hm = new immutable.HashMap[K, V]
+  def ofSize(vals: Seq[Gen[(K, V)]], sz: Int) = {
+    val hm = new mutable.HashMap[K, V]
     val gen = vals(rnd.nextInt(vals.size))
     for (i <- 0 until sz) hm += sample(gen)
     hm
   }
 
   def fromTraversable(t: Traversable[(K, V)]) = {
-    var phm = new ParHashMap[K, V]
+    val phm = new ParHashMap[K, V]
     var i = 0
     for (kv <- t.toList) {
       phm += kv
@@ -58,7 +58,7 @@ with PairValues[Int, Int]
 
   override def printDataStructureDebugInfo(ds: AnyRef) = ds match {
     case pm: ParHashMap[k, v] =>
-      pm.printDebugInfo
+      println("Mutable parallel hash map")
     case _ =>
       println("could not match data structure type: " + ds.getClass)
   }
diff --git a/test/files/scalacheck/parallel-collections/ParallelHashTrieCheck.scala b/test/files/scalacheck/parallel-collections/ParallelHashTrieCheck.scala
new file mode 100644
index 0000000000..10329c19f2
--- /dev/null
+++ b/test/files/scalacheck/parallel-collections/ParallelHashTrieCheck.scala
@@ -0,0 +1,138 @@
+package scala.collection.parallel
+package immutable
+
+
+
+import org.scalacheck._
+import org.scalacheck.Gen
+import org.scalacheck.Gen._
+import org.scalacheck.Prop._
+import org.scalacheck.Properties
+import org.scalacheck.Arbitrary._
+
+import scala.collection._
+import scala.collection.parallel.ops._
+
+
+abstract class ParallelHashMapCheck[K, V](tp: String) extends ParallelMapCheck[K, V]("immutable.ParHashMap[" + tp + "]") {
+  ForkJoinTasks.defaultForkJoinPool.setMaximumPoolSize(Runtime.getRuntime.availableProcessors * 2)
+  ForkJoinTasks.defaultForkJoinPool.setParallelism(Runtime.getRuntime.availableProcessors * 2)
+
+  type CollType = ParHashMap[K, V]
+
+  def isCheckingViews = false
+
+  def hasStrictOrder = false
+
+  def ofSize(vals: Seq[Gen[(K, V)]], sz: Int) = {
+    var hm = new immutable.HashMap[K, V]
+    val gen = vals(rnd.nextInt(vals.size))
+    for (i <- 0 until sz) hm += sample(gen)
+    hm
+  }
+
+  def fromTraversable(t: Traversable[(K, V)]) = {
+    var phm = new ParHashMap[K, V]
+    var i = 0
+    for (kv <- t.toList) {
+      phm += kv
+      i += 1
+    }
+    phm
+  }
+
+}
+
+
+object IntIntParallelHashMapCheck extends ParallelHashMapCheck[Int, Int]("Int, Int")
+with PairOperators[Int, Int]
+with PairValues[Int, Int]
+{
+  def intvalues = new IntValues {}
+  def kvalues = intvalues.values
+  def vvalues = intvalues.values
+
+  val intoperators = new IntOperators {}
+  def voperators = intoperators
+  def koperators = intoperators
+
+  override def printDataStructureDebugInfo(ds: AnyRef) = ds match {
+    case pm: ParHashMap[k, v] =>
+      pm.printDebugInfo
+    case _ =>
+      println("could not match data structure type: " + ds.getClass)
+  }
+}
+
+
+
+abstract class ParallelHashSetCheck[T](tp: String) extends ParallelSetCheck[T]("immutable.ParHashSet[" + tp + "]") {
+  ForkJoinTasks.defaultForkJoinPool.setMaximumPoolSize(Runtime.getRuntime.availableProcessors * 2)
+  ForkJoinTasks.defaultForkJoinPool.setParallelism(Runtime.getRuntime.availableProcessors * 2)
+
+  type CollType = ParHashSet[T]
+
+  def isCheckingViews = false
+
+  def hasStrictOrder = false
+
+  def ofSize(vals: Seq[Gen[T]], sz: Int) = {
+    var hm = new immutable.HashSet[T]
+    val gen = vals(rnd.nextInt(vals.size))
+    for (i <- 0 until sz) hm += sample(gen)
+    hm
+  }
+
+  def fromTraversable(t: Traversable[T]) = {
+    var phm = new ParHashSet[T]
+    var i = 0
+    for (kv <- t.toList) {
+      phm += kv
+      i += 1
+    }
+    phm
+  }
+
+  override def printDataStructureDebugInfo(ds: AnyRef) = ds match {
+    case pm: ParHashSet[t] =>
+      println("Parallel hash set")
+    case _ =>
+      println("could not match data structure type: " + ds.getClass)
+  }
+
+}
+
+
+object IntParallelHashSetCheck extends ParallelHashSetCheck[Int]("Int")
+with IntOperators
+with IntValues
+{
+  def intvalues = new IntValues {}
+  def kvalues = intvalues.values
+  def vvalues = intvalues.values
+
+  override def printDataStructureDebugInfo(ds: AnyRef) = ds match {
+    case pm: ParHashMap[k, v] =>
+      pm.printDebugInfo
+    case _ =>
+      println("could not match data structure type: " + ds.getClass)
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
index ea42e5efa3..52edf9e641 100644
--- a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
@@ -18,11 +18,20 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
   type CollType <: ParIterable[T] with Sequentializable[T, Iterable[T]]
 
   def values: Seq[Gen[T]]
-  def instances(valgens: Seq[Gen[T]]): Gen[Traversable[T]]
+  def ofSize(vals: Seq[Gen[T]], sz: Int): Iterable[T]
   def fromTraversable(t: Traversable[T]): CollType
   def isCheckingViews: Boolean
   def hasStrictOrder: Boolean
 
+
+  def instances(vals: Seq[Gen[T]]): Gen[Iterable[T]] = oneOf(
+    sized(
+      sz =>
+      ofSize(vals, sz)
+    ),
+    for (sz <- choose(1000, 2000)) yield ofSize(vals, sz)
+  )
+
   def printDataStructureDebugInfo(cf: AnyRef) {
     // can be overridden in subclasses
   }
@@ -57,269 +66,278 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
   property("reductions must be equal for assoc. operators") = forAll(collectionPairs) { case (t, coll) =>
     if (t.size != 0) {
       val results = for ((op, ind) <- reduceOperators.zipWithIndex) yield {
-        ("op index: " + ind) |: t.reduceLeft(op) == coll.reduce(op)
+        val tr = t.reduceLeft(op)
+        val cr = coll.reduce(op)
+        if (tr != cr) {
+          println("from: " + t)
+          println("and: " + coll)
+          println("reducing with " + ind)
+          println(tr)
+          println(cr)
+        }
+        ("op index: " + ind) |: tr == cr
       }
       results.reduceLeft(_ && _)
     } else "has size 0" |: true
   }
 
-  property("counts must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    val results = for ((pred, ind) <- countPredicates.zipWithIndex) yield {
-      val tc = t.count(pred)
-      val cc = coll.count(pred)
-      if (tc != cc) {
-        println("from: " + t)
-        println("and: " + coll.toList)
-        println(tc)
-        println(cc)
-      }
-      ("op index: " + ind) |: tc == cc
-    }
-    results.reduceLeft(_ && _)
-  }
-
-  property("forall must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    val results = for ((pred, ind) <- forallPredicates.zipWithIndex)
-      yield ("op index: " + ind) |: t.forall(pred) == coll.forall(pred)
-    results.reduceLeft(_ && _)
-  }
-
-  property("exists must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    val results = for ((pred, ind) <- existsPredicates.zipWithIndex)
-      yield ("op index: " + ind) |: t.exists(pred) == coll.exists(pred)
-    results.reduceLeft(_ && _)
-  }
-
-  property("both must find or not find an element") = forAll(collectionPairs) { case (t, coll) =>
-    val results = for ((pred, ind) <- findPredicates.zipWithIndex) yield {
-      val ft = t.find(pred)
-      val fcoll = coll.find(pred)
-      ("op index: " + ind) |: ((ft == None && fcoll == None) || (ft != None && fcoll != None))
-    }
-    results.reduceLeft(_ && _)
-  }
-
-  def areEqual(t1: Traversable[T], t2: Traversable[T]) = if (hasStrictOrder) {
-    t1 == t2
-  } else (t1, t2) match { // it is slightly delicate what `equal` means if the order is not strict
-    case (m1: Map[_, _], m2: Map[_, _]) => m1 == m2
-    case (i1: Iterable[_], i2: Iterable[_]) => i1.toSet == i2.toSet
-    case _ => t1 == t2
-  }
-
-  property("mappings must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    val results = for ((f, ind) <- mapFunctions.zipWithIndex) yield {
-      val ms = t.map(f)
-      val mp = coll.map(f)
-      if (!areEqual(ms, mp)) {
-        println(t)
-        println(coll)
-        println("mapped to: ")
-        println(ms)
-        println(mp)
-      }
-      ("op index: " + ind) |: areEqual(ms, mp)
-    }
-    results.reduceLeft(_ && _)
-  }
-
-  property("collects must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    val results = for ((f, ind) <- partialMapFunctions.zipWithIndex) yield {
-      val ps = t.collect(f)
-      val pp = coll.collect(f)
-      if (!areEqual(ps, pp)) {
-        println(t)
-        println(coll)
-        println("collected to: ")
-        println(ps)
-        println(pp)
-      }
-      ("op index: " + ind) |: areEqual(ps, pp)
-    }
-    results.reduceLeft(_ && _)
-  }
-
-  property("flatMaps must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    (for ((f, ind) <- flatMapFunctions.zipWithIndex)
-      yield ("op index: " + ind) |: areEqual(t.flatMap(f), coll.flatMap(f))).reduceLeft(_ && _)
-  }
-
-  property("filters must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    (for ((p, ind) <- filterPredicates.zipWithIndex) yield {
-      val tf = t.filter(p)
-      val cf = coll.filter(p)
-      if (tf != cf || cf != tf) {
-        println(t)
-        println(coll)
-        println("filtered to:")
-        println(cf)
-        println(tf)
-        println("tf == cf - " + (tf == cf))
-        println("cf == tf - " + (cf == tf))
-        printDataStructureDebugInfo(cf)
-      }
-      ("op index: " + ind) |: tf == cf && cf == tf
-    }).reduceLeft(_ && _)
-  }
-
-  property("filterNots must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    (for ((p, ind) <- filterNotPredicates.zipWithIndex)
-      yield ("op index: " + ind) |: t.filterNot(p) == coll.filterNot(p)).reduceLeft(_ && _)
-  }
-
-  if (!isCheckingViews) property("partitions must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    (for ((p, ind) <- partitionPredicates.zipWithIndex) yield {
-      val tpart = t.partition(p)
-      val cpart = coll.partition(p)
-      if (tpart != cpart) {
-        println("from: " + t)
-        println("and: " + coll)
-        println(cpart)
-        println(tpart)
-      }
-      ("op index: " + ind) |: tpart == cpart
-    }).reduceLeft(_ && _)
-  }
-
-  if (hasStrictOrder) property("takes must be equal") = forAll(collectionPairsWithLengths) { case (t, coll, n) =>
-    ("take " + n + " elements") |: t.take(n) == coll.take(n)
-  }
-
-  if (hasStrictOrder) property("drops must be equal") = forAll(collectionPairsWithLengths) { case (t, coll, n) =>
-    ("drop " + n + " elements") |: t.drop(n) == coll.drop(n)
-  }
-
-  if (hasStrictOrder) property("slices must be equal") = forAll(collectionPairsWith2Indices)
-  { case (t, coll, fr, slicelength) =>
-    val from = if (fr < 0) 0 else fr
-    val until = if (from + slicelength > t.size) t.size else from + slicelength
-    val tsl = t.slice(from, until)
-    val collsl = coll.slice(from, until)
-    if (tsl != collsl) {
-      println("---------------------- " + from + ", " + until)
-      println("from: " + t)
-      println("and: " + coll)
-      println(tsl)
-      println(collsl)
-      println("as list: " + collsl.toList)
-      println(collsl.iterator.hasNext)
-      println(collsl.iterator.next)
-      println(collsl.iterator.hasNext)
-      println(collsl.iterator.next)
-      println(collsl.iterator.hasNext)
-      println(collsl.iterator.next)
-      println(collsl.iterator.hasNext)
-    }
-    ("slice from " + from + " until " + until) |: tsl == collsl
-  }
-
-  if (hasStrictOrder) property("splits must be equal") = forAll(collectionPairsWithLengths) { case (t, coll, n) =>
-    val tspl = t.splitAt(n)
-    val cspl = coll.splitAt(n)
-    if (tspl != cspl) {
-      println("at: " + n)
-      println("from: " + t)
-      println("and: " + coll)
-      println(tspl)
-      println(cspl)
-    }
-    ("splitAt " + n) |: tspl == cspl
-  }
-
-  if (hasStrictOrder) property("takeWhiles must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    (for ((pred, ind) <- takeWhilePredicates.zipWithIndex) yield {
-      val tt = t.takeWhile(pred)
-      val ct = coll.takeWhile(pred)
-      if (tt != ct) {
-        println("from: " + t)
-        println("and: " + coll)
-        println("taking while...")
-        println(tt)
-        println(ct)
-      }
-      ("operator " + ind) |: tt == ct
-    }).reduceLeft(_ && _)
-  }
-
-  if (hasStrictOrder) property("spans must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    (for ((pred, ind) <- spanPredicates.zipWithIndex) yield {
-      val tsp = t.span(pred)
-      val csp = coll.span(pred)
-      if (tsp != csp) {
-        println("from: " + t)
-        println("and: " + coll)
-        println("span with predicate " + ind)
-        println(tsp)
-        println(csp)
-        println("---------------------------------")
-        println(coll.span(pred))
-        println("---------------------------------")
-      }
-      ("operator " + ind) |: tsp == csp
-    }).reduceLeft(_ && _)
-  }
-
-  if (hasStrictOrder) property("dropWhiles must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    (for ((pred, ind) <- dropWhilePredicates.zipWithIndex) yield {
-      ("operator " + ind) |: t.dropWhile(pred) == coll.dropWhile(pred)
-    }).reduceLeft(_ && _)
-  }
-
-  property("folds must be equal for assoc. operators") = forAll(collectionPairs) { case (t, coll) =>
-    (for (((first, op), ind) <- foldArguments.zipWithIndex) yield {
-      val tres = t.foldLeft(first)(op)
-      val cres = coll.fold(first)(op)
-      if (cres != tres) {
-        println("from: " + t)
-        println("and: " + coll)
-        println("folds are: ")
-        println(tres)
-        println(cres)
-      }
-      ("operator " + ind) |: tres == cres
-    }).reduceLeft(_ && _)
-  }
-
-  property("++s must be equal") = forAll(collectionTriplets) { case (t, coll, colltoadd) =>
-    val toadd = colltoadd
-    val tr = t ++ toadd.iterator
-    val cr = coll ++ toadd.iterator
-    if (areEqual(tr, cr)) {
-      println("from: " + t)
-      println("and: " + coll.iterator.toList)
-      println("adding: " + toadd)
-      println(tr.toList)
-      println(cr.iterator.toList)
-    }
-    ("adding " |: areEqual(tr, cr)) &&
-    (for ((trav, ind) <- (addAllTraversables).zipWithIndex) yield {
-      val tadded = t ++ trav
-      val cadded = coll ++ collection.parallel.mutable.ParArray(trav.toSeq: _*)
-      if (!areEqual(tadded, cadded)) {
-        println("----------------------")
-        println("from: " + t)
-        println("and: " + coll)
-        println("adding: " + trav)
-        println(tadded)
-        println(cadded)
-      }
-      ("traversable " + ind) |: areEqual(tadded, cadded)
-    }).reduceLeft(_ && _)
-  }
-
-  if (hasStrictOrder) property("copies to array must be equal") = forAll(collectionPairs) { case (t, coll) =>
-    val tarr = newArray(t.size)
-    val collarr = newArray(coll.size)
-    t.copyToArray(tarr, 0, t.size)
-    coll.copyToArray(collarr, 0, coll.size)
-    if (tarr.toSeq != collarr.toSeq) {
-      println("from: " + t)
-      println("and: " + coll)
-      println(tarr.toSeq)
-      println(collarr.toSeq)
-    }
-    tarr.toSeq == collarr.toSeq
-  }
+  // property("counts must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   val results = for ((pred, ind) <- countPredicates.zipWithIndex) yield {
+  //     val tc = t.count(pred)
+  //     val cc = coll.count(pred)
+  //     if (tc != cc) {
+  //       println("from: " + t)
+  //       println("and: " + coll.toList)
+  //       println(tc)
+  //       println(cc)
+  //     }
+  //     ("op index: " + ind) |: tc == cc
+  //   }
+  //   results.reduceLeft(_ && _)
+  // }
+
+  // property("forall must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   val results = for ((pred, ind) <- forallPredicates.zipWithIndex)
+  //     yield ("op index: " + ind) |: t.forall(pred) == coll.forall(pred)
+  //   results.reduceLeft(_ && _)
+  // }
+
+  // property("exists must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   val results = for ((pred, ind) <- existsPredicates.zipWithIndex)
+  //     yield ("op index: " + ind) |: t.exists(pred) == coll.exists(pred)
+  //   results.reduceLeft(_ && _)
+  // }
+
+  // property("both must find or not find an element") = forAll(collectionPairs) { case (t, coll) =>
+  //   val results = for ((pred, ind) <- findPredicates.zipWithIndex) yield {
+  //     val ft = t.find(pred)
+  //     val fcoll = coll.find(pred)
+  //     ("op index: " + ind) |: ((ft == None && fcoll == None) || (ft != None && fcoll != None))
+  //   }
+  //   results.reduceLeft(_ && _)
+  // }
+
+  // def areEqual(t1: Traversable[T], t2: Traversable[T]) = if (hasStrictOrder) {
+  //   t1 == t2
+  // } else (t1, t2) match { // it is slightly delicate what `equal` means if the order is not strict
+  //   case (m1: Map[_, _], m2: Map[_, _]) => m1 == m2
+  //   case (i1: Iterable[_], i2: Iterable[_]) => i1.toSet == i2.toSet
+  //   case _ => t1 == t2
+  // }
+
+  // property("mappings must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   val results = for ((f, ind) <- mapFunctions.zipWithIndex) yield {
+  //     val ms = t.map(f)
+  //     val mp = coll.map(f)
+  //     if (!areEqual(ms, mp)) {
+  //       println(t)
+  //       println(coll)
+  //       println("mapped to: ")
+  //       println(ms)
+  //       println(mp)
+  //     }
+  //     ("op index: " + ind) |: areEqual(ms, mp)
+  //   }
+  //   results.reduceLeft(_ && _)
+  // }
+
+  // property("collects must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   val results = for ((f, ind) <- partialMapFunctions.zipWithIndex) yield {
+  //     val ps = t.collect(f)
+  //     val pp = coll.collect(f)
+  //     if (!areEqual(ps, pp)) {
+  //       println(t)
+  //       println(coll)
+  //       println("collected to: ")
+  //       println(ps)
+  //       println(pp)
+  //     }
+  //     ("op index: " + ind) |: areEqual(ps, pp)
+  //   }
+  //   results.reduceLeft(_ && _)
+  // }
+
+  // property("flatMaps must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   (for ((f, ind) <- flatMapFunctions.zipWithIndex)
+  //     yield ("op index: " + ind) |: areEqual(t.flatMap(f), coll.flatMap(f))).reduceLeft(_ && _)
+  // }
+
+  // property("filters must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   (for ((p, ind) <- filterPredicates.zipWithIndex) yield {
+  //     val tf = t.filter(p)
+  //     val cf = coll.filter(p)
+  //     if (tf != cf || cf != tf) {
+  //       println(t)
+  //       println(coll)
+  //       println("filtered to:")
+  //       println(cf)
+  //       println(tf)
+  //       println("tf == cf - " + (tf == cf))
+  //       println("cf == tf - " + (cf == tf))
+  //       printDataStructureDebugInfo(cf)
+  //     }
+  //     ("op index: " + ind) |: tf == cf && cf == tf
+  //   }).reduceLeft(_ && _)
+  // }
+
+  // property("filterNots must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   (for ((p, ind) <- filterNotPredicates.zipWithIndex)
+  //     yield ("op index: " + ind) |: t.filterNot(p) == coll.filterNot(p)).reduceLeft(_ && _)
+  // }
+
+  // if (!isCheckingViews) property("partitions must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   (for ((p, ind) <- partitionPredicates.zipWithIndex) yield {
+  //     val tpart = t.partition(p)
+  //     val cpart = coll.partition(p)
+  //     if (tpart != cpart) {
+  //       println("from: " + t)
+  //       println("and: " + coll)
+  //       println(cpart)
+  //       println(tpart)
+  //     }
+  //     ("op index: " + ind) |: tpart == cpart
+  //   }).reduceLeft(_ && _)
+  // }
+
+  // if (hasStrictOrder) property("takes must be equal") = forAll(collectionPairsWithLengths) { case (t, coll, n) =>
+  //   ("take " + n + " elements") |: t.take(n) == coll.take(n)
+  // }
+
+  // if (hasStrictOrder) property("drops must be equal") = forAll(collectionPairsWithLengths) { case (t, coll, n) =>
+  //   ("drop " + n + " elements") |: t.drop(n) == coll.drop(n)
+  // }
+
+  // if (hasStrictOrder) property("slices must be equal") = forAll(collectionPairsWith2Indices)
+  // { case (t, coll, fr, slicelength) =>
+  //   val from = if (fr < 0) 0 else fr
+  //   val until = if (from + slicelength > t.size) t.size else from + slicelength
+  //   val tsl = t.slice(from, until)
+  //   val collsl = coll.slice(from, until)
+  //   if (tsl != collsl) {
+  //     println("---------------------- " + from + ", " + until)
+  //     println("from: " + t)
+  //     println("and: " + coll)
+  //     println(tsl)
+  //     println(collsl)
+  //     println("as list: " + collsl.toList)
+  //     println(collsl.iterator.hasNext)
+  //     println(collsl.iterator.next)
+  //     println(collsl.iterator.hasNext)
+  //     println(collsl.iterator.next)
+  //     println(collsl.iterator.hasNext)
+  //     println(collsl.iterator.next)
+  //     println(collsl.iterator.hasNext)
+  //   }
+  //   ("slice from " + from + " until " + until) |: tsl == collsl
+  // }
+
+  // if (hasStrictOrder) property("splits must be equal") = forAll(collectionPairsWithLengths) { case (t, coll, n) =>
+  //   val tspl = t.splitAt(n)
+  //   val cspl = coll.splitAt(n)
+  //   if (tspl != cspl) {
+  //     println("at: " + n)
+  //     println("from: " + t)
+  //     println("and: " + coll)
+  //     println(tspl)
+  //     println(cspl)
+  //   }
+  //   ("splitAt " + n) |: tspl == cspl
+  // }
+
+  // if (hasStrictOrder) property("takeWhiles must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   (for ((pred, ind) <- takeWhilePredicates.zipWithIndex) yield {
+  //     val tt = t.takeWhile(pred)
+  //     val ct = coll.takeWhile(pred)
+  //     if (tt != ct) {
+  //       println("from: " + t)
+  //       println("and: " + coll)
+  //       println("taking while...")
+  //       println(tt)
+  //       println(ct)
+  //     }
+  //     ("operator " + ind) |: tt == ct
+  //   }).reduceLeft(_ && _)
+  // }
+
+  // if (hasStrictOrder) property("spans must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   (for ((pred, ind) <- spanPredicates.zipWithIndex) yield {
+  //     val tsp = t.span(pred)
+  //     val csp = coll.span(pred)
+  //     if (tsp != csp) {
+  //       println("from: " + t)
+  //       println("and: " + coll)
+  //       println("span with predicate " + ind)
+  //       println(tsp)
+  //       println(csp)
+  //       println("---------------------------------")
+  //       println(coll.span(pred))
+  //       println("---------------------------------")
+  //     }
+  //     ("operator " + ind) |: tsp == csp
+  //   }).reduceLeft(_ && _)
+  // }
+
+  // if (hasStrictOrder) property("dropWhiles must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   (for ((pred, ind) <- dropWhilePredicates.zipWithIndex) yield {
+  //     ("operator " + ind) |: t.dropWhile(pred) == coll.dropWhile(pred)
+  //   }).reduceLeft(_ && _)
+  // }
+
+  // property("folds must be equal for assoc. operators") = forAll(collectionPairs) { case (t, coll) =>
+  //   (for (((first, op), ind) <- foldArguments.zipWithIndex) yield {
+  //     val tres = t.foldLeft(first)(op)
+  //     val cres = coll.fold(first)(op)
+  //     if (cres != tres) {
+  //       println("from: " + t)
+  //       println("and: " + coll)
+  //       println("folds are: ")
+  //       println(tres)
+  //       println(cres)
+  //     }
+  //     ("operator " + ind) |: tres == cres
+  //   }).reduceLeft(_ && _)
+  // }
+
+  // property("++s must be equal") = forAll(collectionTriplets) { case (t, coll, colltoadd) =>
+  //   val toadd = colltoadd
+  //   val tr = t ++ toadd.iterator
+  //   val cr = coll ++ toadd.iterator
+  //   if (!areEqual(tr, cr)) {
+  //     println("from: " + t)
+  //     println("and: " + coll.iterator.toList)
+  //     println("adding: " + toadd)
+  //     println(tr.toList)
+  //     println(cr.iterator.toList)
+  //   }
+  //   ("adding " |: areEqual(tr, cr)) &&
+  //   (for ((trav, ind) <- (addAllTraversables).zipWithIndex) yield {
+  //     val tadded = t ++ trav
+  //     val cadded = coll ++ collection.parallel.mutable.ParArray(trav.toSeq: _*)
+  //     if (!areEqual(tadded, cadded)) {
+  //       println("----------------------")
+  //       println("from: " + t)
+  //       println("and: " + coll)
+  //       println("adding: " + trav)
+  //       println(tadded)
+  //       println(cadded)
+  //     }
+  //     ("traversable " + ind) |: areEqual(tadded, cadded)
+  //   }).reduceLeft(_ && _)
+  // }
+
+  // if (hasStrictOrder) property("copies to array must be equal") = forAll(collectionPairs) { case (t, coll) =>
+  //   val tarr = newArray(t.size)
+  //   val collarr = newArray(coll.size)
+  //   t.copyToArray(tarr, 0, t.size)
+  //   coll.copyToArray(collarr, 0, coll.size)
+  //   if (tarr.toSeq != collarr.toSeq) {
+  //     println("from: " + t)
+  //     println("and: " + coll)
+  //     println(tarr.toSeq)
+  //     println(collarr.toSeq)
+  //   }
+  //   tarr.toSeq == collarr.toSeq
+  // }
 
 }
 
diff --git a/test/files/scalacheck/parallel-collections/ParallelRangeCheck.scala b/test/files/scalacheck/parallel-collections/ParallelRangeCheck.scala
index d2a05a66c9..850a5d5473 100644
--- a/test/files/scalacheck/parallel-collections/ParallelRangeCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelRangeCheck.scala
@@ -27,7 +27,9 @@ object ParallelRangeCheck extends ParallelSeqCheck[Int]("ParallelRange[Int]") wi
 
   def isCheckingViews = false
 
-  def instances(vals: Seq[Gen[Int]]): Gen[Seq[Int]] = sized { start =>
+  def ofSize(vals: Seq[Gen[Int]], sz: Int) = unsupported
+
+  override def instances(vals: Seq[Gen[Int]]): Gen[Seq[Int]] = sized { start =>
     sized { end =>
       sized { step =>
         new Range(start, end, if (step != 0) step else 1)
diff --git a/test/files/scalacheck/parallel-collections/ParallelSeqCheck.scala b/test/files/scalacheck/parallel-collections/ParallelSeqCheck.scala
index 1fda4eb906..5e84f6c73e 100644
--- a/test/files/scalacheck/parallel-collections/ParallelSeqCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelSeqCheck.scala
@@ -19,8 +19,19 @@ abstract class ParallelSeqCheck[T](collName: String) extends ParallelIterableChe
 
   type CollType <: collection.parallel.ParSeq[T] with Sequentializable[T, Seq[T]]
 
-  def instances(vals: Seq[Gen[T]]): Gen[Seq[T]]
+
+  def ofSize(vals: Seq[Gen[T]], sz: Int): Seq[T]
   def fromSeq(s: Seq[T]): CollType
+
+  override def instances(vals: Seq[Gen[T]]): Gen[Seq[T]] = oneOf(
+    sized(
+      sz =>
+      ofSize(vals, sz)
+    ),
+    for (sz <- choose(1000, 2000)) yield ofSize(vals, sz)
+  )
+
+
   def fromTraversable(t: Traversable[T]) = fromSeq(traversable2Seq(t))
   def traversable2Seq(t: Traversable[T]): Seq[T] = {
     if (t.isInstanceOf[Iterable[_]]) t.asInstanceOf[Iterable[T]].iterator.toList else t.toList
diff --git a/test/files/scalacheck/parallel-collections/ParallelSetCheck.scala b/test/files/scalacheck/parallel-collections/ParallelSetCheck.scala
new file mode 100644
index 0000000000..092f4823df
--- /dev/null
+++ b/test/files/scalacheck/parallel-collections/ParallelSetCheck.scala
@@ -0,0 +1,62 @@
+package scala.collection.parallel
+
+
+
+import org.scalacheck._
+import org.scalacheck.Gen
+import org.scalacheck.Gen._
+import org.scalacheck.Prop._
+import org.scalacheck.Properties
+
+import scala.collection._
+import scala.collection.parallel._
+
+
+
+
+abstract class ParallelSetCheck[T](collname: String) extends ParallelIterableCheck[T](collname) {
+  type CollType <: ParSet[T] with Sequentializable[T, Set[T]]
+
+  property("gets iterated keys") = forAll(collectionPairs) {
+    case (t, coll) =>
+    val containsT = for (elem <- t) yield (coll.contains(elem))
+    val containsSelf = for (elem <- coll) yield (coll.contains(elem))
+    ("Par contains elements of seq map" |: containsT.forall(_ == true)) &&
+    ("Par contains elements of itself" |: containsSelf.forall(_ == true))
+  }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/test/files/scalacheck/parallel-collections/pc.scala b/test/files/scalacheck/parallel-collections/pc.scala
index 3e7ac8c33e..fe406a9408 100644
--- a/test/files/scalacheck/parallel-collections/pc.scala
+++ b/test/files/scalacheck/parallel-collections/pc.scala
@@ -17,12 +17,13 @@ class ParCollProperties extends Properties("Parallel collections") {
   //include(immutable.ParallelRangeCheck)
 
   // parallel immutable hash maps (tries)
-  include(immutable.IntIntParallelHashMapCheck)
+  //include(immutable.IntIntParallelHashMapCheck)
 
   // parallel immutable hash sets (tries)
+  //include(immutable.IntParallelHashSetCheck)
 
   // parallel mutable hash maps (tables)
-
+  include(mutable.IntIntParallelHashMapCheck)
 
   /*   Views   */
 
@@ -41,7 +42,10 @@ object Test {
       org.scalacheck.Test.Params(
         rng = new java.util.Random(5134L),
         testCallback = new ConsoleReporter(0),
-        workers = 1
+        workers = 1,
+        minSize = 0,
+        maxSize = 250,
+        minSuccessfulTests = 250
       ),
       pc
     )
diff --git a/tools/remotetest b/tools/remotetest
index 1e81f7e2c3..262749c810 100755
--- a/tools/remotetest
+++ b/tools/remotetest
@@ -211,11 +211,13 @@ then
 fi
 
 # run the build and tests
+SET_ANT_OPTS='export ANT_OPTS="-XX:MaxPermSize=192M -Xmx1536m"; echo $ANT_OPTS'
+echo "Set ant options command: $SET_ANT_OPTS"
 if [[ $LOGFILE != "" ]]
 then
-  ssh $USER@$LOCATION "cd $WORKREPO; ant test"
+  ssh $USER@$LOCATION "cd $WORKREPO; $SET_ANT_OPTS; ant test"
 else
-  ssh $USER@$LOCATION "cd $WORKREPO; ant test | tee -a $LOGFILE"
+  ssh $USER@$LOCATION "cd $WORKREPO; $SET_ANT_OPTS; ant test | tee -a $LOGFILE"
 fi
 
 success