Restore tests transforming maps to iterables

Author: julienrf

core/src/main/scala/scala/collection/parallel/mutable/ParHashMap.scala

@@ -177,7 +177,7 @@ extends scala.collection.parallel.BucketCombiner[(K, V), ParHashMap[K, V], Defau
       buckets(pos) = new UnrolledBuffer[DefaultEntry[K, V]]()
     }
     // add to bucket
-    buckets(pos) += new DefaultEntry[K, V](elem._1, elem._2)
+    buckets(pos) += new DefaultEntry(elem._1, elem._2)
     this
   }
 
@@ -202,9 +202,7 @@ extends scala.collection.parallel.BucketCombiner[(K, V), ParHashMap[K, V], Defau
     var i = 0
     while (i < ParHashMapCombiner.numblocks) {
       if (buckets(i) ne null) {
-        for (elem <- buckets(i)) {
-          table.insertEntry(elem)
-        }
+        for (elem <- buckets(i)) table.insertEntry(elem)
       }
       i += 1
     }

scalacheck/src/test/scala/ParallelIterableCheck.scala

@@ -74,9 +74,10 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
       val am1: Map[Any, Any] = m1.asInstanceOf[Map[Any, Any]]
       val am2: ParMap[Any, Any] = m2.asInstanceOf[ParMap[Any, Any]]
       am1.forall { case (k, v) => am2.get(k).contains(v) } && am2.forall { case (k, v) => am1.get(k).contains(v) }
-    case (i1: Set[T], i2: ParSet[T]) =>
-      i1.forall(i2) && i2.forall(i1)
-    case _ => t1.iterator.sameElements(t2) && t2.sameElements(t1)
+    case _ =>
+      val s1 = t1.toSet
+      val s2 = t2.toSet
+      s1.forall(s2) && s2.forall(s1)
   }
 
   def printDebugInfo[A, CC[X] <: ParIterable[X], C <: ParIterable[A], S <: Iterable[A] with IterableOps[A, Iterable, S]](coll: ParIterableLike[A, CC, C, S]): Unit = {
@@ -361,13 +362,6 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
       }).reduceLeft(_ && _)
   }
 
-}
-
-/**
-  * Properties for collections whose elements are single values (as opposed to pairs of values)
-  */
-trait SimpleValuesCheck[T] { this: ParallelIterableCheck[T] =>
-
   property("mappings must be equal") = forAllNoShrink(collectionPairs) { case (t, coll) =>
     val results = for ((f, ind) <- mapFunctions.zipWithIndex) yield {
       val ms = t.map(f)

scalacheck/src/test/scala/ParallelMapCheck1.scala

@@ -30,10 +30,10 @@ abstract class ParallelMapCheck[K, V](collname: String) extends ParallelIterable
       (iterable.to(Map), parmap, seq)
     }
 
-  // The following tests have been copied from `SimpleValuesCheck`, and adapted to test
+  // The following tests have been copied from `ParIterableCheck`, and adapted to test
   // overloads of the methods that return Map and ParMap collections
-  property("mappings must be equal") = forAll/*NoShrink*/(collectionPairs) { case (t, coll) =>
-    val results = for ((f, ind) <- mapFunctions.zipWithIndex) yield {
+  property("mappings returning maps must be equal") = forAll/*NoShrink*/(collectionPairs) { case (t, coll) =>
+    val results = for ((f, ind) <- mapFunctions.zipWithIndex.take(5)) yield {
       val ms: Map[K, V] = t.map(f)
       val mp: ParMap[K, V] = coll.map(f)
       val invs = checkDataStructureInvariants(ms, mp)
@@ -53,7 +53,7 @@ abstract class ParallelMapCheck[K, V](collname: String) extends ParallelIterable
     results.reduceLeft(_ && _)
   }
 
-  property("collects must be equal") = forAllNoShrink(collectionPairs) { case (t, coll) =>
+  property("collects returning maps must be equal") = forAllNoShrink(collectionPairs) { case (t, coll) =>
     val results = for ((f, ind) <- partialMapFunctions.zipWithIndex) yield {
       val ps: Map[K, V] = t.collect(f)
       val pp: ParMap[K, V] = coll.collect(f)
@@ -69,12 +69,12 @@ abstract class ParallelMapCheck[K, V](collname: String) extends ParallelIterable
     results.reduceLeft(_ && _)
   }
 
-  property("flatMaps must be equal") = forAllNoShrink(collectionPairs) { case (t, coll) =>
+  property("flatMaps returning maps must be equal") = forAllNoShrink(collectionPairs) { case (t, coll) =>
     (for ((f, ind) <- flatMapFunctions.zipWithIndex)
       yield ("op index: " + ind) |: areEqual(t.flatMap(f), coll.flatMap(f))).reduceLeft(_ && _)
   }
 
-  property("++s must be equal") = forAll(collectionTriplets) { case (t, coll, colltoadd) =>
+  property("++s returning maps must be equal") = forAll(collectionTriplets) { case (t, coll, colltoadd) =>
     try {
       val toadd = colltoadd
       val tr: Map[K, V] = t ++ toadd.iterator

scalacheck/src/test/scala/ParallelSeqCheck.scala

@@ -10,7 +10,7 @@ import scala.collection._
 import scala.collection.parallel._
 
 abstract class ParallelSeqCheck[T](collName: String) extends ParallelIterableCheck[T](collName)
-  with SeqOperators[T] with SimpleValuesCheck[T] {
+  with SeqOperators[T] {
 
   type CollType <: collection.parallel.ParSeq[T]
 

scalacheck/src/test/scala/ParallelSetCheck.scala

@@ -9,8 +9,7 @@ import org.scalacheck.Properties
 import scala.collection._
 import scala.collection.parallel._
 
-abstract class ParallelSetCheck[T](collname: String) extends ParallelIterableCheck[T](collname)
-  with SimpleValuesCheck[T] {
+abstract class ParallelSetCheck[T](collname: String) extends ParallelIterableCheck[T](collname) {
 
   type CollType <: ParSet[T]