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 = {
@@ -161,6 +162,48 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
     results.reduceLeft(_ && _)
   }
 
+  property("mappings must be equal") = forAllNoShrink(collectionPairs) { case (t, coll) =>
+    val results = for ((f, ind) <- mapFunctions.zipWithIndex) yield {
+      val ms = t.map(f)
+      val mp = coll.map(f)
+      val invs = checkDataStructureInvariants(ms, mp)
+      if (!areEqual(ms, mp) || !invs) {
+        println(t)
+        println(coll)
+        println("mapped to: ")
+        println(ms)
+        println(mp)
+        println("sizes: ")
+        println(ms.size)
+        println(mp.size)
+        println("valid: " + invs)
+      }
+      ("op index: " + ind) |: (areEqual(ms, mp) && invs)
+    }
+    results.reduceLeft(_ && _)
+  }
+
+  property("collects must be equal") = forAllNoShrink(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") = forAllNoShrink(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") = forAllNoShrink(collectionPairs) { case (t, coll) =>
     (for ((p, ind) <- filterPredicates.zipWithIndex) yield {
       val tf = t.filter(p)
@@ -311,6 +354,38 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
     }).reduceLeft(_ && _)
   }
 
+  property("++s must be equal") = forAll(collectionTriplets) { case (t, coll, colltoadd) =>
+    try {
+      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) <- addAllIterables.zipWithIndex) yield {
+        val tadded = t ++ trav
+        val cadded = coll ++ trav
+        if (!areEqual(tadded, cadded)) {
+          println("----------------------")
+          println("from: " + t)
+          println("and: " + coll)
+          println("adding: " + trav)
+          println(tadded)
+          println(cadded)
+        }
+        ("traversable " + ind) |: areEqual(tadded, cadded)
+      }).reduceLeft(_ && _)
+    } catch {
+      case e: java.lang.Exception =>
+        throw e
+    }
+  }
+
   if (hasStrictOrder) property("copies to array must be equal") = forAllNoShrink(collectionPairs) { case (t, coll) =>
     val tarr = newArray(t.size)
     val collarr = newArray(coll.size)
@@ -362,84 +437,3 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
   }
 
 }
-
-/**
-  * 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)
-      val mp = coll.map(f)
-      val invs = checkDataStructureInvariants(ms, mp)
-      if (!areEqual(ms, mp) || !invs) {
-        println(t)
-        println(coll)
-        println("mapped to: ")
-        println(ms)
-        println(mp)
-        println("sizes: ")
-        println(ms.size)
-        println(mp.size)
-        println("valid: " + invs)
-      }
-      ("op index: " + ind) |: (areEqual(ms, mp) && invs)
-    }
-    results.reduceLeft(_ && _)
-  }
-
-  property("collects must be equal") = forAllNoShrink(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") = 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) =>
-    try {
-      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) <- addAllIterables.zipWithIndex) yield {
-        val tadded = t ++ trav
-        val cadded = coll ++ trav
-        if (!areEqual(tadded, cadded)) {
-          println("----------------------")
-          println("from: " + t)
-          println("and: " + coll)
-          println("adding: " + trav)
-          println(tadded)
-          println(cadded)
-        }
-        ("traversable " + ind) |: areEqual(tadded, cadded)
-      }).reduceLeft(_ && _)
-    } catch {
-      case e: java.lang.Exception =>
-        throw e
-    }
-  }
-
-}

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]