Custom implementations of drop/take/slice.

This mainly helps performance when comparing keys is expensive.

1 files changed, 15 insertions, 3 deletions

diff --git a/test/files/scalacheck/treemap.scala b/test/files/scalacheck/treemap.scala
index ba6d117fd4..f672637c57 100644
--- a/test/files/scalacheck/treemap.scala
+++ b/test/files/scalacheck/treemap.scala
@@ -7,11 +7,12 @@ import util._
 import Buildable._
 
 object Test extends Properties("TreeMap") {
-  implicit def arbTreeMap[A : Arbitrary : Ordering, B : Arbitrary]: Arbitrary[TreeMap[A, B]] =
-    Arbitrary(for {
+  def genTreeMap[A: Arbitrary: Ordering, B: Arbitrary]: Gen[TreeMap[A, B]] =
+    for {
       keys <- listOf(arbitrary[A])
       values <- listOfN(keys.size, arbitrary[B])
-    } yield TreeMap(keys zip values: _*))
+    } yield TreeMap(keys zip values: _*)
+  implicit def arbTreeMap[A : Arbitrary : Ordering, B : Arbitrary] = Arbitrary(genTreeMap[A, B])
 
   property("foreach/iterator consistency") = forAll { (subject: TreeMap[Int, String]) =>
     val it = subject.iterator
@@ -96,6 +97,17 @@ object Test extends Properties("TreeMap") {
     prefix == subject.take(n) && suffix == subject.drop(n)
   }
 
+  def genSliceParms = for {
+    tree <- genTreeMap[Int, String]
+    from <- choose(0, tree.size)
+    until <- choose(from, tree.size)
+  } yield (tree, from, until)
+
+  property("slice") = forAll(genSliceParms) { case (subject, from, until) =>
+    val slice = subject.slice(from, until)
+    slice.size == until - from && subject.toSeq == subject.take(from).toSeq ++ slice ++ subject.drop(until)
+  }
+
   property("takeWhile") = forAll { (subject: TreeMap[Int, String]) =>
     val result = subject.takeWhile(_._1 < 0)
     result.forall(_._1 < 0) && result == subject.take(result.size)