Add support for property-based testing

examples/stdlib/test/list_examples_pbt.effekt

@@ -0,0 +1,166 @@
+import test
+
+def main() = {
+  println(suite("PBT: List Functions and Other Simple Examples") {
+
+    // example unit tests to show that mixed test suites work
+    test("1 + 1 == 2") {
+      assertEqual(1 + 1, 2)
+    }
+
+    test("2 + 2 == 3") {
+      assertEqual(2 + 2, 3)
+    }
+
+    // reverse[x] === [x]
+    with arbitraryInt;
+    forall[Int]("reverse-singleton", 100){ x => 
+      assertEqual(
+        reverse([x]),
+        [x]
+      )
+    }
+
+    // reverse[x] === [x], with explicit passing of the generator
+    with def g = arbitraryInt;
+    forall[Int]("reverse-singleton, explicitely passing the generator", 100){ g }
+      { x => 
+        assertEqual(
+          reverse([x]),
+          [x]
+        )
+    }
+
+    // intented mistake: reverse[x] === [6]
+    forall[Int]("reverse-singleton mistake", 100)
+      { x => 
+        assertEqual(
+          reverse([x]),
+          [6]
+        )
+    }
+
+    // shows that exists prints tried test cases and found examples correctly
+    exists[Int]("Is the Integer 2 among the generated values?", 100)
+      { x => 
+        assertEqual(
+          x,
+          2
+        )
+    }
+
+    // reverse(xs ++ ys) === reverse(ys) ++ reverse(xs)
+    with arbitraryList[Int](3) 
+    forall[List[Int], List[Int]]("reverse: distributivity over append", 100)
+      { (xs, ys) => 
+        assertEqual(
+          reverse(xs.append(ys)), 
+          reverse(ys).append(reverse(xs))
+        )
+    }
+
+    // intended mistake: reverse(xs ++ ys) === reverse(xs) ++ reverse(ys)
+    forall[List[Int], List[Int]]("reverse: distributivity mistake - swapped order", 20)
+      { (xs, ys) => 
+        assertEqual(
+          reverse(xs.append(ys)), 
+          reverse(xs).append(reverse(ys))
+        )
+    }
+
+    with arbitraryChar; 
+    with arbitraryList[Char](4);
+    forall[List[Char], List[Int]]("|zip(xs,ys)| === min(|xs|,|ys|)",10)
+      { (xs, ys) =>
+        assertEqual(
+          zip(xs, ys).size,
+          min(xs.size, ys.size)
+        )
+    }
+
+    with arbitraryChar; 
+    with arbitraryList[Char](6);
+    forall[List[Char], List[Int]]("intended mistake: |zip(xs,ys)| != max(|xs|,|ys|)",10)
+      { (xs, ys) =>
+        assertEqual(
+          zip(xs, ys).size,
+          max(xs.size, ys.size)
+        )
+    }
+
+    // unzip(zip(xs,ys)) === (xs.take(m), ys.take(m)) where m = min(|xs|,|ys|)
+    with arbitraryChar;
+    with arbitraryString(4);
+    with arbitraryList[String](2);
+    with arbitraryInt;
+    with arbitraryList[Int](3)
+    forall[List[Int], List[String]]("unzip-zip-take relation", 10)
+      { (xs, ys) =>
+        val m = min(xs.size, ys.size)
+        assertEqual(
+          unzip(zip(xs, ys)),
+          (xs.take(m), ys.take(m))
+        )
+    }
+
+    // Dropping elements from the concatenation of two lists is equivalent to dropping elements from the first list, 
+    // and then (if necessary) dropping the remaining count from the second list.
+    // (xs ++ ys).drop(n) === if n <= len(xs) then (xs.drop(n)) ++ ys else ys.drop(n - len(xs))
+    forall[List[Int], List[Int], Int]("drop: concatenation ", 10)
+      { (xs, ys, n) =>
+        val res = if(n <= xs.size) {
+          xs.drop(n).append(ys) 
+          } 
+          else { ys.drop(n - xs.size) }
+        assertEqual(
+          (xs.append(ys).drop(n)),
+          res
+        )
+    }
+
+    // xs.drop(n) === xs.slice(n, x.size)
+    forall[List[Int], Int]("drop-slice relation", 10)
+      { (xs, n) =>
+        assertEqual(
+          xs.drop(n),
+          xs.slice(n, xs.size)
+        )
+    }
+
+    // reverseOnto(reverse(xs), ys) === append(xs, ys)
+    forall[List[Int], List[Int]]("reverseOnto-reverse-append relation ", 10)
+      { (xs, ys) =>
+        assertEqual(
+          reverseOnto(reverse(xs), ys),
+          append(xs, ys)
+          )
+    }
+
+    // size(xs) === foldLeft(xs, 0) { (acc, _) => acc + 1 }
+    forall[List[Int]]("size-foldLeft relation", 20)
+      { xs =>
+        assertEqual(
+          size(xs),
+          foldLeft(xs, 0){(acc, _) => acc + 1}
+        )
+    }
+
+    //xs.take(n) ++ xs.drop(n) === xs
+    forall[Int, List[Int]]("take-drop: inversion over concatenation", 20)
+      { (n, xs) =>
+        assertEqual(
+          append(xs.take(n), xs.drop(n)),
+          xs
+        )
+    }
+
+    // example for a property-based test with multiple assertions
+    with evenNumbers;
+    forall[Int]("even numbers are even and smaller than 4", 20)
+      { n =>
+        assertTrue(n.mod(2) == 0)
+        assertTrue(n <= 4)
+    }
+  })
+}
+

examples/stdlib/test/tree_examples_pbt.effekt

@@ -0,0 +1,107 @@
+import map
+import stream
+
+import test
+
+// user-defined generator for arbitrary, unique Integers in ascending order
+def uniqueInt{body: => Unit / Generator[Int]}: Unit = {
+  try body() with Generator[Int]{
+    def generate() = resume{
+      var next = randomInt(-100, 100)
+      do emit(next)
+      while(true){
+        next = next + randomInt(1, 5)
+        do emit(next)
+      }
+    }
+    def shrink(v) = <>
+  }
+}
+
+// precondition: provided handler for Generator[K] needs to produce unique keys in ascending order!
+// otherwise the generated trees aren't valid binary search trees
+def arbitraryBinTree[K, V] (numKeys: Int) { body: => Unit / Generator[internal::Tree[K, V]] }: Unit / {Generator[K], Generator[V]} = {
+  def buildTree[K, V](pairs: List[(K, V)]): internal::Tree[K,V] = {
+    if (pairs.isEmpty) {
+      internal::Tip()
+    } else {
+      val midIdx = pairs.size() / 2
+      with on[OutOfBounds].panic;
+      val midEl = pairs.get(midIdx)
+      val leftTree = buildTree(pairs.take(midIdx)) 
+      val rightTree = buildTree(pairs.drop(midIdx + 1))
+      val size = 1 + internal::size(leftTree) + internal::size(rightTree)
+
+      internal::Bin(size, midEl.first, midEl.second, leftTree, rightTree)
+    }
+  }
+
+  try body() with Generator[internal::Tree[K, V]] {
+    def generate() = resume {
+        while(true) {
+          val l1 = collectList[K]{with boundary; with limit[K](numKeys); do generate[K]}
+          val l2 = collectList[V]{with boundary; with limit[V](numKeys); do generate[V]}
+          val sortedPairs = zip(l1,l2)
+          do emit(buildTree[K, V](sortedPairs))
+          //TODO try to use zip again
+        }
+    }
+    def shrink(v) = <>
+    }
+}
+
+def main()= {
+  with arbitraryChar;
+  with arbitraryString(5);
+  with uniqueInt; 
+  with arbitraryBinTree[Int, String](8);
+
+  println(suite("PBT: Tree Map Examples") {
+
+    // get-put law: get(put(M, K, V), K) = V
+    forall[String, internal::Tree[Int, String], Int]("get-put law", 100)
+      { (v, t, k) =>
+        val newT = internal::put(t, compareInt, k, v)
+        internal::get(newT, compareInt, k) match {
+          case Some(value) => assertEqual(value, v)
+          case None() => do assert(false, "Key not in the tree")
+        }
+    }
+
+    // put-put law: get(put(put(M, K, V1), K, V2), K) = V2
+    forall[String, internal::Tree[Int, String], Int]("put-put law", 100)
+      { (v1, t, k) =>
+        val v2 = v1 ++ show(k) ++ v1 
+        val newT1 = internal::put(t, compareInt, k, v1)
+        val newT2 = internal::put(newT1, compareInt, k, v2)
+        internal::get(newT2, compareInt, k) match {
+          case Some(v) => assertEqual(v, v2)
+          case None() => do assert(false, "Key in the tree")
+        }
+    }
+
+    // put-get law: put(M, K, get(M, K)) = M
+    forall[internal::Tree[Int, String]]("put-get law", 100)
+      { t =>
+        // put-get law only make sense if K is present in the tree ~> get the keys of the tree
+        var keys = Nil()
+        t.internal::foreach[Int, String] { (k, _v) => keys = Cons(k, keys)}
+
+        with on[OutOfBounds].panic
+        val k = keys.get(randomInt(0, keys.size())) // only check the property for key's present in the tree (= non trivial test case)
+        internal::get(t, compareInt, k) match {
+          case Some(v) => {
+            val newT = internal::put(t, compareInt, k, v)
+            assertEqual(t, newT)}
+          case None() => do assert(false, "Key not in the tree")
+        }
+    }
+
+    // Law: `m.forget === m.map { (_k, _v) => () }
+    forall[internal::Tree[Int, String]]("forget-map relation", 100){t =>
+      val tForget = internal::forget(t)
+      val tMap = internal::map(t){ (_k, _v) => ()}
+      assertEqual(tForget, tMap)
+    }
+  })
+}