Migrate ++ operator

Uncomment all tests for ParIterable, except those that depend on ParMap.

Author: julienrf

core/src/main/scala/scala/collection/parallel/ParIterableLike.scala

@@ -582,13 +582,11 @@ self =>
   def filterNot(pred: T => Boolean): Repr = {
     tasksupport.executeAndWaitResult(new FilterNot(pred, combinerFactory, splitter) mapResult { _.resultWithTaskSupport })
   }
-/*
-  def ++[U >: T, That](that: GenTraversableOnce[U])(implicit bf: OldCanBuildFrom[Repr, U, That]): That = {
-    if (that.isParallel && bf.isParallel) {
+
+  def ++[U >: T](that: IterableOnce[U]): CC[U] = that match {
+    case other: ParIterable[U] =>
       // println("case both are parallel")
-      val other = that.asParIterable
-      val pbf = bf.asParallel
-      val cfactory = combinerFactory(() => pbf(repr))
+      val cfactory = combinerFactory(() => companion.newCombiner[U])
       val copythis = new Copy(cfactory, splitter)
       val copythat = wrap {
         val othtask = new other.Copy(cfactory, other.splitter)
@@ -598,24 +596,17 @@ self =>
         _.resultWithTaskSupport
       }
       tasksupport.executeAndWaitResult(task)
-    } else if (bf(repr).isCombiner) {
+    case _ =>
       // println("case parallel builder, `that` not parallel")
-      val copythis = new Copy(combinerFactory(() => bf(repr).asCombiner), splitter)
+      val copythis = new Copy(combinerFactory(() => companion.newCombiner[U]), splitter)
       val copythat = wrap {
-        val cb = bf(repr).asCombiner
-        for (elem <- that.seq) cb += elem
+        val cb = companion.newCombiner[U]
+        cb ++= that
         cb
       }
       tasksupport.executeAndWaitResult((copythis parallel copythat) { _ combine _ } mapResult { _.resultWithTaskSupport })
-    } else {
-      // println("case not a parallel builder")
-      val b = bf(repr)
-      this.splitter.copy2builder[U, That, Builder[U, That]](b)
-      for (elem <- that.seq) b += elem
-      setTaskSupport(b.result(), tasksupport)
-    }
   }
-*/
+
   def partition(pred: T => Boolean): (Repr, Repr) = {
     tasksupport.executeAndWaitResult(
       new Partition(pred, combinerFactory, combinerFactory, splitter) mapResult {

scalacheck/src/test/scala/ParallelIterableCheck.scala

@@ -67,16 +67,17 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
     (inst, fromIterable(inst), modif)
   }
 
-//  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: GenMap[_, _], m2: GenMap[_, _]) => m1 == m2 && m2 == m1
+  def areEqual(t1: Iterable[T], t2: ParIterable[T]) = if (hasStrictOrder) {
+    t1.iterator.sameElements(t2) && t2.sameElements(t1)
+  } else (t1, t2) match { // it is slightly delicate what `equal` means if the order is not strict
+// TODO uncomment and update that part of the implementation when ParMap and ParSet are migrated
+//    case (m1: Map[_, _], m2: ParMap[_, _]) => m1 == m2 && m2 == m1
 //    case (i1: GenIterable[_], i2: GenIterable[_]) =>
 //      val i1s = i1.toSet
 //      val i2s = i2.toSet
 //      i1s == i2s && i2s == i1s
-//    case _ => t1 == t2 && t2 == t1
-//  }
+    case _ => t1.iterator.sameElements(t2) && t2.sameElements(t1)
+  }
 
   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 = {
     println("Collection debug info: ")
@@ -160,47 +161,47 @@ 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("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("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("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 {
@@ -353,37 +354,37 @@ 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) <- (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(_ && _)
-//    } catch {
-//      case e: java.lang.Exception =>
-//        throw e
-//    }
-//  }
+  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 ++ 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(_ && _)
+    } 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)