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
This commit is contained in:
prokopec
parent
e15d23d7ae
commit
93253a1b8a
|
|
@ -1563,7 +1563,9 @@ BOOTRAPING TEST AND TEST SUITE
|
|||
<include name="run/**/*.scala"/>
|
||||
</runtests>
|
||||
<jvmtests dir="${partest.dir}/${partest.srcdir}/jvm" includes="*.scala"/>
|
||||
<scalachecktests dir="${partest.dir}/${partest.srcdir}/scalacheck" includes="**/*.scala"/>
|
||||
<scalachecktests dir="${partest.dir}/${partest.srcdir}/scalacheck">
|
||||
<include name="*.scala"/>
|
||||
</scalachecktests>
|
||||
<residenttests dir="${partest.dir}/${partest.srcdir}/res" includes="*.res"/>
|
||||
<buildmanagertests dir="${partest.dir}/${partest.srcdir}/buildmanager" includes="*"/>
|
||||
<shootouttests dir="${partest.dir}/${partest.srcdir}/shootout" includes="*.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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -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)(_ == _))
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -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(_ && _)
|
||||
// }
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -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
|
||||
// }
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -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)(_ == _))
|
||||
// }
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
@ -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)(_ + _)
|
||||
|
|
|
|||
Loading…
Reference in New Issue