Simple tests for understanding how @generator annotation works.

Test1.scala

+import funcheck.lib.Specs._
+import org.scalacheck.{Gen, Arbitrary}
+
+object HeapTest {
+  sealed abstract class Middle extends Top
+  case class E()  extends Middle
+  @generator sealed abstract class Top
+  case class Elem(i: Int, j: Int) 
+
+  @generator def create(): E = E()
+  //@generator def create2(i: Int): Elem = Elem(i)
+
+  def genE = Gen.value(E())
+  def genE2 = Gen.value(E())
+
+  @generator
+  def genElemSynthetic(a: Int, b: Int) = Elem(a,b)
+
+  def genElem = for {
+    v2 <- Arbitrary.arbitrary[Int]
+    v1 <- Arbitrary.arbitrary[Int]
+  } yield Elem(v2,v2)
+
+  implicit def arbE: Arbitrary[E] = Arbitrary(Gen.oneOf(genE,genE2))
+
+  forAll[(Elem,Elem,Int)]( p => 1+1 == 2)
+}
\ No newline at end of file

Test2.scala

+import funcheck.lib.Specs._
+import org.scalacheck.{Gen, Arbitrary}
+
+object HeapTest {
+  @generator
+  sealed abstract class Tree 
+  case class Leaf()  extends Tree
+  case class Node(left: Tree, right: Tree, v:Int) extends Tree
+
+  @generator def create(left: Tree, right: Tree, v: Int): Node = Node(left,right,v)
+
+  case class Elem (i: Int, j: Int, k: Int)
+  
+  def genElem: Gen[Elem] = for {
+    i <- Arbitrary.arbitrary[Int]
+    j <- Arbitrary.arbitrary[Int]
+    k <- Arbitrary.arbitrary[Int]
+  } yield Elem(i,j,k)
+ 
+  def genLeaf = Gen.value(Leaf())
+  def genTree: Gen[Tree] = Gen.oneOf(genLeaf,genNode)
+  def genNode = for {
+    v1 <- Arbitrary.arbitrary[Tree]
+    v2 <- Arbitrary.arbitrary[Tree]
+    v3 <- Arbitrary.arbitrary[Int]
+  } yield Node(v1,v2,v3)
+
+  implicit def arbTree: Arbitrary[Tree] = Arbitrary(genTree)
+
+  
+}
\ No newline at end of file

Test3.scala

+import funcheck.lib.Specs._
+import org.scalacheck.{Gen, Arbitrary}
+
+object HeapTest {
+
+  @generator sealed abstract class Tree 
+  case class Node(left: Tree, right: Tree) extends Tree
+  case class Leaf() extends Tree
+
+  def genLeaf: Gen[Leaf] = Gen.value[Leaf](Leaf())
+
+  def genNode: Gen[Node] = for {
+    v1 <- Arbitrary.arbitrary[Tree]
+    v2 <- Arbitrary.arbitrary[Tree]
+  } yield Node(v1,v2)
+
+  implicit def arbTree: Arbitrary[Tree] = Arbitrary(genTree)
+  def genTree: Gen[Tree] = Gen.oneOf(genLeaf,genNode)
+  
+}
\ No newline at end of file