From 8fa8118e341cc0174d789b508b8b6ebab3571582 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 14 May 2009 09:36:49 +0000
Subject: cleaned up collection builder framework

---
 test/files/run/colltest1.check |  99 ++++++++++++++++++
 test/files/run/colltest1.scala | 231 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 330 insertions(+)
 create mode 100644 test/files/run/colltest1.check
 create mode 100755 test/files/run/colltest1.scala

(limited to 'test/files/run')

diff --git a/test/files/run/colltest1.check b/test/files/run/colltest1.check
new file mode 100644
index 0000000000..079c57910a
--- /dev/null
+++ b/test/files/run/colltest1.check
@@ -0,0 +1,99 @@
+new test starting with List()
+10: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+new test starting with List()
+10: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+new test starting with Stream()
+10: Stream(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: Stream(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+Stream(1, ?)
+new test starting with Array()
+10: Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: Array(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+new test starting with ArrayBuffer()
+10: ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: ArrayBuffer(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+new test starting with ListBuffer()
+10: ListBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: ListBuffer(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+ListBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+new test starting with List()
+10: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+new test starting with ArrayBuffer()
+10: ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: ArrayBuffer(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+new test starting with List()
+10: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+new test starting with List()
+10: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+new test starting with ArrayBuffer()
+10: ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: ArrayBuffer(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+new test starting with List()
+10: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+new test starting with List()
+10: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+new test starting with ArrayBuffer()
+10: ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: ArrayBuffer(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+new test starting with List()
+10: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+new test starting with List()
+10: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+new test starting with List()
+10: List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+new test starting with ArrayBuffer()
+10: ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+9: ArrayBuffer(2, 3, 4, 5, 6, 7, 8, 9, 10)
+1
+ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+true
+false
+true
+Map(O -> O, W -> W, H -> H, P -> P, G -> G, V -> V, I -> I, A -> A, F -> F, U -> U, N -> N, X -> X, Z -> Z, S -> S, D -> D, K -> K, R -> R, C -> C, B -> B, L -> L, Q -> Q, M -> M, J -> J, Y -> Y, T -> T, E -> E)
+Map(O -> O, W -> W, H -> H, P -> P, G -> G, V -> V, I -> I, A -> A, F -> F, U -> U, N -> N, X -> X, Z -> Z, S -> S, D -> D, K -> K, R -> R, C -> C, B -> B, L -> L, Q -> Q, M -> M, J -> J, Y -> Y, T -> T, E -> E)
+Map(O -> O, W -> W, H -> H, P -> P, V -> V, G -> G, I -> I, A -> A, F -> F, U -> U, N -> N, X -> X, Z -> Z, S -> S, D -> D, K -> K, R -> R, C -> C, B -> B, L -> L, Q -> Q, M -> M, J -> J, Y -> Y, T -> T, E -> E)
+Map(O -> O, W -> W, H -> H, P -> P, V -> V, G -> G, I -> I, A -> A, F -> F, U -> U, N -> N, X -> X, Z -> Z, S -> S, D -> D, K -> K, R -> R, C -> C, B -> B, L -> L, Q -> Q, M -> M, J -> J, Y -> Y, T -> T, E -> E)
+Map(O -> O, W -> W, H -> H, P -> P, G -> G, V -> V, I -> I, A -> A, F -> F, U -> U, N -> N, X -> X, Z -> Z, S -> S, D -> D, K -> K, R -> R, C -> C, B -> B, L -> L, Q -> Q, M -> M, J -> J, Y -> Y, T -> T, E -> E)
+Map(O -> O, W -> W, H -> H, P -> P, G -> G, V -> V, I -> I, A -> A, F -> F, U -> U, N -> N, X -> X, Z -> Z, S -> S, D -> D, K -> K, R -> R, C -> C, B -> B, L -> L, Q -> Q, M -> M, J -> J, Y -> Y, T -> T, E -> E)
+Map(A -> A, B -> B, C -> C, D -> D, E -> E, F -> F, G -> G, H -> H, I -> I, J -> J, K -> K, L -> L, M -> M, N -> N, O -> O, P -> P, Q -> Q, R -> R, S -> S, T -> T, U -> U, V -> V, W -> W, X -> X, Y -> Y, Z -> Z)
+Map(A -> A, B -> B, C -> C, D -> D, E -> E, F -> F, G -> G, H -> H, I -> I, J -> J, K -> K, L -> L, M -> M, N -> N, O -> O, P -> P, Q -> Q, R -> R, S -> S, T -> T, U -> U, V -> V, W -> W, X -> X, Y -> Y, Z -> Z)
+Map(O -> O, W -> W, H -> H, P -> P, V -> V, G -> G, I -> I, A -> A, F -> F, U -> U, N -> N, X -> X, Z -> Z, S -> S, D -> D, K -> K, R -> R, C -> C, B -> B, L -> L, Q -> Q, M -> M, J -> J, Y -> Y, T -> T, E -> E)
+Map(O -> O, W -> W, H -> H, P -> P, V -> V, G -> G, I -> I, A -> A, F -> F, U -> U, N -> N, X -> X, Z -> Z, S -> S, D -> D, K -> K, R -> R, C -> C, B -> B, L -> L, Q -> Q, M -> M, J -> J, Y -> Y, T -> T, E -> E)
+Map(O -> O, W -> W, H -> H, P -> P, G -> G, V -> V, I -> I, A -> A, F -> F, U -> U, N -> N, X -> X, Z -> Z, S -> S, D -> D, K -> K, R -> R, C -> C, B -> B, L -> L, Q -> Q, M -> M, J -> J, Y -> Y, T -> T, E -> E)
+Map(O -> O, W -> W, H -> H, P -> P, G -> G, V -> V, I -> I, A -> A, F -> F, U -> U, N -> N, X -> X, Z -> Z, S -> S, D -> D, K -> K, R -> R, C -> C, B -> B, L -> L, Q -> Q, M -> M, J -> J, Y -> Y, T -> T, E -> E)
diff --git a/test/files/run/colltest1.scala b/test/files/run/colltest1.scala
new file mode 100755
index 0000000000..f28221e205
--- /dev/null
+++ b/test/files/run/colltest1.scala
@@ -0,0 +1,231 @@
+import collection._
+
+object Test extends Application {
+
+  def orderedTraversableTest(empty: Traversable[Int])
+  {
+    println("new test starting with "+empty)
+    assert(empty.isEmpty)
+    val ten = empty ++ List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+    println(ten.size+": "+ten)
+    println(ten.tail.size+": "+ten.tail)
+    assert(ten == empty ++ (1 to 10))
+    assert(ten.size == 10)
+    assert(ten forall (_ <= 10))
+    assert(ten exists (_ == 5))
+    assert((ten count (_ % 2 == 0)) == 5)
+    assert((ten find (_ % 2 == 0)) == Some(2))
+    assert((0 /: ten)(_ + _) == 55)
+    assert((ten :\ 0)(_ + _) == 55)
+    println(ten.head)
+    val x = ten reduceLeft (_ + _)
+    assert(x == 55, x)
+    assert((ten reduceRight (_ + _)) == 55)
+    val firstFive = empty ++ (1 to 5)
+    val secondFive = empty ++ (6 to 10)
+    assert(firstFive ++ secondFive == ten, firstFive ++ secondFive)
+    val odds = ten filter (_ % 2 != 0)
+    val evens = ten remove (_ % 2 != 0)
+    assert(odds.size == evens.size)
+    val (o, e) = ten.partition(_ % 2 == 0)
+    assert(o.size == e.size)
+    val gs = ten groupBy (x => x / 4)
+    val vs1 = (for (k <- gs.keys; v <- gs(k).toIterable.elements) yield v).toList
+    val vs2 = Traversable.traversableTraversableWrapper[List[Traversable[Int]], Int](gs.values.toList).flatten
+//    val vs2 = gs.values.toList flatMap (xs => xs)
+    assert(ten.head == 1)
+    assert(ten.tail.head == 2)
+    assert(ten.tail.size == 9)
+    assert(ten.tail.foldLeft(10)(_ + _) == 64)
+    assert(ten.last == 10)
+    assert(List(ten.head) ++ ten.tail == ten)
+    assert(ten.init ++ List(ten.last) == ten, ten.init)
+    assert(vs1 == vs2, vs1+"!="+vs2)
+    assert(vs1 == ten)
+    assert((ten take 5) == firstFive)
+    assert((ten drop 5) == secondFive)
+    assert(ten slice (3, 3) isEmpty)
+    assert((ten slice (3, 6)) == List(4, 5, 6), ten slice (3, 6))
+    assert((ten takeWhile (_ <= 5)) == firstFive)
+    assert((ten dropWhile (_ <= 5)) == secondFive)
+    assert((ten span (_ <= 5)) == (firstFive, secondFive))
+    assert((ten splitAt 5) == (firstFive, secondFive), ten splitAt 5)
+    val buf = new mutable.ArrayBuffer[Int]
+    firstFive copyToBuffer buf
+    secondFive copyToBuffer buf
+    assert(buf.result == ten, buf.result)
+    assert(ten.toArray.size == 10)
+    assert(ten.toArray == ten)
+    assert(ten.toIterable == ten)
+    assert(ten.toList == ten)
+    assert(ten.toSequence == ten)
+    assert(ten.toStream == ten)
+    assert(ten.toString endsWith "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)")
+    assert(ten.mkString("[", "; ", "]") endsWith "[1; 2; 3; 4; 5; 6; 7; 8; 9; 10]")
+  }
+
+  def orderedIterableTest(empty: Iterable[Int]) {
+    orderedTraversableTest(empty)
+    val six = empty ++ List(1, 2, 3, 4, 5, 6)
+    assert(six.elements.toStream == six)
+    assert(six.takeRight(4) == List(3, 4, 5, 6), six.takeRight(4))
+    assert(six.dropRight(3) == List(1, 2, 3))
+    assert(six sameElements (1 to 6))
+  }
+
+  def sequenceTest(empty: Sequence[Int]) {
+    orderedIterableTest(empty)
+    val ten = empty ++ (1 to 10)
+    println(ten)
+    val tenPlus = ten map (_ + 1)
+    assert((ten zip tenPlus) forall { case (x, y) => x + 1 == y })
+    val dble = ten flatMap (x => List(x, x))
+    assert(dble.removeDuplicates == ten)
+    assert(ten.length == 10)
+    assert(ten(0) == 1 && ten(9) == 10)
+    assert((ten lengthCompare 10) == 0 && (ten lengthCompare 1) > 0 && (ten lengthCompare 11) < 0)
+    assert((ten isDefinedAt 0) && (ten isDefinedAt 9))
+    assert(!(ten isDefinedAt -1));
+    assert(!(ten isDefinedAt 10))
+    val tenten = ten zip ten
+    assert((tenten map (_._1)) == ten)
+    assert((tenten map (_._2)) == ten)
+    assert(ten.zipWithIndex forall { case (x, y) => x == y + 1 })
+    assert(ten.segmentLength(_ <= 8, 4) == 4, ten.segmentLength(_ <= 8, 4))
+    assert(ten.prefixLength(_ <= 8) == 8)
+    assert(ten.indexWhere(_ >= 8, 4) == 7, ten.indexWhere(_ >= 8, 4))
+    assert(ten.indexWhere(_ >= 8) == 7)
+    assert(ten.indexOf(5) == 4)
+    assert(ten.indexOf(5, 4) == 4)
+    assert(ten.indexOf(5, 5) == -1)
+    assert(ten.lastIndexOf(5) == 4, ten.lastIndexOf(5))
+    assert(ten.lastIndexOf(5, 4) == 4)
+    assert(ten.lastIndexOf(5, 3) == -1)
+    assert(ten.lastIndexWhere(_ <= 8) == 7)
+    assert(ten.lastIndexWhere(_ <= 8, 6) == 6)
+    assert(ten.lastIndexWhere(_ <= 8, 8) == 7)
+    assert(ten.reverse startsWith List(10, 9, 8), ten.reverse.take(10).toList)
+    assert(ten.reverse.length == 10)
+    assert(ten.reverse.reverse == ten)
+    assert(ten.reversedElements.toList.reverse == ten, ten.reversedElements.toList)
+    assert(ten.startsWith(List(1)))
+    assert(ten.startsWith(List(3, 4), 2))
+    assert(ten.endsWith(List(9, 10)))
+    assert(ten.endsWith(List()))
+    assert(ten.indexOfSeq(List(3, 4, 5)) == 2, ten.indexOfSeq(List(3, 4, 5)))
+    assert(ten contains 1)
+    assert(ten contains 10)
+    assert(!(ten contains 0))
+    assert((empty ++ (1 to 7) union empty ++ (3 to 10)) == List(1, 2, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 8, 9, 10))
+    assert((ten diff ten).isEmpty)
+    assert((ten diff List()) == ten)
+    assert((ten diff (ten filter (_ % 2 == 0))) == (ten remove  (_ % 2 == 0)))
+    assert((ten intersect ten) == ten)
+    assert((ten intersect List(5)) == List(5))
+    assert((ten ++ ten).removeDuplicates == ten)
+    assert(ten.patch(3, List(4, 5, 6, 7), 4) == ten)
+    assert(ten.patch(0, List(1, 2, 3), 9) == List(1, 2, 3, 10))
+    assert(empty.padTo(10, 7) == Array.fill(10)(7))
+    assert((ten zip ten.indices) == ten.zipWithIndex)
+  }
+
+  def setTest(empty: => Set[String]) {
+    var s = empty + "A" + "B" + "C"
+    s += ("D", "E", "F")
+    s ++= List("G", "H", "I")
+    s ++= ('J' to 'Z') map (_.toString)
+    assert(s forall (s contains))
+    assert(s contains "X")
+    assert(!(s contains "0"))
+    s = s + "0"
+    assert(s contains "0")
+    s = s - "X"
+    assert(!(s contains "X"))
+    assert(empty.isEmpty)
+    assert(!s.isEmpty)
+    assert((s intersect s) == s)
+    assert((empty intersect s) == empty)
+    assert(!s.isEmpty)
+    val s1 = s intersect empty
+    assert(s1 == empty, s1)
+    def abc = empty + ("a", "b", "c")
+    def bc = empty + ("b", "c")
+    assert(bc subsetOf abc)
+  }
+
+  def rangeTest(r: Range) {
+    val ten = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+    assert(r == ten)
+    assert(r.toList == ten)
+    assert((r filter (_ % 2 == 0)) == (ten filter (_ % 2 == 0)))
+    println((r map (_ + 1)) == (ten map (_ + 1)))
+    println((r map (_ * 2)) == (ten map (_ + 1)))
+    println((r flatMap (i => 0 until i)) == (ten flatMap (i => 0 until i)))
+  }
+
+  def mapTest(empty: => Map[String, String]) = {
+    var m = empty + ("A" -> "A") + ("B" -> "B") + ("C" -> "C")
+    m += (("D" -> "D"), ("E" -> "E"), ("F" -> "F"))
+    m ++= List(("G" -> "G"), ("H" -> "H"), ("I" -> "I"))
+    m ++= ('J' to 'Z') map (x => (x.toString -> x.toString))
+    println(m)
+    assert(!m.isEmpty)
+    assert(m.keys forall (k => (m get k) == Some(k)))
+    assert(m.keys forall (k => (m apply k) == k))
+    assert(m.keys forall (m contains))
+    assert(m.getOrElse("7", "@") == "@")
+    assert(m.keys.length == 26)
+    assert(m.size == 26)
+    assert(m.keySet == Set() ++ m.keys)
+    assert(m.keys.toList == m.values.toList)
+    val m1 = empty ++ m
+    val mm = m -- m.keySet.toList
+    assert(mm.isEmpty, mm)
+    def m3 = empty ++ m1
+    assert(m1 == m3)
+    println(m3)
+    val m4 = m3.remove { case (k, v) => k != "A" }
+    assert(m4.size == 1, m4)
+  }
+
+  def mutableMapTest(empty: => mutable.Map[String, String]) = {
+    mapTest(empty)
+    val m1 = empty ++ (('A' to 'Z') map (_.toString) map (x => (x, x)))
+    val m2 = m1 retain ((k, v) => k == "N")
+    assert(m2.size == 1, m2)
+  }
+
+  sequenceTest(Nil)
+  sequenceTest(List())
+  sequenceTest(Stream.empty)
+  sequenceTest(Array())
+  sequenceTest(mutable.ArrayBuffer())
+  sequenceTest(mutable.ListBuffer())
+  orderedTraversableTest(Traversable())
+  orderedTraversableTest(mutable.Traversable())
+  orderedTraversableTest(immutable.Traversable())
+  orderedIterableTest(Iterable())
+  orderedIterableTest(mutable.Iterable())
+  orderedIterableTest(immutable.Iterable())
+  sequenceTest(Sequence())
+  sequenceTest(mutable.Sequence())
+  sequenceTest(immutable.Sequence())
+  sequenceTest(LinearSequence())
+//  sequenceTest(mutable.LinearSequence())
+  sequenceTest(immutable.LinearSequence())
+  sequenceTest(mutable.Vector())
+  rangeTest(1 to 10)
+
+  setTest(Set())
+  setTest(mutable.Set())
+  setTest(immutable.Set())
+  setTest(mutable.HashSet())
+  setTest(immutable.HashSet())
+
+  mapTest(Map())
+  mutableMapTest(mutable.Map())
+  mapTest(immutable.Map())
+  mapTest(immutable.TreeMap())
+  mutableMapTest(mutable.HashMap())
+  mapTest(immutable.HashMap())
+}
-- 
cgit v1.2.3