From 93253a1b8ae4599f1459473798bd3f533d44b79a Mon Sep 17 00:00:00 2001 From: prokopec Date: Mon, 4 Oct 2010 14:05:35 +0000 Subject: [PATCH] Fixed a scalacheck test group "test entire subdirectory" problem. It's now possible to add scalacheck tests consisting of multiple files. No review. git-svn-id: http://lampsvn.epfl.ch/svn-repos/scala/scala/trunk@23183 5e8d7ff9-d8ef-0310-90f0-a4852d11357a --- build.xml | 4 +- .../scala/tools/partest/PartestTask.scala | 5 +- .../scala/tools/partest/nest/Worker.scala | 4 +- .../ParallelIterableCheck.scala | 304 ------------------ .../ParallelSeqCheck.scala | 302 ----------------- .../parallel-collections/IntOperators.scala | 0 .../parallel-collections/IntValues.scala | 0 .../parallel-collections/Operators.scala | 0 .../ParallelArrayCheck.scala | 10 +- .../ParallelArrayTest.scala | 0 .../ParallelArrayViewCheck.scala | 0 .../ParallelIterableCheck.scala | 304 ++++++++++++++++++ .../ParallelRangeCheck.scala | 0 .../ParallelSeqCheck.scala | 282 ++++++++++++++++ .../scalacheck}/parallel-collections/pc.scala | 6 +- test/files/scalacheck/scan.scala | 2 + 16 files changed, 605 insertions(+), 618 deletions(-) delete mode 100644 test/disabled/parallel-collections/ParallelIterableCheck.scala delete mode 100644 test/disabled/parallel-collections/ParallelSeqCheck.scala rename test/{disabled => files/scalacheck}/parallel-collections/IntOperators.scala (100%) rename test/{disabled => files/scalacheck}/parallel-collections/IntValues.scala (100%) rename test/{disabled => files/scalacheck}/parallel-collections/Operators.scala (100%) rename test/{disabled => files/scalacheck}/parallel-collections/ParallelArrayCheck.scala (83%) rename test/{disabled => files/scalacheck}/parallel-collections/ParallelArrayTest.scala (100%) rename test/{disabled => files/scalacheck}/parallel-collections/ParallelArrayViewCheck.scala (100%) create mode 100644 test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala rename test/{disabled => files/scalacheck}/parallel-collections/ParallelRangeCheck.scala (100%) create mode 100644 test/files/scalacheck/parallel-collections/ParallelSeqCheck.scala rename test/{disabled => files/scalacheck}/parallel-collections/pc.scala (54%) diff --git a/build.xml b/build.xml index c49b45e69..acfd406d0 100644 --- a/build.xml +++ b/build.xml @@ -1563,7 +1563,9 @@ BOOTRAPING TEST AND TEST SUITE - + + + diff --git a/src/partest/scala/tools/partest/PartestTask.scala b/src/partest/scala/tools/partest/PartestTask.scala index 3a6156292..24a5877af 100644 --- a/src/partest/scala/tools/partest/PartestTask.scala +++ b/src/partest/scala/tools/partest/PartestTask.scala @@ -162,10 +162,13 @@ class PartestTask extends Task with CompilationPathProperty { case None => Array() case Some(fs) => def shouldExclude(name: String) = (name endsWith ".obj") || (name startsWith ".") + // println("----> " + fileSet) val fileTests = getFiles(Some(fs)) filterNot (x => shouldExclude(x.getName)) val dirTests: Iterator[SPath] = fileSetToDir(fs).dirs filterNot (x => shouldExclude(x.name)) val dirResult = dirTests.toList.toArray map (_.jfile) + // println("dirs: " + dirResult.toList) + // println("files: " + fileTests.toList) dirResult ++ fileTests } @@ -176,7 +179,7 @@ class PartestTask extends Task with CompilationPathProperty { private def getJvmFiles = getFilesAndDirs(jvmFiles) private def getResidentFiles = getFiles(residentFiles) private def getBuildManagerFiles = getFilesAndDirs(buildManagerFiles) - private def getScalacheckFiles = getFiles(scalacheckFiles) + private def getScalacheckFiles = getFilesAndDirs(scalacheckFiles) private def getScriptFiles = getFiles(scriptFiles) private def getShootoutFiles = getFiles(shootoutFiles) private def getScalapFiles = getFiles(scalapFiles) diff --git a/src/partest/scala/tools/partest/nest/Worker.scala b/src/partest/scala/tools/partest/nest/Worker.scala index 8c8a653a3..93aba206d 100644 --- a/src/partest/scala/tools/partest/nest/Worker.scala +++ b/src/partest/scala/tools/partest/nest/Worker.scala @@ -69,14 +69,14 @@ class Worker(val fileManager: FileManager) extends Actor { def act() { react { case RunTests(kind, files) => - // NestUI.verbose("received "+files.length+" to test") + //NestUI.normal("received "+files.length+" to test") val master = sender runTests(kind, files) { results => master ! Results(results, createdLogFiles, createdOutputDirs) } } } - + def printInfoStart(file: File, printer: PrintWriter) { NestUI.outline("testing: ", printer) val filesdir = file.getAbsoluteFile.getParentFile.getParentFile diff --git a/test/disabled/parallel-collections/ParallelIterableCheck.scala b/test/disabled/parallel-collections/ParallelIterableCheck.scala deleted file mode 100644 index d9b0e5b41..000000000 --- a/test/disabled/parallel-collections/ParallelIterableCheck.scala +++ /dev/null @@ -1,304 +0,0 @@ -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 ParallelIterableCheck[T](collName: String) extends Properties(collName) with Operators[T] { - type CollType <: ParIterable[T] with Sequentializable[T, Iterable[T]] - - def values: Seq[Gen[T]] - def instances(valgens: Seq[Gen[T]]): Gen[Traversable[T]] - def fromTraversable(t: Traversable[T]): CollType - def isCheckingViews: Boolean - - val rnd = new scala.util.Random - - def sample(gen: Gen[T]): T = { - var s = gen.sample - while (s == None) s = gen.sample - s.get - } - - def sampleValue: T = sample(values(rnd.nextInt(values.length))) - - def collectionPairs = for (inst <- instances(values)) yield (inst, fromTraversable(inst)) - - def collectionPairsWithLengths = for (inst <- instances(values); s <- choose(0, inst.size)) - yield (inst, fromTraversable(inst), s) - - def collectionPairsWith2Indices = for ( - inst <- instances(values); - f <- choose(0, inst.size); - s <- choose(0, inst.size)) - yield (inst, fromTraversable(inst), f, s) - - def collectionTriplets = for (inst <- instances(values); - updStart <- choose(0, inst.size); howMany <- choose(0, inst.size)) yield { - val modif = inst.toSeq.patch(updStart, inst.toSeq, howMany) - (inst, fromTraversable(inst), modif) - } - - 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) - } - 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(_ && _) - } - - property("mappings must be equal") = forAll(collectionPairs) { case (t, coll) => - val results = for ((f, ind) <- mapFunctions.zipWithIndex) - yield ("op index: " + ind) |: t.map(f) == coll.map(f) - 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 (ps != pp) { - println(t) - println(coll) - println("partially mapped to: ") - println(ps) - println(pp) - } - ("op index: " + ind) |: ps == pp - } - results.reduceLeft(_ && _) - } - - property("flatMaps must be equal") = forAll(collectionPairs) { case (t, coll) => - (for ((f, ind) <- flatMapFunctions.zipWithIndex) - yield ("op index: " + ind) |: t.flatMap(f) == coll.flatMap(f)).reduceLeft(_ && _) - } - - property("filters must be equal") = forAll(collectionPairs) { case (t, coll) => - (for ((p, ind) <- filterPredicates.zipWithIndex) - yield ("op index: " + ind) |: t.filter(p) == coll.filter(p)).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(_ && _) - } - - property("takes must be equal") = forAll(collectionPairsWithLengths) { case (t, coll, n) => - ("take " + n + " elements") |: t.take(n) == coll.take(n) - } - - property("drops must be equal") = forAll(collectionPairsWithLengths) { case (t, coll, n) => - ("drop " + n + " elements") |: t.drop(n) == coll.drop(n) - } - - 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(tsl.asInstanceOf[Seq[T]].sameElements(collsl)) - 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 - } - - 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 - } - - property("takeWhiles must be equal") = forAll(collectionPairs) { case (t, coll) => - (for ((pred, ind) <- takeWhilePredicates.zipWithIndex) - yield ("operator " + ind) |: t.takeWhile(pred) == coll.takeWhile(pred)).reduceLeft(_ && _) - } - - 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(tsp) - println(csp) - } - ("operator " + ind) |: tsp == csp - }).reduceLeft(_ && _) - } - - 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 ("operator " + ind) |: t.foldLeft(first)(op) == coll.fold(first)(op)).reduceLeft(_ && _) - } - - property("++s must be equal") = forAll(collectionTriplets) { case (t, coll, colltoadd) => - val toadd = colltoadd - val tr = t ++ toadd - val cr = coll ++ fromTraversable(toadd).iterator - if (!tr.toList.iterator.sameElements(cr.iterator)) { - println("from: " + t) - println("and: " + coll.iterator.toList) - println("adding: " + toadd) - println(tr.toList) - println(cr.iterator.toList) - } - ("adding " |: tr == cr) && - (for ((trav, ind) <- (addAllTraversables).zipWithIndex) yield { - val tadded = t ++ trav - val cadded = coll ++ fromTraversable(trav.toList) - if (tadded != cadded) { - println("----------------------") - println("from: " + t) - println("and: " + coll.iterator.toList) - println("adding: " + trav) - println(tadded.toList) - println(cadded.iterator.toList) - } - ("traversable " + ind) |: (tadded) == (cadded) - }).reduceLeft(_ && _) - } - - 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/disabled/parallel-collections/ParallelSeqCheck.scala b/test/disabled/parallel-collections/ParallelSeqCheck.scala deleted file mode 100644 index 63e9be4e4..000000000 --- a/test/disabled/parallel-collections/ParallelSeqCheck.scala +++ /dev/null @@ -1,302 +0,0 @@ -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 ParallelSeqCheck[T](collName: String) extends ParallelIterableCheck[T](collName) with SeqOperators[T] { - - type CollType <: collection.parallel.ParSeq[T] with Sequentializable[T, Seq[T]] - - def instances(vals: Seq[Gen[T]]): Gen[Seq[T]] - def fromSeq(s: Seq[T]): CollType - 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 - } - - override def collectionPairs: Gen[(Seq[T], CollType)] = for (inst <- instances(values)) yield (inst, fromSeq(inst)) - - override def collectionPairsWithLengths: Gen[(Seq[T], CollType, Int)] = - for (inst <- instances(values); s <- choose(0, inst.size)) yield (inst, fromSeq(inst), s); - - def collectionPairsWithModifiedWithLengths: Gen[(Seq[T], CollType, ParSeq[T], Int)] = - for (inst <- instances(values); s <- choose(0, inst.size); - updateStart <- choose(0, inst.size); howMany <- choose(0, inst.size)) yield { - val parcoll = fromSeq(inst) - val parcollmodif = fromSeq(modifySlightly(inst, updateStart, howMany)) - (inst, parcoll, parcollmodif, s) - } - - def collectionPairsWithModified: Gen[(Seq[T], CollType, ParSeq[T])] = - for (inst <- instances(values); updateStart <- choose(0, inst.size); howMany <- choose(0, inst.size)) yield { - val parcoll = fromSeq(inst) - val parcollmodif = fromSeq(modifySlightly(inst, updateStart, howMany)) - (inst, parcoll, parcollmodif) - } - - def collectionPairsWithSliced: Gen[(Seq[T], CollType, ParSeq[T])] = - for (inst <- instances(values); sliceStart <- choose(0, inst.size); howMany <- choose(0, inst.size)) yield { - val parcoll = fromSeq(inst) - val parcollsliced = fromSeq(inst.slice(sliceStart, sliceStart + howMany)) - (inst, parcoll, parcollsliced) - } - - def collectionTripletsWith2Indices: Gen[(Seq[T], CollType, Seq[T], Int, Int)] = - for (inst <- instances(values); f <- choose(0, inst.size); s <- choose(0, inst.size); - third <- instances(values); sliceStart <- choose(0, inst.size); howMany <- choose(0, inst.size)) yield { - (inst, fromSeq(inst), inst.slice(sliceStart, sliceStart + howMany), f, s) - } - - private def modifySlightly(coll: Seq[T], updateStart: Int, howMany: Int) = { - coll.patch(updateStart, coll, howMany) - } - - property("segmentLengths must be equal") = forAll(collectionPairsWithLengths) { case (s, coll, len) => - (for ((pred, ind) <- segmentLengthPredicates.zipWithIndex) yield { - val slen = s.segmentLength(pred, if (len < 0) 0 else len) - val clen = coll.segmentLength(pred, len) - if (slen != clen) { - println("from: " + s) - println("and: " + coll) - println(slen) - println(clen) - } - ("operator " + ind) |: slen == clen - }).reduceLeft(_ && _) - } - - property("prefixLengths must be equal") = forAll(collectionPairs) { case (s, coll) => - (for ((pred, ind) <- segmentLengthPredicates.zipWithIndex) yield { - ("operator " + ind) |: s.prefixLength(pred) == coll.prefixLength(pred) - }).reduceLeft(_ && _) - } - - property("indexWheres must be equal") = forAll(collectionPairsWithLengths) { case (s, coll, len) => - (for ((pred, ind) <- indexWherePredicates.zipWithIndex) yield { - val sind = s.indexWhere(pred, len) - val cind = coll.indexWhere(pred, len) - if (sind != cind) { - println("from: " + s) - println("and: " + coll) - println("at: " + len) - println(sind) - println(cind) - } - ("operator " + ind) |: sind == cind - }).reduceLeft(_ && _) - } - - property("lastIndexWheres must be equal") = forAll(collectionPairsWithLengths) { case (s, coll, len) => - (for ((pred, ind) <- lastIndexWherePredicates.zipWithIndex) yield { - val end = if (len >= s.size) s.size - 1 else len - val sind = s.lastIndexWhere(pred, end) - val cind = coll.lastIndexWhere(pred, end) - ("operator " + ind) |: sind == cind - }).reduceLeft(_ && _) - } - - property("reverses must be equal") = forAll(collectionPairs) { case (s, coll) => - (s.length == 0 && s.getClass == classOf[collection.immutable.Range]) || - { - val sr = s.reverse - val cr = coll.reverse - if (sr != cr) { - println("from: " + s) - println("and: " + coll) - println(sr) - println(cr) - } - sr == cr - } - } - - property("reverseMaps must be equal") = forAll(collectionPairs) { case (s, coll) => - (for ((f, ind) <- reverseMapFunctions.zipWithIndex) yield { - ("operator " + ind) |: s.reverseMap(f) == coll.reverseMap(f) - }).reduceLeft(_ && _) - } - - property("sameElements must be equal") = forAll(collectionPairsWithModifiedWithLengths) { - case (s, coll, collmodif, len) => - val pos = if (len < 0) 0 else len - val scm = s.sameElements(collmodif) - val ccm = coll.sameElements(collmodif) - if (scm != ccm) { - println("Comparing: " + s) - println("and: " + coll) - println("with: " + collmodif) - println(scm) - println(ccm) - } - ("Nil" |: s.sameElements(Nil) == coll.sameElements(Nil)) && - ("toList" |: s.sameElements(s.toList) == coll.sameElements(coll.toList)) && - ("identity" |: s.sameElements(s.map(e => e)) == coll.sameElements(coll.map(e => e))) && - ("vice-versa" |: s.sameElements(coll) == coll.sameElements(s)) && - ("equal" |: s.sameElements(coll)) && - ("modified" |: scm == ccm) && - (for ((it, ind) <- sameElementsSeqs.zipWithIndex) yield { - val sres = s.sameElements(it) - val pres = coll.sameElements(it) - if (sres != pres) { - println("Comparing: " + s) - println("and: " + coll) - println("with: " + it) - println(sres) - println(pres) - } - ("collection " + ind) |: sres == pres - }).reduceLeft(_ && _) - } - - property("startsWiths must be equal") = forAll(collectionPairsWithModifiedWithLengths) { - case (s, coll, collmodif, len) => - val pos = if (len < 0) 0 else len - ("start with self" |: s.startsWith(s) == coll.startsWith(coll)) && - ("tails correspond" |: (s.length == 0 || s.startsWith(s.tail, 1) == coll.startsWith(coll.tail, 1))) && - ("with each other" |: coll.startsWith(s)) && - ("modified" |: s.startsWith(collmodif) == coll.startsWith(collmodif)) && - ("modified2" |: s.startsWith(collmodif, pos) == coll.startsWith(collmodif, pos)) && - (for (sq <- startEndSeqs) yield { - val ss = s.startsWith(sq, pos) - val cs = coll.startsWith(fromSeq(sq), pos) - if (ss != cs) { - println("from: " + s) - println("and: " + coll) - println("test seq: " + sq) - println("from pos: " + pos) - println(ss) - println(cs) - println(coll.iterator.psplit(pos, coll.length - pos)(1).toList) - } - ("seq " + sq) |: ss == cs - }).reduceLeft(_ && _) - } - - property("endsWiths must be equal") = forAll(collectionPairsWithModified) { - case (s, coll, collmodif) => - ("ends with self" |: s.endsWith(s) == coll.endsWith(s)) && - ("ends with tail" |: (s.length == 0 || s.endsWith(s.tail) == coll.endsWith(coll.tail))) && - ("with each other" |: coll.endsWith(s)) && - ("modified" |: s.startsWith(collmodif) == coll.endsWith(collmodif)) && - (for (sq <- startEndSeqs) yield { - val sew = s.endsWith(sq) - val cew = coll.endsWith(fromSeq(sq)) - if (sew != cew) { - println("from: " + s) - println("and: " + coll) - println(sew) - println(cew) - } - ("seq " + sq) |: sew == cew - }).reduceLeft(_ && _) - } - - property("unions must be equal") = forAll(collectionPairsWithModified) { case (s, coll, collmodif) => - ("modified" |: s.union(collmodif.seq) == coll.union(collmodif)) && - ("empty" |: s.union(Nil) == coll.union(fromSeq(Nil))) - } - -// if (!isCheckingViews) property("diffs must be equal") = forAll(collectionPairsWithSliced) { case (s, coll, collsliced) => -// val sdiffs = s.diff(s) -// val cdiffc = coll.diff(coll) -// ("self" |: sdiffs.toSet == cdiffc.toSet) -// ("sliced" |: s.diff(collsliced.seq).toSet == coll.diff(collsliced).toSet) && -// ("empty" |: s.diff(Nil).toSet == coll.diff(fromSeq(Nil)).toSet) -// } -// -// if (!isCheckingViews) property("intersections must be equal") = forAll(collectionPairsWithSliced) { case (s, coll, collsliced) => -// val sints = s.intersect(s).toSet -// val cintc = coll.intersect(coll).toSet -// ("self" |: sints == cintc) && -// ("sliced" |: s.intersect(collsliced.seq).toSet == coll.intersect(collsliced).toSet) && -// ("empty" |: s.intersect(Nil).toSet == coll.intersect(fromSeq(Nil)).toSet) -// } -// -// if (!isCheckingViews) property("removeDuplicates must be equal") = forAll(collectionPairs) { case (s, coll) => -// s.removeDuplicates.toSet == coll.removeDuplicates.toSet -// } - - if (!isCheckingViews) property("patches must be equal") = forAll(collectionTripletsWith2Indices) { - case (s, coll, pat, from, repl) => - ("with seq" |: s.patch(from, pat, repl) == coll.patch(from, pat, repl)) && - ("with par" |: s.patch(from, pat, repl) == coll.patch(from, fromSeq(pat), repl)) && - ("with empty" |: s.patch(from, Nil, repl) == coll.patch(from, fromSeq(Nil), repl)) && - ("with one" |: (s.length == 0 || s.patch(from, List(s(0)), 1) == coll.patch(from, fromSeq(List(coll(0))), 1))) - } - - if (!isCheckingViews) property("updates must be equal") = forAll(collectionPairsWithLengths) { case (s, coll, len) => - val pos = if (len >= s.length) s.length - 1 else len - if (s.length > 0) { - val supd = s.updated(pos, s(0)) - val cupd = coll.updated(pos, coll(0)) - if (supd != cupd) { - println("from: " + s) - println("and: " + coll) - println(supd) - println(cupd) - } - "from first" |: (supd == cupd) - } else "trivially" |: true - } - - property("prepends must be equal") = forAll(collectionPairs) { case (s, coll) => - s.length == 0 || s(0) +: s == coll(0) +: coll - } - - property("appends must be equal") = forAll(collectionPairs) { case (s, coll) => - s.length == 0 || s :+ s(0) == coll :+ coll(0) - } - - property("padTos must be equal") = forAll(collectionPairsWithLengths) { case (s, coll, len) => - val someValue = sampleValue - val sdoub = s.padTo(len * 2, someValue) - val cdoub = coll.padTo(len * 2, someValue) - if (sdoub != cdoub) { - println("from: " + s) - println("and: " + coll) - println(sdoub) - println(cdoub) - } - ("smaller" |: s.padTo(len / 2, someValue) == coll.padTo(len / 2, someValue)) && - ("bigger" |: sdoub == cdoub) - } - - property("corresponds must be equal") = forAll(collectionPairsWithModified) { case (s, coll, modified) => - val modifcut = modified.toSeq.slice(0, modified.length) - ("self" |: s.corresponds(s)(_ == _) == coll.corresponds(coll)(_ == _)) && - ("modified" |: s.corresponds(modified.seq)(_ == _) == coll.corresponds(modified)(_ == _)) && - ("modified2" |: s.corresponds(modifcut)(_ == _) == coll.corresponds(modifcut)(_ == _)) - } - -} - - - - - - - - - - - - - - - - - - - diff --git a/test/disabled/parallel-collections/IntOperators.scala b/test/files/scalacheck/parallel-collections/IntOperators.scala similarity index 100% rename from test/disabled/parallel-collections/IntOperators.scala rename to test/files/scalacheck/parallel-collections/IntOperators.scala diff --git a/test/disabled/parallel-collections/IntValues.scala b/test/files/scalacheck/parallel-collections/IntValues.scala similarity index 100% rename from test/disabled/parallel-collections/IntValues.scala rename to test/files/scalacheck/parallel-collections/IntValues.scala diff --git a/test/disabled/parallel-collections/Operators.scala b/test/files/scalacheck/parallel-collections/Operators.scala similarity index 100% rename from test/disabled/parallel-collections/Operators.scala rename to test/files/scalacheck/parallel-collections/Operators.scala diff --git a/test/disabled/parallel-collections/ParallelArrayCheck.scala b/test/files/scalacheck/parallel-collections/ParallelArrayCheck.scala similarity index 83% rename from test/disabled/parallel-collections/ParallelArrayCheck.scala rename to test/files/scalacheck/parallel-collections/ParallelArrayCheck.scala index baf35f252..08cfc4fdd 100644 --- a/test/disabled/parallel-collections/ParallelArrayCheck.scala +++ b/test/files/scalacheck/parallel-collections/ParallelArrayCheck.scala @@ -39,11 +39,11 @@ abstract class ParallelArrayCheck[T](tp: String) extends ParallelSeqCheck[T]("Pa pa } - property("array mappings must be equal") = forAll(collectionPairs) { case (t, coll) => - val results = for ((f, ind) <- mapFunctions.zipWithIndex) - yield ("op index: " + ind) |: t.map(f) == coll.map(f) - results.reduceLeft(_ && _) - } + // property("array mappings must be equal") = forAll(collectionPairs) { case (t, coll) => + // val results = for ((f, ind) <- mapFunctions.zipWithIndex) + // yield ("op index: " + ind) |: t.map(f) == coll.map(f) + // results.reduceLeft(_ && _) + // } } diff --git a/test/disabled/parallel-collections/ParallelArrayTest.scala b/test/files/scalacheck/parallel-collections/ParallelArrayTest.scala similarity index 100% rename from test/disabled/parallel-collections/ParallelArrayTest.scala rename to test/files/scalacheck/parallel-collections/ParallelArrayTest.scala diff --git a/test/disabled/parallel-collections/ParallelArrayViewCheck.scala b/test/files/scalacheck/parallel-collections/ParallelArrayViewCheck.scala similarity index 100% rename from test/disabled/parallel-collections/ParallelArrayViewCheck.scala rename to test/files/scalacheck/parallel-collections/ParallelArrayViewCheck.scala diff --git a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala new file mode 100644 index 000000000..12d31be8b --- /dev/null +++ b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala @@ -0,0 +1,304 @@ +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 ParallelIterableCheck[T](collName: String) extends Properties(collName) with Operators[T] { + type CollType <: ParIterable[T] with Sequentializable[T, Iterable[T]] + + def values: Seq[Gen[T]] + def instances(valgens: Seq[Gen[T]]): Gen[Traversable[T]] + def fromTraversable(t: Traversable[T]): CollType + def isCheckingViews: Boolean + + val rnd = new scala.util.Random + + def sample(gen: Gen[T]): T = { + var s = gen.sample + while (s == None) s = gen.sample + s.get + } + + def sampleValue: T = sample(values(rnd.nextInt(values.length))) + + def collectionPairs = for (inst <- instances(values)) yield (inst, fromTraversable(inst)) + + def collectionPairsWithLengths = for (inst <- instances(values); s <- choose(0, inst.size)) + yield (inst, fromTraversable(inst), s) + + def collectionPairsWith2Indices = for ( + inst <- instances(values); + f <- choose(0, inst.size); + s <- choose(0, inst.size)) + yield (inst, fromTraversable(inst), f, s) + + def collectionTriplets = for (inst <- instances(values); + updStart <- choose(0, inst.size); howMany <- choose(0, inst.size)) yield { + val modif = inst.toSeq.patch(updStart, inst.toSeq, howMany) + (inst, fromTraversable(inst), modif) + } + + // 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) + // } + // 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(_ && _) + // } + + // property("mappings must be equal") = forAll(collectionPairs) { case (t, coll) => + // val results = for ((f, ind) <- mapFunctions.zipWithIndex) + // yield ("op index: " + ind) |: t.map(f) == coll.map(f) + // 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 (ps != pp) { + // println(t) + // println(coll) + // println("partially mapped to: ") + // println(ps) + // println(pp) + // } + // ("op index: " + ind) |: ps == pp + // } + // results.reduceLeft(_ && _) + // } + + // property("flatMaps must be equal") = forAll(collectionPairs) { case (t, coll) => + // (for ((f, ind) <- flatMapFunctions.zipWithIndex) + // yield ("op index: " + ind) |: t.flatMap(f) == coll.flatMap(f)).reduceLeft(_ && _) + // } + + // property("filters must be equal") = forAll(collectionPairs) { case (t, coll) => + // (for ((p, ind) <- filterPredicates.zipWithIndex) + // yield ("op index: " + ind) |: t.filter(p) == coll.filter(p)).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(_ && _) + // } + + // property("takes must be equal") = forAll(collectionPairsWithLengths) { case (t, coll, n) => + // ("take " + n + " elements") |: t.take(n) == coll.take(n) + // } + + // property("drops must be equal") = forAll(collectionPairsWithLengths) { case (t, coll, n) => + // ("drop " + n + " elements") |: t.drop(n) == coll.drop(n) + // } + + // 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(tsl.asInstanceOf[Seq[T]].sameElements(collsl)) + // 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 + // } + + // 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 + // } + + // property("takeWhiles must be equal") = forAll(collectionPairs) { case (t, coll) => + // (for ((pred, ind) <- takeWhilePredicates.zipWithIndex) + // yield ("operator " + ind) |: t.takeWhile(pred) == coll.takeWhile(pred)).reduceLeft(_ && _) + // } + + // 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(tsp) + // println(csp) + // } + // ("operator " + ind) |: tsp == csp + // }).reduceLeft(_ && _) + // } + + // 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 ("operator " + ind) |: t.foldLeft(first)(op) == coll.fold(first)(op)).reduceLeft(_ && _) + // } + + // property("++s must be equal") = forAll(collectionTriplets) { case (t, coll, colltoadd) => + // val toadd = colltoadd + // val tr = t ++ toadd + // val cr = coll ++ fromTraversable(toadd).iterator + // if (!tr.toList.iterator.sameElements(cr.iterator)) { + // println("from: " + t) + // println("and: " + coll.iterator.toList) + // println("adding: " + toadd) + // println(tr.toList) + // println(cr.iterator.toList) + // } + // ("adding " |: tr == cr) && + // (for ((trav, ind) <- (addAllTraversables).zipWithIndex) yield { + // val tadded = t ++ trav + // val cadded = coll ++ fromTraversable(trav.toList) + // if (tadded != cadded) { + // println("----------------------") + // println("from: " + t) + // println("and: " + coll.iterator.toList) + // println("adding: " + trav) + // println(tadded.toList) + // println(cadded.iterator.toList) + // } + // ("traversable " + ind) |: (tadded) == (cadded) + // }).reduceLeft(_ && _) + // } + + // 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/disabled/parallel-collections/ParallelRangeCheck.scala b/test/files/scalacheck/parallel-collections/ParallelRangeCheck.scala similarity index 100% rename from test/disabled/parallel-collections/ParallelRangeCheck.scala rename to test/files/scalacheck/parallel-collections/ParallelRangeCheck.scala diff --git a/test/files/scalacheck/parallel-collections/ParallelSeqCheck.scala b/test/files/scalacheck/parallel-collections/ParallelSeqCheck.scala new file mode 100644 index 000000000..7ef33ed7f --- /dev/null +++ b/test/files/scalacheck/parallel-collections/ParallelSeqCheck.scala @@ -0,0 +1,282 @@ +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 ParallelSeqCheck[T](collName: String) extends ParallelIterableCheck[T](collName) with SeqOperators[T] { + + type CollType <: collection.parallel.ParSeq[T] with Sequentializable[T, Seq[T]] + + def instances(vals: Seq[Gen[T]]): Gen[Seq[T]] + def fromSeq(s: Seq[T]): CollType + 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 + } + + override def collectionPairs: Gen[(Seq[T], CollType)] = for (inst <- instances(values)) yield (inst, fromSeq(inst)) + + override def collectionPairsWithLengths: Gen[(Seq[T], CollType, Int)] = + for (inst <- instances(values); s <- choose(0, inst.size)) yield (inst, fromSeq(inst), s); + + def collectionPairsWithModifiedWithLengths: Gen[(Seq[T], CollType, ParSeq[T], Int)] = + for (inst <- instances(values); s <- choose(0, inst.size); + updateStart <- choose(0, inst.size); howMany <- choose(0, inst.size)) yield { + val parcoll = fromSeq(inst) + val parcollmodif = fromSeq(modifySlightly(inst, updateStart, howMany)) + (inst, parcoll, parcollmodif, s) + } + + def collectionPairsWithModified: Gen[(Seq[T], CollType, ParSeq[T])] = + for (inst <- instances(values); updateStart <- choose(0, inst.size); howMany <- choose(0, inst.size)) yield { + val parcoll = fromSeq(inst) + val parcollmodif = fromSeq(modifySlightly(inst, updateStart, howMany)) + (inst, parcoll, parcollmodif) + } + + def collectionPairsWithSliced: Gen[(Seq[T], CollType, ParSeq[T])] = + for (inst <- instances(values); sliceStart <- choose(0, inst.size); howMany <- choose(0, inst.size)) yield { + val parcoll = fromSeq(inst) + val parcollsliced = fromSeq(inst.slice(sliceStart, sliceStart + howMany)) + (inst, parcoll, parcollsliced) + } + + def collectionTripletsWith2Indices: Gen[(Seq[T], CollType, Seq[T], Int, Int)] = + for (inst <- instances(values); f <- choose(0, inst.size); s <- choose(0, inst.size); + third <- instances(values); sliceStart <- choose(0, inst.size); howMany <- choose(0, inst.size)) yield { + (inst, fromSeq(inst), inst.slice(sliceStart, sliceStart + howMany), f, s) + } + + private def modifySlightly(coll: Seq[T], updateStart: Int, howMany: Int) = { + coll.patch(updateStart, coll, howMany) + } + + // property("segmentLengths must be equal") = forAll(collectionPairsWithLengths) { case (s, coll, len) => + // (for ((pred, ind) <- segmentLengthPredicates.zipWithIndex) yield { + // val slen = s.segmentLength(pred, if (len < 0) 0 else len) + // val clen = coll.segmentLength(pred, len) + // if (slen != clen) { + // println("from: " + s) + // println("and: " + coll) + // println(slen) + // println(clen) + // } + // ("operator " + ind) |: slen == clen + // }).reduceLeft(_ && _) + // } + + // property("prefixLengths must be equal") = forAll(collectionPairs) { case (s, coll) => + // (for ((pred, ind) <- segmentLengthPredicates.zipWithIndex) yield { + // ("operator " + ind) |: s.prefixLength(pred) == coll.prefixLength(pred) + // }).reduceLeft(_ && _) + // } + + // property("indexWheres must be equal") = forAll(collectionPairsWithLengths) { case (s, coll, len) => + // (for ((pred, ind) <- indexWherePredicates.zipWithIndex) yield { + // val sind = s.indexWhere(pred, len) + // val cind = coll.indexWhere(pred, len) + // if (sind != cind) { + // println("from: " + s) + // println("and: " + coll) + // println("at: " + len) + // println(sind) + // println(cind) + // } + // ("operator " + ind) |: sind == cind + // }).reduceLeft(_ && _) + // } + + // property("lastIndexWheres must be equal") = forAll(collectionPairsWithLengths) { case (s, coll, len) => + // (for ((pred, ind) <- lastIndexWherePredicates.zipWithIndex) yield { + // val end = if (len >= s.size) s.size - 1 else len + // val sind = s.lastIndexWhere(pred, end) + // val cind = coll.lastIndexWhere(pred, end) + // ("operator " + ind) |: sind == cind + // }).reduceLeft(_ && _) + // } + + // property("reverses must be equal") = forAll(collectionPairs) { case (s, coll) => + // (s.length == 0 && s.getClass == classOf[collection.immutable.Range]) || + // { + // val sr = s.reverse + // val cr = coll.reverse + // if (sr != cr) { + // println("from: " + s) + // println("and: " + coll) + // println(sr) + // println(cr) + // } + // sr == cr + // } + // } + + // property("reverseMaps must be equal") = forAll(collectionPairs) { case (s, coll) => + // (for ((f, ind) <- reverseMapFunctions.zipWithIndex) yield { + // ("operator " + ind) |: s.reverseMap(f) == coll.reverseMap(f) + // }).reduceLeft(_ && _) + // } + + // property("sameElements must be equal") = forAll(collectionPairsWithModifiedWithLengths) { + // case (s, coll, collmodif, len) => + // val pos = if (len < 0) 0 else len + // val scm = s.sameElements(collmodif) + // val ccm = coll.sameElements(collmodif) + // if (scm != ccm) { + // println("Comparing: " + s) + // println("and: " + coll) + // println("with: " + collmodif) + // println(scm) + // println(ccm) + // } + // ("Nil" |: s.sameElements(Nil) == coll.sameElements(Nil)) && + // ("toList" |: s.sameElements(s.toList) == coll.sameElements(coll.toList)) && + // ("identity" |: s.sameElements(s.map(e => e)) == coll.sameElements(coll.map(e => e))) && + // ("vice-versa" |: s.sameElements(coll) == coll.sameElements(s)) && + // ("equal" |: s.sameElements(coll)) && + // ("modified" |: scm == ccm) && + // (for ((it, ind) <- sameElementsSeqs.zipWithIndex) yield { + // val sres = s.sameElements(it) + // val pres = coll.sameElements(it) + // if (sres != pres) { + // println("Comparing: " + s) + // println("and: " + coll) + // println("with: " + it) + // println(sres) + // println(pres) + // } + // ("collection " + ind) |: sres == pres + // }).reduceLeft(_ && _) + // } + + // property("startsWiths must be equal") = forAll(collectionPairsWithModifiedWithLengths) { + // case (s, coll, collmodif, len) => + // val pos = if (len < 0) 0 else len + // ("start with self" |: s.startsWith(s) == coll.startsWith(coll)) && + // ("tails correspond" |: (s.length == 0 || s.startsWith(s.tail, 1) == coll.startsWith(coll.tail, 1))) && + // ("with each other" |: coll.startsWith(s)) && + // ("modified" |: s.startsWith(collmodif) == coll.startsWith(collmodif)) && + // ("modified2" |: s.startsWith(collmodif, pos) == coll.startsWith(collmodif, pos)) && + // (for (sq <- startEndSeqs) yield { + // val ss = s.startsWith(sq, pos) + // val cs = coll.startsWith(fromSeq(sq), pos) + // if (ss != cs) { + // println("from: " + s) + // println("and: " + coll) + // println("test seq: " + sq) + // println("from pos: " + pos) + // println(ss) + // println(cs) + // println(coll.iterator.psplit(pos, coll.length - pos)(1).toList) + // } + // ("seq " + sq) |: ss == cs + // }).reduceLeft(_ && _) + // } + + // property("endsWiths must be equal") = forAll(collectionPairsWithModified) { + // case (s, coll, collmodif) => + // ("ends with self" |: s.endsWith(s) == coll.endsWith(s)) && + // ("ends with tail" |: (s.length == 0 || s.endsWith(s.tail) == coll.endsWith(coll.tail))) && + // ("with each other" |: coll.endsWith(s)) && + // ("modified" |: s.startsWith(collmodif) == coll.endsWith(collmodif)) && + // (for (sq <- startEndSeqs) yield { + // val sew = s.endsWith(sq) + // val cew = coll.endsWith(fromSeq(sq)) + // if (sew != cew) { + // println("from: " + s) + // println("and: " + coll) + // println(sew) + // println(cew) + // } + // ("seq " + sq) |: sew == cew + // }).reduceLeft(_ && _) + // } + + // property("unions must be equal") = forAll(collectionPairsWithModified) { case (s, coll, collmodif) => + // ("modified" |: s.union(collmodif.seq) == coll.union(collmodif)) && + // ("empty" |: s.union(Nil) == coll.union(fromSeq(Nil))) + // } + + // if (!isCheckingViews) property("patches must be equal") = forAll(collectionTripletsWith2Indices) { + // case (s, coll, pat, from, repl) => + // ("with seq" |: s.patch(from, pat, repl) == coll.patch(from, pat, repl)) && + // ("with par" |: s.patch(from, pat, repl) == coll.patch(from, fromSeq(pat), repl)) && + // ("with empty" |: s.patch(from, Nil, repl) == coll.patch(from, fromSeq(Nil), repl)) && + // ("with one" |: (s.length == 0 || s.patch(from, List(s(0)), 1) == coll.patch(from, fromSeq(List(coll(0))), 1))) + // } + + // if (!isCheckingViews) property("updates must be equal") = forAll(collectionPairsWithLengths) { case (s, coll, len) => + // val pos = if (len >= s.length) s.length - 1 else len + // if (s.length > 0) { + // val supd = s.updated(pos, s(0)) + // val cupd = coll.updated(pos, coll(0)) + // if (supd != cupd) { + // println("from: " + s) + // println("and: " + coll) + // println(supd) + // println(cupd) + // } + // "from first" |: (supd == cupd) + // } else "trivially" |: true + // } + + // property("prepends must be equal") = forAll(collectionPairs) { case (s, coll) => + // s.length == 0 || s(0) +: s == coll(0) +: coll + // } + + // property("appends must be equal") = forAll(collectionPairs) { case (s, coll) => + // s.length == 0 || s :+ s(0) == coll :+ coll(0) + // } + + // property("padTos must be equal") = forAll(collectionPairsWithLengths) { case (s, coll, len) => + // val someValue = sampleValue + // val sdoub = s.padTo(len * 2, someValue) + // val cdoub = coll.padTo(len * 2, someValue) + // if (sdoub != cdoub) { + // println("from: " + s) + // println("and: " + coll) + // println(sdoub) + // println(cdoub) + // } + // ("smaller" |: s.padTo(len / 2, someValue) == coll.padTo(len / 2, someValue)) && + // ("bigger" |: sdoub == cdoub) + // } + + // property("corresponds must be equal") = forAll(collectionPairsWithModified) { case (s, coll, modified) => + // val modifcut = modified.toSeq.slice(0, modified.length) + // ("self" |: s.corresponds(s)(_ == _) == coll.corresponds(coll)(_ == _)) && + // ("modified" |: s.corresponds(modified.seq)(_ == _) == coll.corresponds(modified)(_ == _)) && + // ("modified2" |: s.corresponds(modifcut)(_ == _) == coll.corresponds(modifcut)(_ == _)) + // } + +} + + + + + + + + + + + + + + + + + + + diff --git a/test/disabled/parallel-collections/pc.scala b/test/files/scalacheck/parallel-collections/pc.scala similarity index 54% rename from test/disabled/parallel-collections/pc.scala rename to test/files/scalacheck/parallel-collections/pc.scala index d369faf80..ffc5eff78 100644 --- a/test/disabled/parallel-collections/pc.scala +++ b/test/files/scalacheck/parallel-collections/pc.scala @@ -6,15 +6,15 @@ import org.scalacheck._ import scala.collection.parallel._ -object ParCollProperties extends Properties("Parallel collections") { +class ParCollProperties extends Properties("Parallel collections") { + // parallel arrays include(mutable.IntParallelArrayCheck) - include(immutable.ParallelRangeCheck) } object Test { def main(args: Array[String]) { - val results = org.scalacheck.Test.checkProperties(ParCollProperties) + val results = org.scalacheck.Test.checkProperties(new ParCollProperties) if (!results.forall(_._2.passed)) println(results) } } diff --git a/test/files/scalacheck/scan.scala b/test/files/scalacheck/scan.scala index e9b25ce3d..fc214d739 100644 --- a/test/files/scalacheck/scan.scala +++ b/test/files/scalacheck/scan.scala @@ -3,6 +3,8 @@ import Prop._ import Gen._ + + object Test extends Properties("TraversableLike.scanLeft") { property("scanLeft") = forAll { (xs: List[Int], z: Int) => { val sums = xs.scanLeft(z)(_ + _)