diff --git a/build.sbt b/build.sbt
index bcbcc7ee0950df27e954b623eefcf3925d3b356f..43a9a691284bd1ac292c46db4cfe749d2937f4ab 100644
--- a/build.sbt
+++ b/build.sbt
@@ -31,7 +31,6 @@ libraryDependencies ++= Seq(
   "org.scala-lang" % "scala-compiler" % "2.11.6",
   "org.scalatest" %% "scalatest" % "2.2.0" % "test",
   "com.typesafe.akka" %% "akka-actor" % "2.3.4",
-  "com.storm-enroute" %% "scalameter" % "0.7-SNAPSHOT" % "test",
   "com.fasterxml.jackson.module" %% "jackson-module-scala" % "2.6.0-rc2"
 )
 
@@ -90,39 +89,54 @@ sourceGenerators in Compile <+= Def.task {
 }
 
 
+sourcesInBase in Compile := false
+
 Keys.fork in run := true
 
+// Unit Tests
 Keys.fork in Test := true
 
 logBuffered in Test := false
 
 javaOptions in Test ++= Seq("-Xss16M", "-Xmx4G", "-XX:MaxPermSize=128M")
 
-testFrameworks += new TestFramework("org.scalameter.ScalaMeterFramework")
+parallelExecution in Test := true
 
-parallelExecution in Test := false
+testOptions in Test := Seq(Tests.Argument("-oDF"))
 
-parallelExecution in (Test, testOnly) := false
 
-testOptions in (Test, test) := Seq(Tests.Filter(s => s.endsWith("LeonAllTests")), Tests.Argument(TestFrameworks.ScalaTest, "-oDF"))
 
-testOptions in (Test, testOnly) := Seq(Tests.Argument(TestFrameworks.ScalaTest, "-oDF"))
+// Regression Tests
+lazy val IntegrTest = config("integration") extend(Test)
 
-sourcesInBase in Compile := false
+Keys.fork in IntegrTest := true
+
+logBuffered in IntegrTest := false
+
+javaOptions in IntegrTest ++= Seq("-Xss16M", "-Xmx4G", "-XX:MaxPermSize=128M")
+
+parallelExecution in IntegrTest := false
+
+testOptions in IntegrTest := Seq(Tests.Argument("-oDF"))
 
-lazy val PerfTest = config("perf") extend(Test)
 
-lazy val UnitTest = config("unit-test") extend(Test)
 
-scalaSource in PerfTest := baseDirectory.value / "src/test/scala/"
+// RegressionTest Tests
+lazy val RegressionTest = config("regression") extend(Test)
+
+Keys.fork in RegressionTest := true
+
+logBuffered in RegressionTest := false
+
+javaOptions in RegressionTest  ++= Seq("-Xss16M", "-Xmx4G", "-XX:MaxPermSize=128M")
+
+parallelExecution in RegressionTest := false
+
+testOptions in RegressionTest  := Seq(Tests.Argument("-oDF"))
 
-scalaSource in UnitTest := baseDirectory.value / "src/unit-test/scala/"
 
-parallelExecution in PerfTest := false
 
-parallelExecution in UnitTest := true
 
-testOptions in (PerfTest, test) := Seq(Tests.Filter(s => s.endsWith("PerfTest")))
 
 def ghProject(repo: String, version: String) = RootProject(uri(s"${repo}#${version}"))
 
@@ -131,9 +145,10 @@ lazy val bonsai      = ghProject("git://github.com/colder/bonsai.git",     "0fec
 lazy val scalaSmtLib = ghProject("git://github.com/regb/scala-smtlib.git", "6b74fb332416d470e0be7bf6e94ebc18fd300c2f")
 
 lazy val root = (project in file(".")).
-  configs(PerfTest).
-  configs(UnitTest).
+  configs(RegressionTest).
+  configs(IntegrTest).
   dependsOn(bonsai, scalaSmtLib).
-  settings(inConfig(PerfTest)(Defaults.testSettings): _*).
-  settings(inConfig(UnitTest)(Defaults.testSettings): _*)
+  settings(inConfig(RegressionTest)(Defaults.testSettings): _*).
+  settings(inConfig(IntegrTest)(Defaults.testSettings): _*)
+
 
diff --git a/src/integration/scala/leon/test/LeonTestSuite.scala b/src/integration/scala/leon/test/LeonTestSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..5a095725c0479f99ca3f145745d775f0f6e78786
--- /dev/null
+++ b/src/integration/scala/leon/test/LeonTestSuite.scala
@@ -0,0 +1,50 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test
+
+import leon._
+import leon.purescala.Definitions.Program
+import leon.LeonContext
+import leon.utils._
+import leon.frontends.scalac.ExtractionPhase
+
+import org.scalatest._
+import org.scalatest.exceptions.TestFailedException
+
+trait LeonTestSuiteMeh extends fixture.FunSuite {
+  type FixtureParam = LeonContext
+
+  override def withFixture(test: OneArgTest): Outcome = {
+    val reporter = new TestSilentReporter
+    val opts     = List[String]()
+
+    val ctx      = Main.processOptions(opts).copy(reporter = reporter)
+
+    try {
+      test(ctx)
+    } catch {
+      case fe: LeonFatalError =>
+        reporter.lastErrors ++= fe.msg
+        Failed(new TestFailedException(reporter.lastErrors.mkString("\n"), fe, 5))
+    }
+  }
+
+  def parseString(str: String)(implicit ctx: LeonContext): Program = {
+    parseStrings(List(str))(ctx)
+  }
+
+  def parseStrings(strs: List[String])(implicit ctx: LeonContext): Program = {
+    val pipeline = TemporaryInputPhase andThen
+                   ExtractionPhase andThen
+                   PreprocessingPhase
+
+    val errorsBefore = ctx.reporter.errorCount
+
+    val program = pipeline.run(ctx)((strs, Nil))
+
+    assert(ctx.reporter.errorCount === errorsBefore)
+
+    program
+  }
+
+}
diff --git a/src/integration/scala/leon/test/LeonTestSuiteWithProgram.scala b/src/integration/scala/leon/test/LeonTestSuiteWithProgram.scala
new file mode 100644
index 0000000000000000000000000000000000000000..17d65364de16d2a37b26be4a6ca147ac5c5ccb41
--- /dev/null
+++ b/src/integration/scala/leon/test/LeonTestSuiteWithProgram.scala
@@ -0,0 +1,72 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test
+
+import leon._
+import leon.purescala.Definitions.Program
+import leon.LeonContext
+import leon.utils._
+import leon.frontends.scalac.ExtractionPhase
+
+import org.scalatest._
+import org.scalatest.exceptions.TestFailedException
+
+import scala.language.implicitConversions
+
+trait LeonTestSuiteWithProgram extends fixture.FunSuite {
+
+  implicit def fixtureToCtx(implicit f: FixtureParam): LeonContext = f._1
+  implicit def fixtureToPgm(implicit f: FixtureParam): Program = f._2
+
+  val leonOpts = List[String]()
+
+  val pipeline =
+    TemporaryInputPhase andThen
+    ExtractionPhase andThen
+    PreprocessingPhase
+
+  val sources: List[String]
+
+  private[this] var fixtureCache: Option[(LeonContext, Program)] = None
+
+  def getFixture(): (LeonContext, Program) = synchronized {
+    if (fixtureCache.isEmpty) {
+      val reporter = new TestSilentReporter
+      val im       = new InterruptManager(reporter)
+
+      val ctx      = Main.processOptions(leonOpts).copy(reporter = reporter, interruptManager = im)
+
+      val pgm      = pipeline.run(ctx)((sources, Nil))
+
+      fixtureCache = Some((ctx, pgm))
+    }
+
+    fixtureCache.get
+  }
+
+  type FixtureParam = (LeonContext, Program)
+
+  override def withFixture(test: OneArgTest): Outcome = {
+    try {
+      val (ctx, pgm) = getFixture()
+      try {
+        val freshReporter = new TestSilentReporter
+
+        val f = (ctx.copy(reporter = freshReporter), pgm)
+
+        test(f)
+      } catch {
+        case fe: LeonFatalError =>
+          ctx.reporter match {
+            case sr: TestSilentReporter =>
+              sr.lastErrors ++= fe.msg
+              Failed(new TestFailedException(sr.lastErrors.mkString("\n"), fe, 5))
+          }
+      }
+    } catch {
+      case t: Throwable  =>
+        Failed(t)
+    }
+  }
+}
+
diff --git a/src/unit-test/scala/leon/TestSilentReporter.scala b/src/integration/scala/leon/test/TestSilentReporter.scala
similarity index 88%
rename from src/unit-test/scala/leon/TestSilentReporter.scala
rename to src/integration/scala/leon/test/TestSilentReporter.scala
index 9802995c66f505e0820842898045d4a8fcfc74a9..a303d35a99ed6a76d2068a9a279fb5ec664e5d38 100644
--- a/src/unit-test/scala/leon/TestSilentReporter.scala
+++ b/src/integration/scala/leon/test/TestSilentReporter.scala
@@ -1,6 +1,7 @@
 /* Copyright 2009-2015 EPFL, Lausanne */
 
-package leon
+package leon.test
+import leon.DefaultReporter
 
 class TestSilentReporter extends DefaultReporter(Set()) {
   var lastErrors: List[String] = Nil
diff --git a/src/test/scala/leon/test/codegen/CodeGenSuite.scala b/src/integration/scala/leon/test/evaluators/CodegenEvaluatorSuite.scala
similarity index 65%
rename from src/test/scala/leon/test/codegen/CodeGenSuite.scala
rename to src/integration/scala/leon/test/evaluators/CodegenEvaluatorSuite.scala
index f58cc604b9ef1396a3206e88157d130a6a3ba5ac..bddf8da587782f2c9bd2b2b535b6b11c31f9cbae 100644
--- a/src/test/scala/leon/test/codegen/CodeGenSuite.scala
+++ b/src/integration/scala/leon/test/evaluators/CodegenEvaluatorSuite.scala
@@ -1,134 +1,26 @@
 /* Copyright 2009-2015 EPFL, Lausanne */
 
-package leon.test.codegen
+package leon.test.evaluators
 
 import leon._
-import leon.codegen._
+import leon.evaluators._ 
+
+import leon.utils.{TemporaryInputPhase, PreprocessingPhase}
+import leon.frontends.scalac.ExtractionPhase
+
+import leon.purescala.Common._
 import leon.purescala.Definitions._
 import leon.purescala.Expressions._
+import leon.purescala.DefOps._
 import leon.purescala.Types._
-import leon.evaluators.{CodeGenEvaluator,EvaluationResults}
-import EvaluationResults._
-
-/*
- * To add a new test:
- * - Add your test, preferably in a new module, in the test variable
- * - Make sure the function under test is named "test" and has no parameters
- * - Add the test name and expected result in the result variable.
- *   Make sure the relative order of the tests matches that of code
- */
-class CodeGenSuite extends test.LeonTestSuite {
- 
-  case class TestCase(
-    name : String,
-    expectedResult: Expr,
-    testFunction: FunDef
-  )
-
-  def runTests() = {
-    val catchAll = true
-  
-    val pipeline = 
-      utils.TemporaryInputPhase andThen
-      frontends.scalac.ExtractionPhase andThen
-      utils.PreprocessingPhase
-    
-    val ctx = createLeonContext() 
-      
-    val ast = pipeline.run(ctx)( (code, List()) )
-    
-    val testFuns = ast.definedFunctions.filter {
-      _.id.name == "test"
-    }.sortWith{ ( f1, f2 ) => f1.getPos < f2.getPos }
-    
-    val testCases = results zip testFuns map { 
-      case ( (name, result), fd ) =>
-        TestCase(name, result, fd)
-    }
-
-    assert(results.size == testFuns.size)
-    
-    for {
-      requireMonitor <- Seq(false, true)
-      doInstrument <- Seq(false,true)
-      evaluator = new CodeGenEvaluator(createLeonContext(), ast, CodeGenParams(
-        maxFunctionInvocations = if (requireMonitor) 1000 else -1, // Monitor calls and abort execution if more than X calls
-        checkContracts = true,      // Generate calls that checks pre/postconditions
-        doInstrument = doInstrument // Instrument reads to case classes (mainly for vanuatoo)
-      ))
-      TestCase(name, expected, testFunction) <- testCases
-      suffix = (if (requireMonitor) "M" else "") + ( if (doInstrument) "I" else "")
-    } test(name + suffix) { 
-      val body = testFunction.body.get
-      val params = testFunction.params map { _.id }
-      val compiled = evaluator.compile(body, params).getOrElse {
-        ctx.reporter.fatalError("Failed to compile test function!")
-      }
-      try { compiled(Nil) match {
-        case Successful(res) if res == expected =>
-          // Success
-        case RuntimeError(_) | EvaluatorError(_) if expected.isInstanceOf[Error] => 
-          // Success
-        case Successful(res) => 
-          ctx.reporter.fatalError(s"""
-            Program $name produced wrong output.
-            Output was ${res.toString}
-            Expected was ${expected.toString}       
-          """.stripMargin)
-        case RuntimeError(mes) => 
-          ctx.reporter.fatalError(s"Program $name threw runtime error with message $mes")
-        case EvaluatorError(res) =>  
-          ctx.reporter.fatalError(s"Evaluator failed for program $name with message $res")
-      }} catch {
-        // Currently, this is what we would like to catch and still succeed, but there might be more
-        case _ : LeonFatalError | _ : StackOverflowError if expected.isInstanceOf[Error] =>
-          // Success
-        case th : Throwable => 
-          if (catchAll) {
-            // This is to be able to continue testing after an error
-            println(s"Program $name failed!")
-            th.printStackTrace()
-            ctx.reporter.fatalError(s"Program $name failed\n${th.printStackTrace()}")// with message ${th.getMessage()}")
-          } else { throw th }
-      }
-    }
-  }
-
-  val results = Seq(
-    ("simple",            IntLiteral(1)),
-    ("simpleBigInt",      InfiniteIntegerLiteral(1)),
-    ("eager",             IntLiteral(43)),
-    ("this",              IntLiteral(42) ),
-    ("oldStuff",          IntLiteral(1)),
-    ("methSimple",        IntLiteral(10)),
-    ("methMakeBigInt",    InfiniteIntegerLiteral(42)),
-    ("methSimpleBigInt",  InfiniteIntegerLiteral(10)),
-    ("BigIntNoOverflow",  InfiniteIntegerLiteral(BigInt("4000000000"))),
-    ("BigIntOps",         InfiniteIntegerLiteral(BigInt(7))),
-    ("BigIntComp0",       BooleanLiteral(true)),
-    ("BigIntComp1",       InfiniteIntegerLiteral(BigInt(17))),
-    ("BigIntComp2",       InfiniteIntegerLiteral(BigInt(12))),
-    ("BigIntComp3",       InfiniteIntegerLiteral(BigInt(-7))),
-    ("methods",           IntLiteral(15)),
-    ("lazy",              IntLiteral(1 + 5 + 1 + 6 + 2) ),
-    ("modules",           IntLiteral(1 + 2 + 0) ),
-    ("lazyISLazy" ,       IntLiteral(42) ),
-    ("ListWithSize" ,     IntLiteral(3) ),
-    ("ListWithSumMono" ,  IntLiteral(1 + 2 + 3) ),
-    ("poly" ,             IntLiteral(42) ),
-    ("ListHead" ,         IntLiteral(1)),
-    ("ListWithSum" ,      IntLiteral(1 + 2 + 3) ), 
-    // This one loops!    
-    ("lazyLoops" ,        Error(Untyped, "Looping") ),
-    ("Lazier" ,           IntLiteral(1 + 2 + 3) ),
-    ("SetToList",         BooleanLiteral(true) ),
-    ("Overrides1",        Tuple(Seq(BooleanLiteral(false), BooleanLiteral(true))) ),
-    ("Overrides2",        Tuple(Seq(BooleanLiteral(false), BooleanLiteral(true))) )
-  )
+import leon.purescala.Extractors._
+import leon.purescala.Constructors._
 
+import leon.codegen._
 
+class CodegenEvaluatorSuite extends leon.test.LeonTestSuiteWithProgram {
 
-  val code = """
+  val sources = List("""
     import leon.lang._
 
     object simple {
@@ -208,31 +100,31 @@ class CodeGenSuite extends test.LeonTestSuite {
       
       def test = Con().f2(2000000000)
     }
-    object methSimple5 {
+    object bigint1 {
       
       def f(x: BigInt): BigInt = ((x * 2) - 10)/2
       
       def test = f(12)
     }
-    object methSimple6 {
+    object bigint2 {
       
       def f(x: BigInt): Boolean = x == BigInt(17)
       
       def test = f(17)
     }
-    object methSimple7 {
+    object bigint3 {
       
       def f(x: BigInt): BigInt = if(x <= 0) -x else x
       
       def test = f(-17)
     }
-    object methSimple8 {
+    object bigint4 {
       
       def f(x: BigInt): BigInt = if(x < 0) -x else x
       
       def test = f(-12)
     }
-    object methSimple9 {
+    object bigint5 {
       
       def f(x: BigInt): BigInt = if(x >= 0) -x else x
       
@@ -385,7 +277,69 @@ class CodeGenSuite extends test.LeonTestSuite {
 
       def test = (B().x, C().x)
     }
-  """
+  """)
+
+  val results = Seq(
+    ("simple",            IntLiteral(1)),
+    ("simple2",           InfiniteIntegerLiteral(1)),
+    ("eager",             IntLiteral(43)),
+    ("thiss",             IntLiteral(42) ),
+    ("oldStuff",          IntLiteral(1)),
+    ("methSimple",        IntLiteral(10)),
+    ("methSimple2",       InfiniteIntegerLiteral(42)),
+    ("methSimple3",       InfiniteIntegerLiteral(10)),
+    ("methSimple4",       InfiniteIntegerLiteral(BigInt("4000000000"))),
+    ("bigint1",           InfiniteIntegerLiteral(BigInt(7))),
+    ("bigint2",           BooleanLiteral(true)),
+    ("bigint3",           InfiniteIntegerLiteral(BigInt(17))),
+    ("bigint4",           InfiniteIntegerLiteral(BigInt(12))),
+    ("bigint5",           InfiniteIntegerLiteral(BigInt(-7))),
+    ("methods",           IntLiteral(15)),
+    ("lazyFields",        IntLiteral(1 + 5 + 1 + 6 + 2) ),
+    ("modules",           IntLiteral(1 + 2 + 0) ),
+    ("lazyISLazy" ,       IntLiteral(42) ),
+    ("ListWithSize" ,     IntLiteral(3) ),
+    ("ListWithSumMono" ,  IntLiteral(1 + 2 + 3) ),
+    ("poly" ,             IntLiteral(42) ),
+    ("ListHead" ,         IntLiteral(1)),
+    ("ListWithSum" ,      IntLiteral(1 + 2 + 3) ), 
+    // This one loops!    
+    ("lazyLoops" ,        Error(Untyped, "Looping") ),
+    ("Lazier" ,           IntLiteral(1 + 2 + 3) ),
+    ("SetToList",         BooleanLiteral(true) ),
+    ("Overrides1",        Tuple(Seq(BooleanLiteral(false), BooleanLiteral(true))) ),
+    ("Overrides2",        Tuple(Seq(BooleanLiteral(false), BooleanLiteral(true))) )
+  )
+
+  for {
+    (name, exp) <- results
+    requireMonitor <- Seq(false, true)
+    doInstrument <- Seq(false,true)
+  } {
+    val opts = ((if(requireMonitor) Some("monitor") else None) ++
+               (if(doInstrument) Some("instrument") else None)).mkString("+")
+
+    val testName = f"$name%-20s $opts%-18s"
+
+    test("Evaluation of "+testName) { case (ctx, pgm) =>
+      val eval = new CodeGenEvaluator(ctx, pgm, CodeGenParams(
+        maxFunctionInvocations = if (requireMonitor) 1000 else -1, // Monitor calls and abort execution if more than X calls
+        checkContracts = true,      // Generate calls that checks pre/postconditions
+        doInstrument = doInstrument // Instrument reads to case classes (mainly for vanuatoo)
+      ))
 
-  runTests()
+      val fun = pgm.lookup(name+".test").collect {
+        case fd: FunDef => fd
+      }.getOrElse {
+        fail("Failed to lookup '"+name+".test'")
+      }
+
+      (eval.eval(FunctionInvocation(fun.typed(Seq()), Seq())).result, exp) match {
+        case (Some(res), exp) =>
+        case (None, Error(_, _)) =>
+        case (None, _) =>
+        case (_, Error(_, _)) =>
+      }
+    }
+  }
 }
diff --git a/src/integration/scala/leon/test/evaluators/EvaluatorSuite.scala b/src/integration/scala/leon/test/evaluators/EvaluatorSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..93f6139d828622bdbdc396e3baa5a2c9bce1c9b3
--- /dev/null
+++ b/src/integration/scala/leon/test/evaluators/EvaluatorSuite.scala
@@ -0,0 +1,400 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.allEvaluators
+
+import leon._
+import leon.test._
+import leon.evaluators._
+
+import leon.utils.{TemporaryInputPhase, PreprocessingPhase}
+import leon.frontends.scalac.ExtractionPhase
+
+import leon.purescala.Common._
+import leon.purescala.Definitions._
+import leon.purescala.Expressions._
+import leon.purescala.DefOps._
+import leon.purescala.Types._
+import leon.purescala.Extractors._
+import leon.purescala.Constructors._
+import leon.codegen._
+
+class EvaluatorSuite extends LeonTestSuiteWithProgram with helpers.ExpressionsDSL {
+
+  val sources = List(
+    """|object CaseClasses {
+       |  sealed abstract class List
+       |  case class Nil() extends List
+       |  case class Cons(head : Int, tail : List) extends List
+       |
+       |  case class MySingleton(i : Int)
+       |
+       |  def size(l : List) : Int = l match {
+       |    case Nil() => 0
+       |    case Cons(_, xs) => 1 + size(xs)
+       |  }
+       |
+       |  def compare(l1 : List, l2 : List) : Boolean = (l1 == l2)
+       |
+       |  def head(l : List) : Int = l match {
+       |    case Cons(h, _) => h
+       |  }
+       |
+       |  def wrap(i : Int) : MySingleton = MySingleton(i)
+       |}""".stripMargin,
+
+    """|import leon.lang._
+       |object Sets {
+       |  sealed abstract class List
+       |  case class Nil() extends List
+       |  case class Cons(head : Int, tail : List) extends List
+       |
+       |  def content(l : List) : Set[Int] = l match {
+       |    case Nil() => Set.empty[Int]
+       |    case Cons(x, xs) => Set(x) ++ content(xs)
+       |  }
+       |
+       |  def finite() : Set[Int] = Set(1, 2, 3)
+       |  def build(x : Int, y : Int, z : Int) : Set[Int] = Set(x, y, z)
+       |  def union(s1 : Set[Int], s2 : Set[Int]) : Set[Int] = s1 ++ s2
+       |  def inter(s1 : Set[Int], s2 : Set[Int]) : Set[Int] = s1 & s2
+       |  def diff(s1 : Set[Int], s2 : Set[Int]) : Set[Int] = s1 -- s2
+       |}""".stripMargin,
+
+    """|import leon.lang._
+       |object Maps {
+       |  sealed abstract class PList
+       |  case class PNil() extends PList
+       |  case class PCons(headfst : Int, headsnd : Int, tail : PList) extends PList
+       |
+       |  def toMap(pl : PList) : Map[Int,Int] = pl match {
+       |    case PNil() => Map.empty[Int,Int]
+       |    case PCons(f,s,xs) => toMap(xs).updated(f, s)
+       |  }
+       |
+       |  def finite0() : Map[Int,Int] = Map[Int, Int]()
+       |  def finite1() : Map[Int,Int] = Map(1 -> 2)
+       |  def finite2() : Map[Int,Int] = Map(2 -> 3, 1 -> 2)
+       |  def finite3() : Map[Int,Int] = finite1().updated(2, 3)
+       |}""".stripMargin,
+
+    """|import leon.lang._
+       |object Sets2 {
+       |  case class MyPair(x : Int, y : Boolean)
+       |
+       |  def buildPairCC(x : Int, y : Boolean) : MyPair = MyPair(x,y)
+       |  def mkSingletonCC(p : MyPair) : Set[MyPair] = Set(p)
+       |  def containsCC(s : Set[MyPair], p : MyPair) : Boolean = s.contains(p)
+       |
+       |  def buildPairT(x : Int, y : Boolean) : (Int,Boolean) = (x,y)
+       |  def mkSingletonT(p : (Int,Boolean)) : Set[(Int,Boolean)] = Set(p)
+       |  def containsT(s : Set[(Int,Boolean)], p : (Int,Boolean)) : Boolean = s.contains(p)
+       |}""".stripMargin,
+
+    """|import leon.lang._
+       |import leon.lang.synthesis._
+       |object Choose {
+       |  def c(i : Int) : Int = choose { (j : Int) => j > i && j < i + 2 }
+       |}
+       |""".stripMargin,
+
+    """|import leon.lang._
+       |object Recursion {
+       |  import leon.lang._
+       |
+       |  def c(i : Int) : Int = c(i-1)
+       |}
+       |""".stripMargin,
+
+    """|import leon.lang._
+       |object Contracts {
+       |
+       |  def c(i : Int) : Int = {
+       |    require(i > 0);
+       |    c(i-1)
+       |  }
+       |}
+       |""".stripMargin,
+
+    """|import leon.lang._
+       |object PatMat {
+       |  abstract class List;
+       |  case class Cons(h: Int, t: List) extends List;
+       |  case object Nil extends List;
+       |
+       |  def f1: Int = (Cons(1, Nil): List) match {
+       |    case Cons(h, t) => h
+       |    case Nil => 0
+       |  }
+       |
+       |  def f2: Int = (Cons(1, Nil): List) match {
+       |    case Cons(h, _) => h
+       |    case Nil => 0
+       |  }
+       |
+       |  def f3: Int = (Nil: List) match {
+       |    case _ => 1
+       |  }
+       |
+       |  def f4: Int = (Cons(1, Cons(2, Nil)): List) match {
+       |    case a: Cons => 1
+       |    case _ => 0
+       |  }
+       |
+       |  def f5: Int = ((Cons(1, Nil), Nil): (List, List)) match {
+       |    case (a: Cons, _) => 1
+       |    case _ => 0
+       |  }
+       |
+       |  def f6: Int = (Cons(2, Nil): List) match {
+       |    case Cons(h, t) if h > 0 => 1
+       |    case _ => 0
+       |  }
+       |}""".stripMargin,
+
+    """import leon.lang._
+      |object Lambda {
+      |  val foo1 = (x: BigInt) => x
+      |  val foo2 = {
+      |    val a = BigInt(1)
+      |    (x: BigInt) => a + x
+      |  }
+      |  val foo3 = {
+      |    val f1 = (x: BigInt) => x + 1
+      |    val f2 = (x: BigInt) => x + 2
+      |    (x: BigInt, y: BigInt) => f1(x) + f2(y)
+      |  }
+      |  def foo4(x: BigInt) = (i: BigInt) => i + x
+      |}""".stripMargin,
+
+    """object Methods {
+      |  abstract class A
+      |
+      |  abstract class B extends A {
+      |    def foo(i: BigInt) = {
+      |      require(i > 0)
+      |      i + 1
+      |    } ensuring ( _ >= 0 )
+      |  }
+      |
+      |  case class C(x: BigInt) extends B {
+      |    val y = BigInt(42)
+      |    override def foo(i: BigInt) = {
+      |      x + y + (if (i>0) i else -i)
+      |    } ensuring ( _ >= x )
+      |  }
+      |
+      |  case class D() extends A
+      |
+      |  def f1 = {
+      |    val c = C(42)
+      |    (if (c.foo(0) + c.x > 0) c else D()).isInstanceOf[B]
+      |  }
+      |  def f2 = D().isInstanceOf[B]
+      |  def f3 = C(42).isInstanceOf[A]
+      |}""".stripMargin
+  )
+
+  def normalEvaluators(implicit ctx: LeonContext, pgm: Program): List[Evaluator] = {
+    List(
+      new DefaultEvaluator(ctx, pgm)
+    )
+  }
+
+  def codegenEvaluators(implicit ctx: LeonContext, pgm: Program): List[Evaluator] = {
+    List(
+      new CodeGenEvaluator(ctx, pgm)
+    )
+  }
+
+  def allEvaluators(implicit ctx: LeonContext, pgm: Program): List[Evaluator] = {
+    normalEvaluators ++ codegenEvaluators
+  }
+
+  test("Case classes") { implicit fix =>
+    val nil = cc("CaseClasses.Nil")()
+    def cons(es: Expr*) = cc("CaseClasses.Cons")(es: _*)
+
+    val cons12a = cons(i(1), cons(i(2), nil))
+    val cons12b = cons(i(1), cons(i(2), nil))
+    val sing1   = cc("CaseClasses.MySingleton")(i(1))
+
+    for(e <- allEvaluators) {
+      eval(e, fcall("CaseClasses.size")(nil))                  === i(0)
+      eval(e, fcall("CaseClasses.size")(cons12a))              === i(2)
+      eval(e, fcall("CaseClasses.compare")(nil, cons12a))      === F
+      eval(e, fcall("CaseClasses.compare")(cons12a, cons12b))  === T
+      eval(e, fcall("CaseClasses.head")(cons12a))              === i(1)
+
+      eval(e, Equals(fcall("CaseClasses.wrap")(i(1)), sing1)) === T
+
+      // Match error
+      eval(e, fcall("CaseClasses.head")(nil)).failed
+    }
+  }
+
+  test("Sets") { implicit fix  =>
+    val nil = cc("Sets.Nil")()
+    def cons(es: Expr*) = cc("Sets.Cons")(es: _*)
+
+    val cons12 = cons(i(1), cons(i(2), nil))
+
+    val es     = FiniteSet(Set(), Int32Type)
+    val s2     = FiniteSet(Set(i(2)), Int32Type)
+    val s12    = FiniteSet(Set(i(1), i(2)), Int32Type)
+    val s13    = FiniteSet(Set(i(1), i(3)), Int32Type)
+    val s46    = FiniteSet(Set(i(4), i(6)), Int32Type)
+    val s123   = FiniteSet(Set(i(1), i(2), i(3)), Int32Type)
+    val s246   = FiniteSet(Set(i(2), i(4), i(6)), Int32Type)
+    val s12346 = FiniteSet(Set(i(1), i(2), i(3), i(4), i(6)), Int32Type)
+
+    for(e <- allEvaluators) {
+      eval(e, fcall("Sets.finite")())                === s123
+      eval(e, fcall("Sets.content")(nil))            === es
+      eval(e, fcall("Sets.content")(cons12))         === s12
+      eval(e, fcall("Sets.build")(i(1), i(2), i(3))) === s123
+      eval(e, fcall("Sets.build")(i(1), i(2), i(2))) === s12
+      eval(e, fcall("Sets.union")(s123, s246))       === s12346
+      eval(e, fcall("Sets.union")(s246, s123))       === s12346
+      eval(e, fcall("Sets.inter")(s123, s246))       === s2
+      eval(e, fcall("Sets.inter")(s246, s123))       === s2
+      eval(e, fcall("Sets.diff")(s123, s246))        === s13
+      eval(e, fcall("Sets.diff")(s246, s123))        === s46
+
+      eval(e, Equals(fcall("Sets.union")(s123, s246), fcall("Sets.union")(s246, s123))) === T
+      eval(e, Equals(fcall("Sets.inter")(s123, s246), fcall("Sets.inter")(s246, s123))) === T
+      eval(e, Equals(fcall("Sets.diff")(s123, s246),  fcall("Sets.diff")(s246, s123)))   === F
+    }
+  }
+
+  test("Maps") { implicit fix  =>
+    val cons1223 = cc("Maps.PCons")(i(1), i(2), cc("Maps.PCons")(i(2), i(3), cc("Maps.PNil")()))
+
+    def eqMap(a: Expr, m: Map[Expr, Expr]) = a match {
+      case FiniteMap(es1, _, _) =>
+        es1.toMap === m
+      case e =>
+        fail("Expected FiniteMap, got "+e)
+    }
+
+    val em     = FiniteMap(Seq(), Int32Type, Int32Type)
+
+    for(e <- allEvaluators) {
+      eqMap(eval(e, fcall("Maps.finite0")()).res, Map())
+      eqMap(eval(e, fcall("Maps.finite1")()).res, Map(i(1) -> i(2)))
+      eqMap(eval(e, fcall("Maps.finite2")()).res, Map(i(1) -> i(2), i(2) -> i(3)))
+      eqMap(eval(e, fcall("Maps.toMap")(cons1223)).res, Map(i(1) -> i(2), i(2) -> i(3)))
+
+      eval(e, Equals(fcall("Maps.finite1")(), fcall("Maps.finite2")())) === F
+      eval(e, Equals(fcall("Maps.finite2")(), fcall("Maps.finite3")())) === T
+      eval(e, MapIsDefinedAt(fcall("Maps.finite2")(), i(2)))          === T
+      eval(e, MapIsDefinedAt(fcall("Maps.finite2")(), i(3)))          === F
+    }
+  }
+
+  test("Sets and maps of structures") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, fcall("Sets2.containsCC")(fcall("Sets2.mkSingletonCC")(fcall("Sets2.buildPairCC")(i(42), T)), fcall("Sets2.buildPairCC")(i(42), T))) === T
+      eval(e, fcall("Sets2.containsT")(fcall("Sets2.mkSingletonT")(fcall("Sets2.buildPairT")(i(42), T)), fcall("Sets2.buildPairT")(i(42), T))) === T
+    }
+  }
+
+  test("Executing Chooses") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, fcall("Choose.c")(i(42))) === i(43)
+    }
+  }
+
+  test("Infinite Recursion") { implicit fix =>
+    val e = new CodeGenEvaluator(fix._1, fix._2, CodeGenParams.default.copy(maxFunctionInvocations = 32))
+
+    eval(e, fcall("Recursion.c")(i(42))).failed
+  }
+
+  test("Wrong Contracts") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, fcall("Contracts.c")(i(-42))).failed
+    }
+  }
+
+  test("Pattern Matching") { implicit fix =>
+    for(e <- allEvaluators) {
+      // Some simple math.
+      eval(e, fcall("PatMat.f1")()) === i(1)
+      eval(e, fcall("PatMat.f2")()) === i(1)
+      eval(e, fcall("PatMat.f3")()) === i(1)
+      eval(e, fcall("PatMat.f4")()) === i(1)
+      eval(e, fcall("PatMat.f5")()) === i(1)
+      eval(e, fcall("PatMat.f6")()) === i(1)
+    }
+  }
+
+  test("Lambda functions") { implicit fix =>
+    def checkLambda(e: Evaluator, in: Expr, out: PartialFunction[Expr, Boolean]) {
+      val res = eval(e, in).success
+      if (!out.isDefinedAt(res) || !out(res))
+        throw new AssertionError(s"Evaluation of '$in' with evaluator '${e.name}' produced invalid '$res'.")
+    }
+
+    val ONE = bi(1)
+    val TWO = bi(2)
+
+    for(e <- allEvaluators) {
+      checkLambda(e, fcall("Lambda.foo1")(), {
+        case Lambda(Seq(vd), Variable(id)) if vd.id == id => true 
+      })
+      checkLambda(e, fcall("Lambda.foo2")(), {
+        case Lambda(Seq(vd), Plus(ONE, Variable(id))) if vd.id == id => true
+      })
+      checkLambda(e, fcall("Lambda.foo3")(), {
+        case Lambda(Seq(vx, vy), Plus(Plus(Variable(x), ONE), Plus(Variable(y), TWO))) if vx.id == x && vy.id == y => true 
+      })
+      checkLambda(e, fcall("Lambda.foo4")(TWO), {
+        case Lambda(Seq(vd), Plus(Variable(id), TWO)) if vd.id == id => true 
+      })
+    }
+  }
+
+  test("Methods") { implicit fix =>
+    for(e <- allEvaluators) {
+      // Some simple math.
+      eval(e, fcall("Methods.f1")()) === T
+      eval(e, fcall("Methods.f2")()) === F
+      eval(e, fcall("Methods.f3")()) === T
+    }
+  }
+
+  abstract class EvalDSL {
+    def res: Expr
+    def ===(res: Expr): Unit
+    def failed: Unit = {}
+    def success: Expr = res
+  }
+
+  case class Success(expr: Expr, env: Map[Identifier, Expr], evaluator: Evaluator, res: Expr) extends EvalDSL {
+    override def failed = {
+      fail(s"Evaluation of '$expr' with '$evaluator' (and env $env) should have failed")
+    }
+
+    def ===(exp: Expr) = {
+      assert(res === exp)
+    }
+  }
+
+  case class Failed(expr: Expr, env: Map[Identifier, Expr], evaluator: Evaluator, err: String) extends EvalDSL {
+    override def success = {
+      fail(s"Evaluation of '$expr' with '$evaluator' (and env $env) should have succeeded but failed with $err")
+    }
+
+    def res = success
+
+    def ===(res: Expr) = success
+  }
+
+  def eval(e: Evaluator, toEval: Expr, env: Map[Identifier, Expr] = Map()): EvalDSL = {
+    e.eval(toEval, env) match {
+      case EvaluationResults.Successful(res)     => Success(toEval, env, e, res)
+      case EvaluationResults.RuntimeError(err)   => Failed(toEval, env, e, err)
+      case EvaluationResults.EvaluatorError(err) => Failed(toEval, env, e, err)
+    }
+  }
+}
diff --git a/src/integration/scala/leon/test/helpers/ExpressionsDSL.scala b/src/integration/scala/leon/test/helpers/ExpressionsDSL.scala
new file mode 100644
index 0000000000000000000000000000000000000000..08ab658815eb5cd51ef5b821261d5484ba878112
--- /dev/null
+++ b/src/integration/scala/leon/test/helpers/ExpressionsDSL.scala
@@ -0,0 +1,72 @@
+package leon.test.helpers
+
+import org.scalatest.Assertions
+
+import leon.purescala.Definitions._
+import leon.purescala.Common._
+import leon.purescala.Types._
+import leon.purescala.Expressions._
+
+trait ExpressionsDSL {
+  self: Assertions =>
+
+  val F = BooleanLiteral(false)
+  val T = BooleanLiteral(true)
+
+  def bi(x: Int)    = InfiniteIntegerLiteral(x)
+  def b(x: Boolean) = BooleanLiteral(x)
+  def i(x: Int)     = IntLiteral(x)
+  def r(x: Double)  = RealLiteral(BigDecimal(x))
+
+  val a = FreshIdentifier("a", Int32Type).toVariable
+  val b = FreshIdentifier("b", Int32Type).toVariable
+  val c = FreshIdentifier("c", Int32Type).toVariable
+
+  val x = FreshIdentifier("x", IntegerType).toVariable
+  val y = FreshIdentifier("y", IntegerType).toVariable
+  val z = FreshIdentifier("z", IntegerType).toVariable
+
+  val m = FreshIdentifier("m", RealType).toVariable
+  val n = FreshIdentifier("n", RealType).toVariable
+  val o = FreshIdentifier("o", RealType).toVariable
+
+  val p = FreshIdentifier("p", BooleanType).toVariable
+  val q = FreshIdentifier("q", BooleanType).toVariable
+  val r = FreshIdentifier("r", BooleanType).toVariable
+
+
+  def funDef(name: String)(implicit pgm: Program): FunDef = {
+    pgm.lookupAll(name).collect {
+      case fd: FunDef => fd
+    }.headOption.getOrElse {
+      fail(s"Failed to lookup function '$name' in program")
+    }
+  }
+
+  def classDef(name: String)(implicit pgm: Program): ClassDef = {
+    pgm.lookupAll(name).collect {
+      case cd: ClassDef => cd
+    }.headOption.getOrElse {
+      fail(s"Failed to lookup class '$name' in program")
+    }
+  }
+
+  def caseClassDef(name: String)(implicit pgm: Program): CaseClassDef = {
+    pgm.lookupAll(name).collect {
+      case ccd: CaseClassDef => ccd
+    }.headOption.getOrElse {
+      fail(s"Failed to lookup case class '$name' in program")
+    }
+  }
+
+  def cc(name: String)(args: Expr*)(implicit pgm: Program): Expr = {
+    val cct = caseClassDef(name).typed(Seq())
+    CaseClass(cct, args.toSeq)
+  }
+
+  def fcall(name: String)(args: Expr*)(implicit pgm: Program): Expr = {
+    val tfd = funDef(name).typed(Seq())
+    FunctionInvocation(tfd, args.toSeq)
+  }
+
+}
diff --git a/src/integration/scala/leon/test/helpers/WithLikelyEq.scala b/src/integration/scala/leon/test/helpers/WithLikelyEq.scala
new file mode 100644
index 0000000000000000000000000000000000000000..aee9e7671d5f0d64e4e81bd0a6b82c6b514b2e20
--- /dev/null
+++ b/src/integration/scala/leon/test/helpers/WithLikelyEq.scala
@@ -0,0 +1,65 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.helpers
+
+import org.scalatest.Assertions
+
+import leon.test._
+import leon.evaluators._
+import leon.purescala.Common._
+import leon.LeonContext
+import leon.purescala.Types._
+import leon.purescala.Definitions._
+import leon.purescala.ExprOps._
+import leon.purescala.Expressions._
+import leon.utils.SeqUtils._
+
+/*
+ * Determine if two expressions over arithmetic variables are likely to be equal.
+ *
+ * This is a probabilistic based approach, it does not rely on any external solver and can
+ * only prove the non equality of two expressions.
+ */
+trait WithLikelyEq {
+  self: Assertions =>
+
+  val typesValues = Map[TypeTree, Seq[Expr]](
+    IntegerType -> Seq(-42, -1, 0, 1, 7, 42).map(InfiniteIntegerLiteral(_)),
+    Int32Type   -> Seq(-42, -1, 0, 1, 7, 42).map(IntLiteral(_)),
+    BooleanType -> Seq(BooleanLiteral(false), BooleanLiteral(true))
+  )
+
+  def checkLikelyEq(ctx: LeonContext, pgm: Program = Program.empty)(e1: Expr, e2: Expr, pre: Option[Expr] = None, values: Map[Identifier, Expr] = Map()): Unit = {
+    val evaluator = new DefaultEvaluator(ctx, pgm)
+
+    val freeVars = (variablesOf(e1) ++ variablesOf(e2)).toSeq.sortBy(_.globalId)
+
+    if (freeVars.isEmpty) {
+      val r1 = evaluator.eval(e1)
+      val r2 = evaluator.eval(e2)
+
+      assert(r1 === r2, s"'$e1' != '$e2' ('$r1' != '$r2')")
+    } else {
+
+      val allValues = freeVars.map(id => values.get(id).map(Seq(_)).getOrElse(typesValues(id.getType)))
+
+      cartesianProduct(allValues).foreach { vs =>
+        val m = (freeVars zip vs).toMap
+
+        val doTest = pre.map { p =>
+          evaluator.eval(p, m).result match {
+            case Some(BooleanLiteral(b)) => b
+            case _ => fail("Precondition is not a boolean expression")
+          }
+        }.getOrElse(true)
+
+        if (doTest) {
+          val r1 = evaluator.eval(e1, m)
+          val r2 = evaluator.eval(e2, m)
+
+          assert(r1 === r2, s"'$e1' != '$e2' with '$m' ('$r1' != '$r2')")
+        }
+      }
+    }
+  }
+}
diff --git a/src/integration/scala/leon/test/purescala/DataGenSuite.scala b/src/integration/scala/leon/test/purescala/DataGenSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..2ca61596f85e5422721a73b1a7ea1fd894622425
--- /dev/null
+++ b/src/integration/scala/leon/test/purescala/DataGenSuite.scala
@@ -0,0 +1,106 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.purescala
+
+import leon.test._
+import leon.utils.{TemporaryInputPhase, PreprocessingPhase}
+import leon.frontends.scalac.ExtractionPhase
+
+import leon.purescala.Common._
+import leon.purescala.Expressions._
+import leon.purescala.Definitions._
+import leon.purescala.Types._
+import leon.datagen._
+
+import leon.evaluators._
+
+class DataGenSuite extends LeonTestSuiteWithProgram with helpers.ExpressionsDSL {
+  val sources = List(
+    """|import leon.lang._
+       |object Program {
+       |  sealed abstract class List
+       |  case class Cons(head: Int, tail: List) extends List
+       |  case object Nil extends List
+       |
+       |  def size(lst: List): BigInt = lst match {
+       |    case Cons(_, xs) => 1 + size(xs)
+       |    case Nil => BigInt(0)
+       |  }
+       |
+       |  def isSorted(lst: List) : Boolean = lst match {
+       |    case Nil => true
+       |    case Cons(_, Nil) => true
+       |    case Cons(x, xs @ Cons(y, ys)) => x < y && isSorted(xs)
+       |  }
+       |
+       |  def content(lst: List) : Set[Int] = lst match {
+       |    case Nil => Set.empty[Int]
+       |    case Cons(x, xs) => Set(x) ++ content(xs)
+       |  }
+       |
+       |  def insertSpec(elem: Int, list: List, res: List) : Boolean = {
+       |    isSorted(res) && content(res) == (content(list) ++ Set(elem))
+       |  }
+       |}""".stripMargin
+  )
+
+  test("Lists") { implicit fix =>
+
+    val ctx = fix._1
+    val pgm = fix._2
+
+    val eval      = new DefaultEvaluator(ctx, pgm)
+    val generator = new GrammarDataGen(eval)
+
+    generator.generate(BooleanType).toSet.size === 2
+    generator.generate(TupleType(Seq(BooleanType,BooleanType))).toSet.size === 4
+
+    // Make sure we target our own lists
+
+    val listType = classDef("Program.List").typed(Seq())
+
+    assert(generator.generate(listType).take(100).toSet.size === 100, "Should be able to generate 100 different lists")
+
+    val l1 = FreshIdentifier("l1", listType).toVariable
+    val l2 = FreshIdentifier("l2", listType).toVariable
+
+    def size(x: Expr)    = fcall("Program.size")(x)
+    def content(x: Expr) = fcall("Program.content")(x)
+    def sorted(x: Expr)  = fcall("Program.isSorted")(x)
+
+    def spec(elem: Expr, list: Expr, res: Expr) = fcall("Program.insertSpec")(elem, list, res)
+    def cons(h: Expr, t: Expr) = cc("Program.Cons")(h, t)
+
+    assert(generator.generateFor(
+      Seq(l1.id),
+      GreaterThan(size(l1), bi(0)),
+      10,
+      500
+    ).size === 10, "Should find 10 non-empty lists in the first 500 enumerated")
+
+    assert(generator.generateFor(
+      Seq(l1.id, l2.id),
+      And(Equals(content(l1), content(l2)), sorted(l2)),
+      10,
+      500
+    ).size === 10, "Should find 2x 10 lists with same content in the first 500 enumerated")
+
+    assert(generator.generateFor(
+      Seq(l1.id, l2.id),
+      And(Seq(Equals(content(l1), content(l2)), sorted(l1), sorted(l2), Not(Equals(l1, l2)))),
+      1,
+      500
+    ).isEmpty, "There should be no models for this problem")
+
+    assert(generator.generateFor(
+      Seq(l1.id, l2.id, b.id, a.id),
+      And(Seq(
+        LessThan(a, b),
+        sorted(cons(a, l1)),
+        spec(b, l1, l2)
+      )),
+      10,
+      500
+    ).size >= 5, "There should be at least 5 models for this problem.")
+  }
+}
diff --git a/src/integration/scala/leon/test/purescala/DefOpsSuite.scala b/src/integration/scala/leon/test/purescala/DefOpsSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..663c533eb7adb4f8953f449d2032fe13b897dd70
--- /dev/null
+++ b/src/integration/scala/leon/test/purescala/DefOpsSuite.scala
@@ -0,0 +1,110 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.purescala
+
+import leon.test._
+
+import leon._
+import leon.purescala.Definitions._
+import leon.purescala.DefOps._
+import leon.utils._
+
+class DefOpsSuite extends LeonTestSuiteWithProgram {
+
+  val sources = List(
+    """ |package foo.bar.baz
+        |import other.hello.world.Foo
+        |import other.hello.world.Foo._
+        |import other.hello.world.!!!._
+        |import other.hello.world.m
+        |object Bar {
+        |  val x = 42
+        |  abstract class A
+        |  case class C(i : Int) extends A
+        |}
+        |
+        |object Foo {
+        |  import Bar.C
+        |  case class FooC()
+        |  val m = Bar.x + y + x
+        |  val ? = C(m)
+        |  val fooC = ? match {
+        |    case C(i) if i == 0 => FooC()
+        |    case _ => FooC()
+        |  }
+        |}""".stripMargin,
+
+    """ |package other.hello.world
+        |
+        |object !!! { val m = 42 }
+        |object m { val x = 0 }
+        |
+        |object Foo {
+        |  val y = 0 
+        |}""".stripMargin,
+
+    """ |package foo.bar
+        |package object baz {
+        |  val x = 42 
+        |}""".stripMargin,
+
+    """ |package foo.bar.baz.and.some.more
+        |object InSubpackage {}
+        |""".stripMargin,
+
+    """ object InEmpty { def arrayLookup(a : Array[Int], i : Int) = a(i) } """
+  )
+
+  def fooC(implicit pgm: Program) = {
+    pgm.lookup("foo.bar.baz.Foo.fooC")
+  }
+
+
+  test("Find base definition"){ case (ctx, pgm) =>
+    assert(fooC(pgm).isDefined)
+  }
+
+
+  test("In empty package") { case (ctx, pgm) =>
+    implicit val program = pgm
+    val name = "InEmpty.arrayLookup"
+    val df = pgm.lookup(name)
+    assert(df.isDefined)
+    assert{fullName(df.get) == name }
+  }
+
+    // Search by full name    
+   
+  def mustFind(name: String, msg: String) = test(msg) { case (ctx, pgm) =>
+    assert(searchRelative(name, fooC(pgm).get)(pgm).nonEmpty) 
+  }
+
+  def mustFail(name: String, msg: String) = test(msg) { case (ctx, pgm) =>
+    assert(searchRelative(name, fooC(pgm).get)(pgm).isEmpty) 
+  }
+
+  mustFind("fooC", "Find yourself")
+  mustFind("FooC", "Find a definition in the same scope 1")
+  mustFind("?",    "Find a definition in the same scope 2")
+  mustFind("m",    "Find a definition in the same scope 3")
+  mustFind("Foo",  "Find an enclosing definition")
+  mustFind("Bar",  "Find a definition in an enclosing scope")
+
+  mustFind("Bar.A",    "Find a definition in an object 1")
+  mustFind("Foo.fooC", "Find a definition in an object 2")
+
+  mustFind("y", "Find imported definition 1")
+  mustFind("x", "Find imported definition 2")
+  
+  mustFind("other.hello.world.Foo",     "Find a definition in another package")
+  mustFind("and.some.more.InSubpackage","Find a definition in a subpackage")
+  mustFind("InEmpty.arrayLookup",       "Find a definition in the empty package")
+
+  mustFail("nonExistent",    "Don't find non-existent definition")
+  mustFail("A",              "Don't find definition in another object")
+  mustFail("InSubpackage",   "Don't find definition in another package")
+  mustFail("hello.world.Foo","Don't find definition in non-visible nested package")
+  mustFail("!!!",            "Don't find definition that is root of a wildcard import")
+  mustFail("m.x",            "Don't find imported definition shadowed by local definition")
+
+}
diff --git a/src/integration/scala/leon/test/purescala/InliningSuite.scala b/src/integration/scala/leon/test/purescala/InliningSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..79c08ba355bb15df88aae5c7ce20e1b085d4395f
--- /dev/null
+++ b/src/integration/scala/leon/test/purescala/InliningSuite.scala
@@ -0,0 +1,48 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.purescala
+
+import leon.test._
+import leon.purescala.Expressions._
+
+class InliningSuite extends LeonTestSuiteWithProgram with helpers.ExpressionsDSL {
+  val sources = List(
+    """|
+       |import leon.lang._
+       |import leon.annotation._
+       |
+       |object InlineGood {
+       |
+       |  @inline
+       |  def foo(a: BigInt) = true
+       |
+       |  def bar(a: BigInt) = foo(a)
+       |
+       |} """.stripMargin,
+
+    """ |import leon.lang._
+       |import leon.annotation._
+       |
+       |object InlineBad {
+       |
+       |  @inline
+       |  def foo(a: BigInt): BigInt = if (a > 42) foo(a-1) else 0
+       |
+       |  def bar(a: BigInt) = foo(a)
+       |
+       |}""".stripMargin
+  )
+
+
+  test("Simple Inlining") { implicit fix =>
+    assert(funDef("InlineGood.bar").fullBody == BooleanLiteral(true), "Function not inlined?")
+  }
+
+  test("Recursive Inlining") { implicit fix =>
+    funDef("InlineBad.bar").fullBody match {
+      case FunctionInvocation(tfd, args) if tfd.id.name == "foo" => // OK, not inlined
+      case b =>
+        fail(s"Resultig body should be a call to 'foo', got '$b'")
+    }
+  }
+}
diff --git a/src/integration/scala/leon/test/purescala/SimplifyPathsSuite.scala b/src/integration/scala/leon/test/purescala/SimplifyPathsSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..b538c2492035542c32ba8ec51d1347bc98152753
--- /dev/null
+++ b/src/integration/scala/leon/test/purescala/SimplifyPathsSuite.scala
@@ -0,0 +1,90 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.purescala
+
+import leon.test._
+
+import leon._
+import leon.solvers._
+import leon.solvers.z3.UninterpretedZ3Solver
+import leon.purescala.Definitions.Program
+import leon.purescala.Expressions._
+import leon.purescala.Types._
+import leon.purescala.Common._
+import leon.purescala.ExprOps
+
+class SimplifyPathsSuite extends LeonTestSuite {
+  val a = FreshIdentifier("a", BooleanType)
+  val aV = a.toVariable
+  val b = FreshIdentifier("b", BooleanType)
+  val bV = b.toVariable
+  val c = FreshIdentifier("c", BooleanType)
+  val cV = b.toVariable
+
+  val l1 = InfiniteIntegerLiteral(1)
+  val l2 = InfiniteIntegerLiteral(2)
+
+  def simplifyPaths(ctx: LeonContext, expr: Expr): Expr = {
+    val uninterpretedZ3 = SolverFactory(() => new UninterpretedZ3Solver(ctx, Program.empty))
+    try {
+      ExprOps.simplifyPaths(uninterpretedZ3)(expr)
+    } finally {
+      uninterpretedZ3.shutdown()
+    }
+  }
+
+  test("Simplify Paths 01 - if(true)") { ctx => 
+    val in  = IfExpr(BooleanLiteral(true), l1, l2)
+    val exp = l1
+
+    val out = simplifyPaths(ctx, in)
+    assert(out === exp)
+  }
+
+  test("Simplify Paths 02 - expr match { .. }") { ctx => 
+    val x = FreshIdentifier("x", BooleanType)
+    val xV = x.toVariable
+
+    val in  = MatchExpr(Equals(And(aV, Not(bV)), Not(Or(Not(aV), bV))), Seq(
+      MatchCase(LiteralPattern(Some(x), BooleanLiteral(true)), None, And(xV, cV)),
+      MatchCase(LiteralPattern(None, BooleanLiteral(false)), None, Not(cV))
+
+    ))
+    val exp = cV
+
+    val out = simplifyPaths(ctx, in)
+    assert(out === exp)
+  }
+
+  test("Simplify Paths 03 - ") { ctx =>
+    val a = FreshIdentifier("a", IntegerType)
+    val aV = a.toVariable
+    val x = FreshIdentifier("x", IntegerType)
+    val y = FreshIdentifier("y", IntegerType)
+    val z = FreshIdentifier("y", IntegerType)
+    val w = FreshIdentifier("y", IntegerType)
+    val o = FreshIdentifier("o", IntegerType)
+
+    val l0 = InfiniteIntegerLiteral(0)
+    val l42 = InfiniteIntegerLiteral(42)
+
+    val in  = MatchExpr(aV, Seq(
+      MatchCase(LiteralPattern(None, l0), None, l0),
+      MatchCase(WildcardPattern(Some(x)), Some(GreaterEquals(x.toVariable, l42)),   Plus(x.toVariable, l42)),
+      MatchCase(WildcardPattern(Some(y)), Some(GreaterThan(y.toVariable, l42)),     Minus(x.toVariable, l42)),
+      MatchCase(WildcardPattern(Some(z)), Some(GreaterThan(z.toVariable, l0)),      Plus(z.toVariable, l42)),
+      MatchCase(WildcardPattern(Some(w)), Some(LessThan(w.toVariable, l0)),         Minus(w.toVariable, l42)),
+      MatchCase(WildcardPattern(Some(o)), None,                                     InfiniteIntegerLiteral(1000))
+    ))
+
+    val exp  = MatchExpr(aV, Seq(
+      MatchCase(LiteralPattern(None, l0), None, l0),
+      MatchCase(WildcardPattern(Some(x)), Some(GreaterEquals(x.toVariable, l42)),   Plus(x.toVariable, l42)),
+      MatchCase(WildcardPattern(Some(z)), Some(GreaterThan(z.toVariable, l0)),      Plus(z.toVariable, l42)),
+      MatchCase(WildcardPattern(Some(w)), None,                                     Minus(w.toVariable, l42))
+    ))
+
+    val out = simplifyPaths(ctx, in)
+    assert(out === exp)
+  }
+}
diff --git a/src/integration/scala/leon/test/solvers/EnumerationSolverSuite.scala b/src/integration/scala/leon/test/solvers/EnumerationSolverSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..561e4d24ec7e889ab426cf9dfef805cb16cab7e7
--- /dev/null
+++ b/src/integration/scala/leon/test/solvers/EnumerationSolverSuite.scala
@@ -0,0 +1,29 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.solvers
+
+import leon.test._
+import leon.solvers._
+import leon.purescala.Common._
+import leon.purescala.Definitions._
+import leon.purescala.Expressions._
+import leon.purescala.Types._
+import leon.LeonContext
+
+class EnumerationSolverSuite extends LeonSolverSuite {
+  def getSolver(implicit ctx: LeonContext, pgm: Program) = {
+    new EnumerationSolver(ctx, pgm)
+  }
+
+  val sources = Nil
+
+  test("EnumerationSolver 1 (true)") { implicit fix =>
+    sat(BooleanLiteral(true))
+  }
+
+  test("EnumerationSolver 2 (x == 1)") { implicit fix =>
+    val x = FreshIdentifier("x", IntegerType).toVariable
+
+    sat(Equals(x, InfiniteIntegerLiteral(0)))
+  }
+}
diff --git a/src/integration/scala/leon/test/solvers/FairZ3SolverTests.scala b/src/integration/scala/leon/test/solvers/FairZ3SolverTests.scala
new file mode 100644
index 0000000000000000000000000000000000000000..32b038322907b284aa2cf9b19a455f69f25ff685
--- /dev/null
+++ b/src/integration/scala/leon/test/solvers/FairZ3SolverTests.scala
@@ -0,0 +1,73 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.solvers
+
+import leon.test._
+import leon.purescala.Common._
+import leon.purescala.Definitions._
+import leon.purescala.Expressions._
+import leon.purescala.Types._
+import leon.LeonContext
+
+import leon.solvers._
+import leon.solvers.z3._
+
+class FairZ3SolverTests extends LeonSolverSuite {
+
+  val sources = List(
+    """|import leon.lang._
+       |
+       |object Minimal {
+       |  def f(x: BigInt) = x + 1
+       |}""".stripMargin
+   )
+
+  def getSolver(implicit ctx: LeonContext, pgm: Program) = {
+    new FairZ3Solver(ctx, pgm)
+  }
+
+  test("Tautology 1") { implicit fix =>
+    valid(BooleanLiteral(true))
+  }
+
+  test("Tautology 2") { implicit fix =>
+    val x = FreshIdentifier("x", IntegerType).toVariable
+    valid(Equals(Plus(x, x), Times(InfiniteIntegerLiteral(2), x)))
+  }
+
+  // This one contains a function invocation but is valid regardless of its
+  // interpretation, so should be proved anyway.
+  test("Tautology 3") { implicit fix =>
+    val pgm = fix._2
+    val fd = pgm.lookup("Minimal.f").collect {
+      case fd: FunDef => fd
+    }.get
+
+    def f(e: Expr) = FunctionInvocation(fd.typed, Seq(e))
+    val x = FreshIdentifier("x", IntegerType).toVariable
+    val y = FreshIdentifier("y", IntegerType).toVariable
+
+    valid(Implies(Not(Equals(f(x), f(y))), Not(Equals(x, y))))
+  }
+
+  test("Wrong 1") { implicit fix =>
+    invalid(BooleanLiteral(false))
+  }
+
+  test("Wrong 2") { implicit fix =>
+    val x = FreshIdentifier("x", IntegerType).toVariable
+    unsat(And(GreaterThan(x, InfiniteIntegerLiteral(0)), Equals(Plus(x, x), Times(InfiniteIntegerLiteral(3), x))))
+  }
+
+  test("Correct after unfolding") { implicit fix =>
+    val pgm = fix._2
+    val fd = pgm.lookup("Minimal.f").collect {
+      case fd: FunDef => fd
+    }.get
+
+    def f(e: Expr) = FunctionInvocation(fd.typed, Seq(e))
+    val x = FreshIdentifier("x", IntegerType).toVariable
+
+    valid(Equals(f(x), Plus(x, InfiniteIntegerLiteral(1))))
+  }
+}
diff --git a/src/integration/scala/leon/test/solvers/LeonSolverSuite.scala b/src/integration/scala/leon/test/solvers/LeonSolverSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..994232803347955255efc26f624b023e71e9786e
--- /dev/null
+++ b/src/integration/scala/leon/test/solvers/LeonSolverSuite.scala
@@ -0,0 +1,92 @@
+package leon.test.solvers
+
+import leon.test._
+import leon.purescala.Common._
+import leon.purescala.Definitions._
+import leon.purescala.Expressions._
+import leon.purescala.Types._
+import leon.LeonContext
+
+import leon.solvers._
+import leon.solvers.z3._
+
+trait LeonSolverSuite extends LeonTestSuiteWithProgram {
+  def getSolver(implicit ctx: LeonContext, pgm: Program): Solver
+
+  case class SolverDSL(res: Option[Boolean], solver: Solver) {
+    val resToString = res match {
+      case Some(true)  => "sat"
+      case Some(false) => "unsat"
+      case None        => "unknown"
+    }
+
+    def sat: Unit = {
+      if (res != Some(true)) {
+        fail(s"Expected 'sat', got '$resToString' from $solver")
+      }
+    }
+
+    def unsat: Unit = {
+      if (res != Some(false)) {
+        fail(s"Expected 'unsat', got '$resToString' from $solver")
+      }
+    }
+    def unknown: Unit = {
+      if (res != None) {
+        fail(s"Expected 'unknown', got '$resToString' from $solver")
+      }
+    }
+  }
+
+  def satToString(res: Option[Boolean]) = res match {
+    case Some(true)  => "sat"
+    case Some(false) => "unsat"
+    case None        => "unknown"
+  }
+
+  def validToString(res: Option[Boolean]) = res match {
+    case Some(true)  => "invalid"
+    case Some(false) => "valid"
+    case None        => "unknown"
+  }
+
+  def check(cnstr: Expr)(implicit ctx: LeonContext, pgm: Program): Option[Boolean] = {
+    val solver = getSolver
+
+    try {
+      solver.assertCnstr(cnstr)
+      solver.check
+    } finally {
+      solver.free()
+    }
+  }
+
+  def sat(cnstr: Expr)(implicit ctx: LeonContext, pgm: Program): Unit = {
+    val res = check(cnstr)
+    if (res != Some(true)) {
+      fail("Expected '"+satToString(Some(true))+"', got '"+satToString(res)+"'")
+    }
+  }
+
+  def unsat(cnstr: Expr)(implicit ctx: LeonContext, pgm: Program): Unit = {
+    val res = check(cnstr)
+    if (res != Some(false)) {
+      fail("Expected '"+satToString(Some(false))+"', got '"+satToString(res)+"'")
+    }
+  }
+
+  def valid(cnstr: Expr)(implicit ctx: LeonContext, pgm: Program): Unit = {
+    val res = check(Not(cnstr))
+    if (res != Some(false)) {
+      fail("Expected '"+validToString(Some(false))+"', got '"+validToString(res)+"'")
+    }
+  }
+
+  def invalid(cnstr: Expr)(implicit ctx: LeonContext, pgm: Program): Unit = {
+    val res = check(Not(cnstr))
+    if (res != Some(true)) {
+      fail("Expected '"+validToString(Some(true))+"', got '"+validToString(res)+"'")
+    }
+  }
+
+}
diff --git a/src/test/scala/leon/test/solvers/TimeoutSolverSuite.scala b/src/integration/scala/leon/test/solvers/TimeoutSolverSuite.scala
similarity index 81%
rename from src/test/scala/leon/test/solvers/TimeoutSolverSuite.scala
rename to src/integration/scala/leon/test/solvers/TimeoutSolverSuite.scala
index 6c7c8ab714577313aa3ded7119136b71eb6b280b..7f9fc9f35d8cfab41a47bf235b54299c917c5dfc 100644
--- a/src/test/scala/leon/test/solvers/TimeoutSolverSuite.scala
+++ b/src/integration/scala/leon/test/solvers/TimeoutSolverSuite.scala
@@ -20,7 +20,7 @@ class TimeoutSolverSuite extends LeonTestSuite {
 
     override def check: Option[Boolean] = {
       while(!interrupted) {
-        Thread.sleep(100)
+        Thread.sleep(50L)
       }
       None
     }
@@ -40,8 +40,8 @@ class TimeoutSolverSuite extends LeonTestSuite {
     def getModel = ???
   }
 
-  private def getTOSolver : SolverFactory[Solver] = {
-    SolverFactory(() => (new IdioticSolver(testContext, Program.empty) with TimeoutSolver).setTimeout(1000L))
+  private def getTOSolver(ctx: LeonContext): SolverFactory[Solver] = {
+    SolverFactory(() => (new IdioticSolver(ctx, Program.empty) with TimeoutSolver).setTimeout(200L))
   }
 
   private def check(sf: SolverFactory[Solver], e: Expr): Option[Boolean] = {
@@ -50,8 +50,8 @@ class TimeoutSolverSuite extends LeonTestSuite {
     s.check
   }
 
-  test("TimeoutSolver 1") {
-    val sf = getTOSolver
+  test("TimeoutSolver 1") { ctx =>
+    val sf = getTOSolver(ctx)
     assert(check(sf, BooleanLiteral(true)) === None)
     assert(check(sf, BooleanLiteral(false)) === None)
 
@@ -61,8 +61,8 @@ class TimeoutSolverSuite extends LeonTestSuite {
     sf.shutdown()
   }
 
-  test("TimeoutSolver 2") {
-    val sf = getTOSolver
+  test("TimeoutSolver 2") { ctx =>
+    val sf = getTOSolver(ctx)
     val x = Variable(FreshIdentifier("x", IntegerType))
     val o = InfiniteIntegerLiteral(1)
     assert(check(sf, Equals(Plus(x, o), Plus(o, x))) === None)
diff --git a/src/integration/scala/leon/test/solvers/UnrollingSolverSuite.scala b/src/integration/scala/leon/test/solvers/UnrollingSolverSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..c681dfd5e09e30a305ad3f685f28ad402f7b05b2
--- /dev/null
+++ b/src/integration/scala/leon/test/solvers/UnrollingSolverSuite.scala
@@ -0,0 +1,54 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.solvers
+
+import leon.test._
+import leon.LeonContext
+import leon.purescala.Expressions._
+import leon.purescala.Types._
+import leon.purescala.Common._
+import leon.purescala.Definitions._
+import leon.solvers._
+import leon.solvers.z3._
+import leon.solvers.combinators._
+
+class UnrollingSolverSuite extends LeonSolverSuite {
+
+  val sources = List(
+    """|import leon.lang._
+       |
+       |object Minimal {
+       |  def f(x: BigInt): BigInt = {
+       |    if (x > 0) {
+       |      x + f(x-1)
+       |    } else {
+       |      BigInt(1)
+       |    }
+       |  } ensuring { _ > 0 }
+       |}""".stripMargin
+  )
+
+  def getSolver(implicit ctx: LeonContext, pgm: Program) = {
+    new UnrollingSolver(ctx, pgm, new UninterpretedZ3Solver(ctx, pgm))
+  }
+
+  test("'true' should be valid") { implicit fix =>
+    valid(BooleanLiteral(true))
+  }
+
+  test("'false' should be invalid") { implicit fix =>
+    invalid(BooleanLiteral(false))
+  }
+
+  test("unrolling should enable recursive definition verification") { implicit fix =>
+    val pgm = fix._2
+    val fd = pgm.lookup("Minimal.f").collect {
+      case fd: FunDef => fd
+    }.get
+
+    def f(e: Expr) = FunctionInvocation(fd.typed, Seq(e))
+    val x = FreshIdentifier("x", IntegerType).toVariable
+
+    valid(GreaterThan(f(x), InfiniteIntegerLiteral(0)))
+  }
+}
diff --git a/src/main/scala/leon/codegen/CodeGeneration.scala b/src/main/scala/leon/codegen/CodeGeneration.scala
index 9812f47f801503871926b1ed66421428b65b43aa..a3bcb5d1478fbe922b5be02934659ff019dcf2b8 100644
--- a/src/main/scala/leon/codegen/CodeGeneration.scala
+++ b/src/main/scala/leon/codegen/CodeGeneration.scala
@@ -805,9 +805,14 @@ trait CodeGeneration {
           case ArrayType(other) => ch << NewArray(typeToJVM(other)); AASTORE
           case other => throw CompilationException(s"Cannot compile finite array expression whose type is $other.")
         }
-        for((i, e) <- elems) {
+
+        for (i <- 0 until l) {
+          val v = elems.get(i).orElse(default).getOrElse {
+            throw CompilationException(s"No valuation for key '$i' in array")
+          } 
+
           ch << DUP << Ldc(i)
-          mkExpr(e, ch) 
+          mkExpr(v, ch) 
           ch << storeInstr
         }
 
diff --git a/src/main/scala/leon/codegen/CompilationUnit.scala b/src/main/scala/leon/codegen/CompilationUnit.scala
index 0cbf5be52624e0fbb06ed84ddc651cf86e12a508..ce8dce09ab23a27e47976780a7d395375f42c1f6 100644
--- a/src/main/scala/leon/codegen/CompilationUnit.scala
+++ b/src/main/scala/leon/codegen/CompilationUnit.scala
@@ -257,6 +257,17 @@ class CompilationUnit(val ctx: LeonContext,
     case (_, UnitType) =>
       UnitLiteral()
 
+    case (ar: Array[_], ArrayType(base)) =>
+      if (ar.length == 0) {
+        EmptyArray(base)
+      } else {
+        val elems = for ((e: AnyRef, i) <- ar.zipWithIndex) yield {
+          i -> jvmToExpr(e, base)
+        }
+
+        NonemptyArray(elems.toMap, None)
+      }
+
     case _ =>
       throw CompilationException("Unsupported return value : " + e.getClass +" while expecting "+tpe)
   }
diff --git a/src/main/scala/leon/utils/TemporaryInputPhase.scala b/src/main/scala/leon/utils/TemporaryInputPhase.scala
index ed43399ada7e02fce4488a26a0a4b2db6d6913fe..ba561a9504ebcaff583eb3ffd36c18df8b01d714 100644
--- a/src/main/scala/leon/utils/TemporaryInputPhase.scala
+++ b/src/main/scala/leon/utils/TemporaryInputPhase.scala
@@ -5,21 +5,24 @@ package utils
 
 import java.io.{File, BufferedWriter, FileWriter}
 
-object TemporaryInputPhase extends LeonPhase[(String, List[String]), List[String]] {
+object TemporaryInputPhase extends LeonPhase[(List[String], List[String]), List[String]] {
 
   val name = "Temporary Input"
   val description = "Create source files from string content"
 
-  def run(ctx: LeonContext)(data: (String, List[String])): List[String] = {
-    val (content, opts) = data
+  def run(ctx: LeonContext)(data: (List[String], List[String])): List[String] = {
+    val (contents, opts) = data
 
-    val file : File = File.createTempFile("leon", ".scala")
-    file.deleteOnExit()
-    val out = new BufferedWriter(new FileWriter(file))
-    out.write(content)
-    out.close()
+    val files = contents.map { content =>
+      val file : File = File.createTempFile("leon", ".scala")
+      file.deleteOnExit()
+      val out = new BufferedWriter(new FileWriter(file))
+      out.write(content)
+      out.close()
+      file.getAbsolutePath
+    }
 
 
-    file.getAbsolutePath :: opts
+    files ::: opts
   }
 }
diff --git a/src/test/resources/regression/frontends/error/simple/Asserts.scala b/src/regression/resources/regression/frontends/error/simple/Asserts.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/simple/Asserts.scala
rename to src/regression/resources/regression/frontends/error/simple/Asserts.scala
diff --git a/src/test/resources/regression/frontends/error/simple/ConvertBigInt.scala b/src/regression/resources/regression/frontends/error/simple/ConvertBigInt.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/simple/ConvertBigInt.scala
rename to src/regression/resources/regression/frontends/error/simple/ConvertBigInt.scala
diff --git a/src/test/resources/regression/frontends/error/simple/InstanceOf1.scala b/src/regression/resources/regression/frontends/error/simple/InstanceOf1.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/simple/InstanceOf1.scala
rename to src/regression/resources/regression/frontends/error/simple/InstanceOf1.scala
diff --git a/src/test/resources/regression/frontends/error/simple/LiteralBigInt.scala b/src/regression/resources/regression/frontends/error/simple/LiteralBigInt.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/simple/LiteralBigInt.scala
rename to src/regression/resources/regression/frontends/error/simple/LiteralBigInt.scala
diff --git a/src/test/resources/regression/frontends/error/simple/NotEquals.scala b/src/regression/resources/regression/frontends/error/simple/NotEquals.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/simple/NotEquals.scala
rename to src/regression/resources/regression/frontends/error/simple/NotEquals.scala
diff --git a/src/test/resources/regression/frontends/error/xlang/Array1.scala b/src/regression/resources/regression/frontends/error/xlang/Array1.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/xlang/Array1.scala
rename to src/regression/resources/regression/frontends/error/xlang/Array1.scala
diff --git a/src/test/resources/regression/frontends/error/xlang/Array10.scala b/src/regression/resources/regression/frontends/error/xlang/Array10.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/xlang/Array10.scala
rename to src/regression/resources/regression/frontends/error/xlang/Array10.scala
diff --git a/src/test/resources/regression/frontends/error/xlang/Array2.scala b/src/regression/resources/regression/frontends/error/xlang/Array2.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/xlang/Array2.scala
rename to src/regression/resources/regression/frontends/error/xlang/Array2.scala
diff --git a/src/test/resources/regression/frontends/error/xlang/Array3.scala b/src/regression/resources/regression/frontends/error/xlang/Array3.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/xlang/Array3.scala
rename to src/regression/resources/regression/frontends/error/xlang/Array3.scala
diff --git a/src/test/resources/regression/frontends/error/xlang/Array4.scala b/src/regression/resources/regression/frontends/error/xlang/Array4.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/xlang/Array4.scala
rename to src/regression/resources/regression/frontends/error/xlang/Array4.scala
diff --git a/src/test/resources/regression/frontends/error/xlang/Array5.scala b/src/regression/resources/regression/frontends/error/xlang/Array5.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/xlang/Array5.scala
rename to src/regression/resources/regression/frontends/error/xlang/Array5.scala
diff --git a/src/test/resources/regression/frontends/error/xlang/Array6.scala b/src/regression/resources/regression/frontends/error/xlang/Array6.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/xlang/Array6.scala
rename to src/regression/resources/regression/frontends/error/xlang/Array6.scala
diff --git a/src/test/resources/regression/frontends/error/xlang/Array7.scala b/src/regression/resources/regression/frontends/error/xlang/Array7.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/xlang/Array7.scala
rename to src/regression/resources/regression/frontends/error/xlang/Array7.scala
diff --git a/src/test/resources/regression/frontends/error/xlang/Array8.scala b/src/regression/resources/regression/frontends/error/xlang/Array8.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/xlang/Array8.scala
rename to src/regression/resources/regression/frontends/error/xlang/Array8.scala
diff --git a/src/test/resources/regression/frontends/error/xlang/Array9.scala b/src/regression/resources/regression/frontends/error/xlang/Array9.scala
similarity index 100%
rename from src/test/resources/regression/frontends/error/xlang/Array9.scala
rename to src/regression/resources/regression/frontends/error/xlang/Array9.scala
diff --git a/src/test/resources/regression/frontends/passing/ClassFields.scala b/src/regression/resources/regression/frontends/passing/ClassFields.scala
similarity index 100%
rename from src/test/resources/regression/frontends/passing/ClassFields.scala
rename to src/regression/resources/regression/frontends/passing/ClassFields.scala
diff --git a/src/test/resources/regression/frontends/passing/Fields.scala b/src/regression/resources/regression/frontends/passing/Fields.scala
similarity index 100%
rename from src/test/resources/regression/frontends/passing/Fields.scala
rename to src/regression/resources/regression/frontends/passing/Fields.scala
diff --git a/src/test/resources/regression/frontends/passing/ImplicitDefs.scala b/src/regression/resources/regression/frontends/passing/ImplicitDefs.scala
similarity index 100%
rename from src/test/resources/regression/frontends/passing/ImplicitDefs.scala
rename to src/regression/resources/regression/frontends/passing/ImplicitDefs.scala
diff --git a/src/test/resources/regression/frontends/passing/ImplicitDefs2.scala b/src/regression/resources/regression/frontends/passing/ImplicitDefs2.scala
similarity index 100%
rename from src/test/resources/regression/frontends/passing/ImplicitDefs2.scala
rename to src/regression/resources/regression/frontends/passing/ImplicitDefs2.scala
diff --git a/src/test/resources/regression/frontends/passing/Operators.scala b/src/regression/resources/regression/frontends/passing/Operators.scala
similarity index 100%
rename from src/test/resources/regression/frontends/passing/Operators.scala
rename to src/regression/resources/regression/frontends/passing/Operators.scala
diff --git a/src/test/resources/regression/frontends/passing/OptParams.scala b/src/regression/resources/regression/frontends/passing/OptParams.scala
similarity index 100%
rename from src/test/resources/regression/frontends/passing/OptParams.scala
rename to src/regression/resources/regression/frontends/passing/OptParams.scala
diff --git a/src/test/resources/regression/frontends/passing/Overrides.scala b/src/regression/resources/regression/frontends/passing/Overrides.scala
similarity index 100%
rename from src/test/resources/regression/frontends/passing/Overrides.scala
rename to src/regression/resources/regression/frontends/passing/Overrides.scala
diff --git a/src/test/resources/regression/frontends/passing/bigintExtr.scala b/src/regression/resources/regression/frontends/passing/bigintExtr.scala
similarity index 100%
rename from src/test/resources/regression/frontends/passing/bigintExtr.scala
rename to src/regression/resources/regression/frontends/passing/bigintExtr.scala
diff --git a/src/test/resources/regression/performance/cegis/Add.scala b/src/regression/resources/regression/performance/cegis/Add.scala
similarity index 100%
rename from src/test/resources/regression/performance/cegis/Add.scala
rename to src/regression/resources/regression/performance/cegis/Add.scala
diff --git a/src/test/resources/regression/performance/cegis/Distinct.scala b/src/regression/resources/regression/performance/cegis/Distinct.scala
similarity index 100%
rename from src/test/resources/regression/performance/cegis/Distinct.scala
rename to src/regression/resources/regression/performance/cegis/Distinct.scala
diff --git a/src/test/resources/regression/performance/cegis/Hole1.scala b/src/regression/resources/regression/performance/cegis/Hole1.scala
similarity index 100%
rename from src/test/resources/regression/performance/cegis/Hole1.scala
rename to src/regression/resources/regression/performance/cegis/Hole1.scala
diff --git a/src/test/resources/regression/performance/cegis/Length.scala b/src/regression/resources/regression/performance/cegis/Length.scala
similarity index 100%
rename from src/test/resources/regression/performance/cegis/Length.scala
rename to src/regression/resources/regression/performance/cegis/Length.scala
diff --git a/src/test/resources/regression/performance/cegis/Mult.scala b/src/regression/resources/regression/performance/cegis/Mult.scala
similarity index 100%
rename from src/test/resources/regression/performance/cegis/Mult.scala
rename to src/regression/resources/regression/performance/cegis/Mult.scala
diff --git a/src/test/resources/regression/performance/cegis/Squared.scala b/src/regression/resources/regression/performance/cegis/Squared.scala
similarity index 100%
rename from src/test/resources/regression/performance/cegis/Squared.scala
rename to src/regression/resources/regression/performance/cegis/Squared.scala
diff --git a/src/test/resources/regression/repair/Compiler1.scala b/src/regression/resources/regression/repair/Compiler1.scala
similarity index 100%
rename from src/test/resources/regression/repair/Compiler1.scala
rename to src/regression/resources/regression/repair/Compiler1.scala
diff --git a/src/test/resources/regression/repair/Heap4.scala b/src/regression/resources/regression/repair/Heap4.scala
similarity index 100%
rename from src/test/resources/regression/repair/Heap4.scala
rename to src/regression/resources/regression/repair/Heap4.scala
diff --git a/src/test/resources/regression/repair/List1.scala b/src/regression/resources/regression/repair/List1.scala
similarity index 100%
rename from src/test/resources/regression/repair/List1.scala
rename to src/regression/resources/regression/repair/List1.scala
diff --git a/src/test/resources/regression/repair/MergeSort2.scala b/src/regression/resources/regression/repair/MergeSort2.scala
similarity index 100%
rename from src/test/resources/regression/repair/MergeSort2.scala
rename to src/regression/resources/regression/repair/MergeSort2.scala
diff --git a/src/test/resources/regression/synthesis/Church/Add.scala b/src/regression/resources/regression/synthesis/Church/Add.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/Church/Add.scala
rename to src/regression/resources/regression/synthesis/Church/Add.scala
diff --git a/src/test/resources/regression/synthesis/Church/Distinct.scala b/src/regression/resources/regression/synthesis/Church/Distinct.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/Church/Distinct.scala
rename to src/regression/resources/regression/synthesis/Church/Distinct.scala
diff --git a/src/test/resources/regression/synthesis/Church/Mult.scala b/src/regression/resources/regression/synthesis/Church/Mult.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/Church/Mult.scala
rename to src/regression/resources/regression/synthesis/Church/Mult.scala
diff --git a/src/test/resources/regression/synthesis/Church/Squared.scala b/src/regression/resources/regression/synthesis/Church/Squared.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/Church/Squared.scala
rename to src/regression/resources/regression/synthesis/Church/Squared.scala
diff --git a/src/test/resources/regression/synthesis/Examples/Length.scala b/src/regression/resources/regression/synthesis/Examples/Length.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/Examples/Length.scala
rename to src/regression/resources/regression/synthesis/Examples/Length.scala
diff --git a/src/test/resources/regression/synthesis/Holes/Hole1.scala b/src/regression/resources/regression/synthesis/Holes/Hole1.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/Holes/Hole1.scala
rename to src/regression/resources/regression/synthesis/Holes/Hole1.scala
diff --git a/src/test/resources/regression/synthesis/List/Delete.scala b/src/regression/resources/regression/synthesis/List/Delete.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/List/Delete.scala
rename to src/regression/resources/regression/synthesis/List/Delete.scala
diff --git a/src/test/resources/regression/synthesis/List/Diff.scala b/src/regression/resources/regression/synthesis/List/Diff.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/List/Diff.scala
rename to src/regression/resources/regression/synthesis/List/Diff.scala
diff --git a/src/test/resources/regression/synthesis/List/Insert.scala b/src/regression/resources/regression/synthesis/List/Insert.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/List/Insert.scala
rename to src/regression/resources/regression/synthesis/List/Insert.scala
diff --git a/src/test/resources/regression/synthesis/List/Split1.scala b/src/regression/resources/regression/synthesis/List/Split1.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/List/Split1.scala
rename to src/regression/resources/regression/synthesis/List/Split1.scala
diff --git a/src/test/resources/regression/synthesis/List/Split2.scala b/src/regression/resources/regression/synthesis/List/Split2.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/List/Split2.scala
rename to src/regression/resources/regression/synthesis/List/Split2.scala
diff --git a/src/test/resources/regression/synthesis/List/Split3.scala b/src/regression/resources/regression/synthesis/List/Split3.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/List/Split3.scala
rename to src/regression/resources/regression/synthesis/List/Split3.scala
diff --git a/src/test/resources/regression/synthesis/List/Union.scala b/src/regression/resources/regression/synthesis/List/Union.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/List/Union.scala
rename to src/regression/resources/regression/synthesis/List/Union.scala
diff --git a/src/test/resources/regression/synthesis/Misc/HolesBug.scala b/src/regression/resources/regression/synthesis/Misc/HolesBug.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/Misc/HolesBug.scala
rename to src/regression/resources/regression/synthesis/Misc/HolesBug.scala
diff --git a/src/test/resources/regression/synthesis/SortedList/Delete.scala b/src/regression/resources/regression/synthesis/SortedList/Delete.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/SortedList/Delete.scala
rename to src/regression/resources/regression/synthesis/SortedList/Delete.scala
diff --git a/src/test/resources/regression/synthesis/SortedList/Diff.scala b/src/regression/resources/regression/synthesis/SortedList/Diff.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/SortedList/Diff.scala
rename to src/regression/resources/regression/synthesis/SortedList/Diff.scala
diff --git a/src/test/resources/regression/synthesis/SortedList/Insert1.scala b/src/regression/resources/regression/synthesis/SortedList/Insert1.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/SortedList/Insert1.scala
rename to src/regression/resources/regression/synthesis/SortedList/Insert1.scala
diff --git a/src/test/resources/regression/synthesis/SortedList/Insert2.scala b/src/regression/resources/regression/synthesis/SortedList/Insert2.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/SortedList/Insert2.scala
rename to src/regression/resources/regression/synthesis/SortedList/Insert2.scala
diff --git a/src/test/resources/regression/synthesis/SortedList/InsertSort.scala b/src/regression/resources/regression/synthesis/SortedList/InsertSort.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/SortedList/InsertSort.scala
rename to src/regression/resources/regression/synthesis/SortedList/InsertSort.scala
diff --git a/src/test/resources/regression/synthesis/SortedList/Union.scala b/src/regression/resources/regression/synthesis/SortedList/Union.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/SortedList/Union.scala
rename to src/regression/resources/regression/synthesis/SortedList/Union.scala
diff --git a/src/test/resources/regression/synthesis/StrictSortedList/Delete.scala b/src/regression/resources/regression/synthesis/StrictSortedList/Delete.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/StrictSortedList/Delete.scala
rename to src/regression/resources/regression/synthesis/StrictSortedList/Delete.scala
diff --git a/src/test/resources/regression/synthesis/StrictSortedList/Insert.scala b/src/regression/resources/regression/synthesis/StrictSortedList/Insert.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/StrictSortedList/Insert.scala
rename to src/regression/resources/regression/synthesis/StrictSortedList/Insert.scala
diff --git a/src/test/resources/regression/synthesis/StrictSortedList/Union.scala b/src/regression/resources/regression/synthesis/StrictSortedList/Union.scala
similarity index 100%
rename from src/test/resources/regression/synthesis/StrictSortedList/Union.scala
rename to src/regression/resources/regression/synthesis/StrictSortedList/Union.scala
diff --git a/src/test/resources/regression/termination/looping/LambdaCalculus.scala b/src/regression/resources/regression/termination/looping/LambdaCalculus.scala
similarity index 100%
rename from src/test/resources/regression/termination/looping/LambdaCalculus.scala
rename to src/regression/resources/regression/termination/looping/LambdaCalculus.scala
diff --git a/src/test/resources/regression/termination/looping/Numeric1.scala b/src/regression/resources/regression/termination/looping/Numeric1.scala
similarity index 100%
rename from src/test/resources/regression/termination/looping/Numeric1.scala
rename to src/regression/resources/regression/termination/looping/Numeric1.scala
diff --git a/src/test/resources/regression/termination/looping/Numeric2.scala b/src/regression/resources/regression/termination/looping/Numeric2.scala
similarity index 100%
rename from src/test/resources/regression/termination/looping/Numeric2.scala
rename to src/regression/resources/regression/termination/looping/Numeric2.scala
diff --git a/src/test/resources/regression/termination/looping/Numeric3.scala b/src/regression/resources/regression/termination/looping/Numeric3.scala
similarity index 100%
rename from src/test/resources/regression/termination/looping/Numeric3.scala
rename to src/regression/resources/regression/termination/looping/Numeric3.scala
diff --git a/src/test/resources/regression/termination/looping/OddEven.scala b/src/regression/resources/regression/termination/looping/OddEven.scala
similarity index 100%
rename from src/test/resources/regression/termination/looping/OddEven.scala
rename to src/regression/resources/regression/termination/looping/OddEven.scala
diff --git a/src/test/resources/regression/termination/looping/Queue.scala b/src/regression/resources/regression/termination/looping/Queue.scala
similarity index 100%
rename from src/test/resources/regression/termination/looping/Queue.scala
rename to src/regression/resources/regression/termination/looping/Queue.scala
diff --git a/src/test/resources/regression/termination/looping/Termination_failling1.scala b/src/regression/resources/regression/termination/looping/Termination_failling1.scala
similarity index 100%
rename from src/test/resources/regression/termination/looping/Termination_failling1.scala
rename to src/regression/resources/regression/termination/looping/Termination_failling1.scala
diff --git a/src/test/resources/regression/termination/looping/UniversalEquality.scala b/src/regression/resources/regression/termination/looping/UniversalEquality.scala
similarity index 100%
rename from src/test/resources/regression/termination/looping/UniversalEquality.scala
rename to src/regression/resources/regression/termination/looping/UniversalEquality.scala
diff --git a/src/test/resources/regression/termination/looping/WrongFibonacci.scala b/src/regression/resources/regression/termination/looping/WrongFibonacci.scala
similarity index 100%
rename from src/test/resources/regression/termination/looping/WrongFibonacci.scala
rename to src/regression/resources/regression/termination/looping/WrongFibonacci.scala
diff --git a/src/test/resources/regression/termination/valid/BinaryTreeImp.scala b/src/regression/resources/regression/termination/valid/BinaryTreeImp.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/BinaryTreeImp.scala
rename to src/regression/resources/regression/termination/valid/BinaryTreeImp.scala
diff --git a/src/test/resources/regression/termination/valid/CountTowardsZero.scala b/src/regression/resources/regression/termination/valid/CountTowardsZero.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/CountTowardsZero.scala
rename to src/regression/resources/regression/termination/valid/CountTowardsZero.scala
diff --git a/src/test/resources/regression/termination/valid/Fibonacci.scala b/src/regression/resources/regression/termination/valid/Fibonacci.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/Fibonacci.scala
rename to src/regression/resources/regression/termination/valid/Fibonacci.scala
diff --git a/src/test/resources/regression/termination/valid/HOTermination.scala b/src/regression/resources/regression/termination/valid/HOTermination.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/HOTermination.scala
rename to src/regression/resources/regression/termination/valid/HOTermination.scala
diff --git a/src/test/resources/regression/termination/valid/ListWithSize.scala b/src/regression/resources/regression/termination/valid/ListWithSize.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/ListWithSize.scala
rename to src/regression/resources/regression/termination/valid/ListWithSize.scala
diff --git a/src/test/resources/regression/termination/valid/Numeric1.scala b/src/regression/resources/regression/termination/valid/Numeric1.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/Numeric1.scala
rename to src/regression/resources/regression/termination/valid/Numeric1.scala
diff --git a/src/test/resources/regression/termination/valid/Queue.scala b/src/regression/resources/regression/termination/valid/Queue.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/Queue.scala
rename to src/regression/resources/regression/termination/valid/Queue.scala
diff --git a/src/test/resources/regression/termination/valid/QuickSort.scala b/src/regression/resources/regression/termination/valid/QuickSort.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/QuickSort.scala
rename to src/regression/resources/regression/termination/valid/QuickSort.scala
diff --git a/src/test/resources/regression/termination/valid/RedBlackTree.scala b/src/regression/resources/regression/termination/valid/RedBlackTree.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/RedBlackTree.scala
rename to src/regression/resources/regression/termination/valid/RedBlackTree.scala
diff --git a/src/test/resources/regression/termination/valid/SimpInterpret.scala b/src/regression/resources/regression/termination/valid/SimpInterpret.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/SimpInterpret.scala
rename to src/regression/resources/regression/termination/valid/SimpInterpret.scala
diff --git a/src/test/resources/regression/termination/valid/Termination_passing1.scala b/src/regression/resources/regression/termination/valid/Termination_passing1.scala
similarity index 100%
rename from src/test/resources/regression/termination/valid/Termination_passing1.scala
rename to src/regression/resources/regression/termination/valid/Termination_passing1.scala
diff --git a/src/test/resources/regression/testcases b/src/regression/resources/regression/testcases
similarity index 100%
rename from src/test/resources/regression/testcases
rename to src/regression/resources/regression/testcases
diff --git a/src/test/resources/regression/transformations/SimplifyLets.scala b/src/regression/resources/regression/transformations/SimplifyLets.scala
similarity index 100%
rename from src/test/resources/regression/transformations/SimplifyLets.scala
rename to src/regression/resources/regression/transformations/SimplifyLets.scala
diff --git a/src/test/resources/regression/transformations/SimplifyPaths.scala b/src/regression/resources/regression/transformations/SimplifyPaths.scala
similarity index 100%
rename from src/test/resources/regression/transformations/SimplifyPaths.scala
rename to src/regression/resources/regression/transformations/SimplifyPaths.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/Acc.scala b/src/regression/resources/regression/verification/newsolvers/invalid/Acc.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/Acc.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/Acc.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/AddingNegativeNumbers.scala b/src/regression/resources/regression/verification/newsolvers/invalid/AddingNegativeNumbers.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/AddingNegativeNumbers.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/AddingNegativeNumbers.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/AddingPositiveNumbers.scala b/src/regression/resources/regression/verification/newsolvers/invalid/AddingPositiveNumbers.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/AddingPositiveNumbers.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/AddingPositiveNumbers.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/Array1.scala b/src/regression/resources/regression/verification/newsolvers/invalid/Array1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/Array1.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/Array1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/Array2.scala b/src/regression/resources/regression/verification/newsolvers/invalid/Array2.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/Array2.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/Array2.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/Array3.scala b/src/regression/resources/regression/verification/newsolvers/invalid/Array3.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/Array3.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/Array3.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/Array4.scala b/src/regression/resources/regression/verification/newsolvers/invalid/Array4.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/Array4.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/Array4.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/Asserts1.scala b/src/regression/resources/regression/verification/newsolvers/invalid/Asserts1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/Asserts1.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/Asserts1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/BVDivision.scala b/src/regression/resources/regression/verification/newsolvers/invalid/BVDivision.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/BVDivision.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/BVDivision.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/BVDivision2.scala b/src/regression/resources/regression/verification/newsolvers/invalid/BVDivision2.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/BVDivision2.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/BVDivision2.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/BigArray.scala b/src/regression/resources/regression/verification/newsolvers/invalid/BigArray.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/BigArray.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/BigArray.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/Division.scala b/src/regression/resources/regression/verification/newsolvers/invalid/Division.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/Division.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/Division.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/EnsuringBoolean.scala b/src/regression/resources/regression/verification/newsolvers/invalid/EnsuringBoolean.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/EnsuringBoolean.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/EnsuringBoolean.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/FiniteSort.scala b/src/regression/resources/regression/verification/newsolvers/invalid/FiniteSort.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/FiniteSort.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/FiniteSort.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/Generics.scala b/src/regression/resources/regression/verification/newsolvers/invalid/Generics.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/Generics.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/Generics.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/Generics2.scala b/src/regression/resources/regression/verification/newsolvers/invalid/Generics2.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/Generics2.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/Generics2.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/InsertionSort.scala b/src/regression/resources/regression/verification/newsolvers/invalid/InsertionSort.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/InsertionSort.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/InsertionSort.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/ListOperations.scala b/src/regression/resources/regression/verification/newsolvers/invalid/ListOperations.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/ListOperations.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/ListOperations.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/MyTuple1.scala b/src/regression/resources/regression/verification/newsolvers/invalid/MyTuple1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/MyTuple1.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/MyTuple1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/MyTuple2.scala b/src/regression/resources/regression/verification/newsolvers/invalid/MyTuple2.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/MyTuple2.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/MyTuple2.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/MyTuple3.scala b/src/regression/resources/regression/verification/newsolvers/invalid/MyTuple3.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/MyTuple3.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/MyTuple3.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/PositiveMap.scala b/src/regression/resources/regression/verification/newsolvers/invalid/PositiveMap.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/PositiveMap.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/PositiveMap.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/PropositionalLogic.scala b/src/regression/resources/regression/verification/newsolvers/invalid/PropositionalLogic.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/PropositionalLogic.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/PropositionalLogic.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/README b/src/regression/resources/regression/verification/newsolvers/invalid/README
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/README
rename to src/regression/resources/regression/verification/newsolvers/invalid/README
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/RedBlackTree.scala b/src/regression/resources/regression/verification/newsolvers/invalid/RedBlackTree.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/RedBlackTree.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/RedBlackTree.scala
diff --git a/src/test/resources/regression/verification/newsolvers/invalid/Unit1.scala b/src/regression/resources/regression/verification/newsolvers/invalid/Unit1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/invalid/Unit1.scala
rename to src/regression/resources/regression/verification/newsolvers/invalid/Unit1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Acc.scala b/src/regression/resources/regression/verification/newsolvers/valid/Acc.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Acc.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Acc.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/AddingPositiveNumbers.scala b/src/regression/resources/regression/verification/newsolvers/valid/AddingPositiveNumbers.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/AddingPositiveNumbers.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/AddingPositiveNumbers.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/AmortizedQueue.scala b/src/regression/resources/regression/verification/newsolvers/valid/AmortizedQueue.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/AmortizedQueue.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/AmortizedQueue.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/ArrayLiterals.scala b/src/regression/resources/regression/verification/newsolvers/valid/ArrayLiterals.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/ArrayLiterals.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/ArrayLiterals.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/ArrayUpdated.scala b/src/regression/resources/regression/verification/newsolvers/valid/ArrayUpdated.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/ArrayUpdated.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/ArrayUpdated.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Asserts1.scala b/src/regression/resources/regression/verification/newsolvers/valid/Asserts1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Asserts1.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Asserts1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/AssociativeList.scala b/src/regression/resources/regression/verification/newsolvers/valid/AssociativeList.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/AssociativeList.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/AssociativeList.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/BestRealTypes.scala b/src/regression/resources/regression/verification/newsolvers/valid/BestRealTypes.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/BestRealTypes.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/BestRealTypes.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/BitsTricks.scala b/src/regression/resources/regression/verification/newsolvers/valid/BitsTricks.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/BitsTricks.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/BitsTricks.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/CaseObject1.scala b/src/regression/resources/regression/verification/newsolvers/valid/CaseObject1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/CaseObject1.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/CaseObject1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Field1.scala b/src/regression/resources/regression/verification/newsolvers/valid/Field1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Field1.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Field1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Field2.scala b/src/regression/resources/regression/verification/newsolvers/valid/Field2.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Field2.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Field2.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/FiniteSort.scala b/src/regression/resources/regression/verification/newsolvers/valid/FiniteSort.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/FiniteSort.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/FiniteSort.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/FoolProofAdder.scala b/src/regression/resources/regression/verification/newsolvers/valid/FoolProofAdder.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/FoolProofAdder.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/FoolProofAdder.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Generics.scala b/src/regression/resources/regression/verification/newsolvers/valid/Generics.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Generics.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Generics.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Generics1.scala b/src/regression/resources/regression/verification/newsolvers/valid/Generics1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Generics1.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Generics1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Heaps.scala b/src/regression/resources/regression/verification/newsolvers/valid/Heaps.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Heaps.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Heaps.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/InsertionSort.scala b/src/regression/resources/regression/verification/newsolvers/valid/InsertionSort.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/InsertionSort.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/InsertionSort.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/InstanceOf1.scala b/src/regression/resources/regression/verification/newsolvers/valid/InstanceOf1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/InstanceOf1.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/InstanceOf1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/ListOperations.scala b/src/regression/resources/regression/verification/newsolvers/valid/ListOperations.scala
similarity index 99%
rename from src/test/resources/regression/verification/newsolvers/valid/ListOperations.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/ListOperations.scala
index 4a2b54d6e98799df22921fc11ca811e95dd9f8cb..5b162a58b3d2b5d600e2cb8321d17b538bceef82 100644
--- a/src/test/resources/regression/verification/newsolvers/valid/ListOperations.scala
+++ b/src/regression/resources/regression/verification/newsolvers/valid/ListOperations.scala
@@ -47,7 +47,7 @@ object ListOperations {
   }.holds
   
   def drunk[A](l : List[A]) : List[A] = (l match {
-    case Nil() => Nil()
+    case Nil() => Nil[A]()
     case Cons(x,l1) => Cons(x,Cons(x,drunk(l1)))
   }) ensuring (size(_) == 2 * size(l))
 
diff --git a/src/test/resources/regression/verification/newsolvers/valid/LiteralMaps.scala b/src/regression/resources/regression/verification/newsolvers/valid/LiteralMaps.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/LiteralMaps.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/LiteralMaps.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/MergeSort.scala b/src/regression/resources/regression/verification/newsolvers/valid/MergeSort.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/MergeSort.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/MergeSort.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/MyMap.scala b/src/regression/resources/regression/verification/newsolvers/valid/MyMap.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/MyMap.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/MyMap.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/MySet.scala b/src/regression/resources/regression/verification/newsolvers/valid/MySet.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/MySet.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/MySet.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/MyTuple1.scala b/src/regression/resources/regression/verification/newsolvers/valid/MyTuple1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/MyTuple1.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/MyTuple1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/MyTuple2.scala b/src/regression/resources/regression/verification/newsolvers/valid/MyTuple2.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/MyTuple2.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/MyTuple2.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/MyTuple3.scala b/src/regression/resources/regression/verification/newsolvers/valid/MyTuple3.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/MyTuple3.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/MyTuple3.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/MyTuple4.scala b/src/regression/resources/regression/verification/newsolvers/valid/MyTuple4.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/MyTuple4.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/MyTuple4.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/MyTuple5.scala b/src/regression/resources/regression/verification/newsolvers/valid/MyTuple5.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/MyTuple5.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/MyTuple5.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/MyTuple6.scala b/src/regression/resources/regression/verification/newsolvers/valid/MyTuple6.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/MyTuple6.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/MyTuple6.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Nat.scala b/src/regression/resources/regression/verification/newsolvers/valid/Nat.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Nat.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Nat.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/NotEquals.scala b/src/regression/resources/regression/verification/newsolvers/valid/NotEquals.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/NotEquals.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/NotEquals.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/PositiveMap.scala b/src/regression/resources/regression/verification/newsolvers/valid/PositiveMap.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/PositiveMap.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/PositiveMap.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/PropositionalLogic.scala b/src/regression/resources/regression/verification/newsolvers/valid/PropositionalLogic.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/PropositionalLogic.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/PropositionalLogic.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/README b/src/regression/resources/regression/verification/newsolvers/valid/README
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/README
rename to src/regression/resources/regression/verification/newsolvers/valid/README
diff --git a/src/test/resources/regression/verification/newsolvers/valid/RedBlackTree.scala b/src/regression/resources/regression/verification/newsolvers/valid/RedBlackTree.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/RedBlackTree.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/RedBlackTree.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/SearchLinkedList.scala b/src/regression/resources/regression/verification/newsolvers/valid/SearchLinkedList.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/SearchLinkedList.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/SearchLinkedList.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Subtyping1.scala b/src/regression/resources/regression/verification/newsolvers/valid/Subtyping1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Subtyping1.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Subtyping1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Subtyping2.scala b/src/regression/resources/regression/verification/newsolvers/valid/Subtyping2.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Subtyping2.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Subtyping2.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Unit1.scala b/src/regression/resources/regression/verification/newsolvers/valid/Unit1.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Unit1.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Unit1.scala
diff --git a/src/test/resources/regression/verification/newsolvers/valid/Unit2.scala b/src/regression/resources/regression/verification/newsolvers/valid/Unit2.scala
similarity index 100%
rename from src/test/resources/regression/verification/newsolvers/valid/Unit2.scala
rename to src/regression/resources/regression/verification/newsolvers/valid/Unit2.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Acc.scala b/src/regression/resources/regression/verification/purescala/invalid/Acc.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Acc.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Acc.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/AddingNegativeNumbers.scala b/src/regression/resources/regression/verification/purescala/invalid/AddingNegativeNumbers.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/AddingNegativeNumbers.scala
rename to src/regression/resources/regression/verification/purescala/invalid/AddingNegativeNumbers.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/AddingPositiveNumbers.scala b/src/regression/resources/regression/verification/purescala/invalid/AddingPositiveNumbers.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/AddingPositiveNumbers.scala
rename to src/regression/resources/regression/verification/purescala/invalid/AddingPositiveNumbers.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Array1.scala b/src/regression/resources/regression/verification/purescala/invalid/Array1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Array1.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Array1.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Array2.scala b/src/regression/resources/regression/verification/purescala/invalid/Array2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Array2.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Array2.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Array3.scala b/src/regression/resources/regression/verification/purescala/invalid/Array3.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Array3.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Array3.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Array4.scala b/src/regression/resources/regression/verification/purescala/invalid/Array4.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Array4.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Array4.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Asserts1.scala b/src/regression/resources/regression/verification/purescala/invalid/Asserts1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Asserts1.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Asserts1.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/BVDivision2.scala b/src/regression/resources/regression/verification/purescala/invalid/BVDivision2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/BVDivision2.scala
rename to src/regression/resources/regression/verification/purescala/invalid/BVDivision2.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/BVDivisionByZero.scala b/src/regression/resources/regression/verification/purescala/invalid/BVDivisionByZero.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/BVDivisionByZero.scala
rename to src/regression/resources/regression/verification/purescala/invalid/BVDivisionByZero.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/BVRemainderByZero.scala b/src/regression/resources/regression/verification/purescala/invalid/BVRemainderByZero.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/BVRemainderByZero.scala
rename to src/regression/resources/regression/verification/purescala/invalid/BVRemainderByZero.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/BigArray.scala b/src/regression/resources/regression/verification/purescala/invalid/BigArray.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/BigArray.scala
rename to src/regression/resources/regression/verification/purescala/invalid/BigArray.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/BraunTree.scala b/src/regression/resources/regression/verification/purescala/invalid/BraunTree.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/BraunTree.scala
rename to src/regression/resources/regression/verification/purescala/invalid/BraunTree.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/CharCompare.scala b/src/regression/resources/regression/verification/purescala/invalid/CharCompare.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/CharCompare.scala
rename to src/regression/resources/regression/verification/purescala/invalid/CharCompare.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Choose1.scala b/src/regression/resources/regression/verification/purescala/invalid/Choose1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Choose1.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Choose1.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/DivisionByZero.scala b/src/regression/resources/regression/verification/purescala/invalid/DivisionByZero.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/DivisionByZero.scala
rename to src/regression/resources/regression/verification/purescala/invalid/DivisionByZero.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/EnsuringBoolean.scala b/src/regression/resources/regression/verification/purescala/invalid/EnsuringBoolean.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/EnsuringBoolean.scala
rename to src/regression/resources/regression/verification/purescala/invalid/EnsuringBoolean.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/FiniteSort.scala b/src/regression/resources/regression/verification/purescala/invalid/FiniteSort.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/FiniteSort.scala
rename to src/regression/resources/regression/verification/purescala/invalid/FiniteSort.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Generics.scala b/src/regression/resources/regression/verification/purescala/invalid/Generics.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Generics.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Generics.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Generics2.scala b/src/regression/resources/regression/verification/purescala/invalid/Generics2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Generics2.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Generics2.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/HOInvocations.scala b/src/regression/resources/regression/verification/purescala/invalid/HOInvocations.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/HOInvocations.scala
rename to src/regression/resources/regression/verification/purescala/invalid/HOInvocations.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/InsertionSort.scala b/src/regression/resources/regression/verification/purescala/invalid/InsertionSort.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/InsertionSort.scala
rename to src/regression/resources/regression/verification/purescala/invalid/InsertionSort.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/ListOperations.scala b/src/regression/resources/regression/verification/purescala/invalid/ListOperations.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/ListOperations.scala
rename to src/regression/resources/regression/verification/purescala/invalid/ListOperations.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Lists.scala b/src/regression/resources/regression/verification/purescala/invalid/Lists.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Lists.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Lists.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/ModuloByZero.scala b/src/regression/resources/regression/verification/purescala/invalid/ModuloByZero.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/ModuloByZero.scala
rename to src/regression/resources/regression/verification/purescala/invalid/ModuloByZero.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/MyTuple1.scala b/src/regression/resources/regression/verification/purescala/invalid/MyTuple1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/MyTuple1.scala
rename to src/regression/resources/regression/verification/purescala/invalid/MyTuple1.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/MyTuple2.scala b/src/regression/resources/regression/verification/purescala/invalid/MyTuple2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/MyTuple2.scala
rename to src/regression/resources/regression/verification/purescala/invalid/MyTuple2.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/MyTuple3.scala b/src/regression/resources/regression/verification/purescala/invalid/MyTuple3.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/MyTuple3.scala
rename to src/regression/resources/regression/verification/purescala/invalid/MyTuple3.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Overrides.scala b/src/regression/resources/regression/verification/purescala/invalid/Overrides.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Overrides.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Overrides.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/PositiveMap.scala b/src/regression/resources/regression/verification/purescala/invalid/PositiveMap.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/PositiveMap.scala
rename to src/regression/resources/regression/verification/purescala/invalid/PositiveMap.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/PropositionalLogic.scala b/src/regression/resources/regression/verification/purescala/invalid/PropositionalLogic.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/PropositionalLogic.scala
rename to src/regression/resources/regression/verification/purescala/invalid/PropositionalLogic.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/README b/src/regression/resources/regression/verification/purescala/invalid/README
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/README
rename to src/regression/resources/regression/verification/purescala/invalid/README
diff --git a/src/test/resources/regression/verification/purescala/invalid/RealDivisionByZero.scala b/src/regression/resources/regression/verification/purescala/invalid/RealDivisionByZero.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/RealDivisionByZero.scala
rename to src/regression/resources/regression/verification/purescala/invalid/RealDivisionByZero.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/RealNonDiscrete.scala b/src/regression/resources/regression/verification/purescala/invalid/RealNonDiscrete.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/RealNonDiscrete.scala
rename to src/regression/resources/regression/verification/purescala/invalid/RealNonDiscrete.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/RedBlackTree.scala b/src/regression/resources/regression/verification/purescala/invalid/RedBlackTree.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/RedBlackTree.scala
rename to src/regression/resources/regression/verification/purescala/invalid/RedBlackTree.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/RemainderByZero.scala b/src/regression/resources/regression/verification/purescala/invalid/RemainderByZero.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/RemainderByZero.scala
rename to src/regression/resources/regression/verification/purescala/invalid/RemainderByZero.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Unapply1.scala b/src/regression/resources/regression/verification/purescala/invalid/Unapply1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Unapply1.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Unapply1.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Unapply2.scala b/src/regression/resources/regression/verification/purescala/invalid/Unapply2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Unapply2.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Unapply2.scala
diff --git a/src/test/resources/regression/verification/purescala/invalid/Unit1.scala b/src/regression/resources/regression/verification/purescala/invalid/Unit1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/invalid/Unit1.scala
rename to src/regression/resources/regression/verification/purescala/invalid/Unit1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Acc.scala b/src/regression/resources/regression/verification/purescala/valid/Acc.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Acc.scala
rename to src/regression/resources/regression/verification/purescala/valid/Acc.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/AddingPositiveNumbers.scala b/src/regression/resources/regression/verification/purescala/valid/AddingPositiveNumbers.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/AddingPositiveNumbers.scala
rename to src/regression/resources/regression/verification/purescala/valid/AddingPositiveNumbers.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/AmortizedQueue.scala b/src/regression/resources/regression/verification/purescala/valid/AmortizedQueue.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/AmortizedQueue.scala
rename to src/regression/resources/regression/verification/purescala/valid/AmortizedQueue.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Anonymous.scala b/src/regression/resources/regression/verification/purescala/valid/Anonymous.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Anonymous.scala
rename to src/regression/resources/regression/verification/purescala/valid/Anonymous.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/ArrayLiterals.scala b/src/regression/resources/regression/verification/purescala/valid/ArrayLiterals.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/ArrayLiterals.scala
rename to src/regression/resources/regression/verification/purescala/valid/ArrayLiterals.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/ArrayUpdated.scala b/src/regression/resources/regression/verification/purescala/valid/ArrayUpdated.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/ArrayUpdated.scala
rename to src/regression/resources/regression/verification/purescala/valid/ArrayUpdated.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Asserts1.scala b/src/regression/resources/regression/verification/purescala/valid/Asserts1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Asserts1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Asserts1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/AssociativeList.scala b/src/regression/resources/regression/verification/purescala/valid/AssociativeList.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/AssociativeList.scala
rename to src/regression/resources/regression/verification/purescala/valid/AssociativeList.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/BVDivSemantics.scala b/src/regression/resources/regression/verification/purescala/valid/BVDivSemantics.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/BVDivSemantics.scala
rename to src/regression/resources/regression/verification/purescala/valid/BVDivSemantics.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/BVDivisionByZero.scala b/src/regression/resources/regression/verification/purescala/valid/BVDivisionByZero.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/BVDivisionByZero.scala
rename to src/regression/resources/regression/verification/purescala/valid/BVDivisionByZero.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/BVDivisionByZero2.scala b/src/regression/resources/regression/verification/purescala/valid/BVDivisionByZero2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/BVDivisionByZero2.scala
rename to src/regression/resources/regression/verification/purescala/valid/BVDivisionByZero2.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/BasicReal.scala b/src/regression/resources/regression/verification/purescala/valid/BasicReal.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/BasicReal.scala
rename to src/regression/resources/regression/verification/purescala/valid/BasicReal.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/BestRealTypes.scala b/src/regression/resources/regression/verification/purescala/valid/BestRealTypes.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/BestRealTypes.scala
rename to src/regression/resources/regression/verification/purescala/valid/BestRealTypes.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/BitsTricks.scala b/src/regression/resources/regression/verification/purescala/valid/BitsTricks.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/BitsTricks.scala
rename to src/regression/resources/regression/verification/purescala/valid/BitsTricks.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/CaseObject1.scala b/src/regression/resources/regression/verification/purescala/valid/CaseObject1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/CaseObject1.scala
rename to src/regression/resources/regression/verification/purescala/valid/CaseObject1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Choose1.scala b/src/regression/resources/regression/verification/purescala/valid/Choose1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Choose1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Choose1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Closures.scala b/src/regression/resources/regression/verification/purescala/valid/Closures.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Closures.scala
rename to src/regression/resources/regression/verification/purescala/valid/Closures.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Closures2.scala b/src/regression/resources/regression/verification/purescala/valid/Closures2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Closures2.scala
rename to src/regression/resources/regression/verification/purescala/valid/Closures2.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/DivisionByZero.scala b/src/regression/resources/regression/verification/purescala/valid/DivisionByZero.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/DivisionByZero.scala
rename to src/regression/resources/regression/verification/purescala/valid/DivisionByZero.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Extern1.scala b/src/regression/resources/regression/verification/purescala/valid/Extern1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Extern1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Extern1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Extern2.scala b/src/regression/resources/regression/verification/purescala/valid/Extern2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Extern2.scala
rename to src/regression/resources/regression/verification/purescala/valid/Extern2.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Field1.scala b/src/regression/resources/regression/verification/purescala/valid/Field1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Field1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Field1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Field2.scala b/src/regression/resources/regression/verification/purescala/valid/Field2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Field2.scala
rename to src/regression/resources/regression/verification/purescala/valid/Field2.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/FiniteSort.scala b/src/regression/resources/regression/verification/purescala/valid/FiniteSort.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/FiniteSort.scala
rename to src/regression/resources/regression/verification/purescala/valid/FiniteSort.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/FlatMap.scala b/src/regression/resources/regression/verification/purescala/valid/FlatMap.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/FlatMap.scala
rename to src/regression/resources/regression/verification/purescala/valid/FlatMap.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/FoldAssociative.scala b/src/regression/resources/regression/verification/purescala/valid/FoldAssociative.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/FoldAssociative.scala
rename to src/regression/resources/regression/verification/purescala/valid/FoldAssociative.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/FoolProofAdder.scala b/src/regression/resources/regression/verification/purescala/valid/FoolProofAdder.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/FoolProofAdder.scala
rename to src/regression/resources/regression/verification/purescala/valid/FoolProofAdder.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Generics.scala b/src/regression/resources/regression/verification/purescala/valid/Generics.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Generics.scala
rename to src/regression/resources/regression/verification/purescala/valid/Generics.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Generics1.scala b/src/regression/resources/regression/verification/purescala/valid/Generics1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Generics1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Generics1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/HOInvocations.scala b/src/regression/resources/regression/verification/purescala/valid/HOInvocations.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/HOInvocations.scala
rename to src/regression/resources/regression/verification/purescala/valid/HOInvocations.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Heaps.scala b/src/regression/resources/regression/verification/purescala/valid/Heaps.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Heaps.scala
rename to src/regression/resources/regression/verification/purescala/valid/Heaps.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/InsertionSort.scala b/src/regression/resources/regression/verification/purescala/valid/InsertionSort.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/InsertionSort.scala
rename to src/regression/resources/regression/verification/purescala/valid/InsertionSort.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/InstanceOf1.scala b/src/regression/resources/regression/verification/purescala/valid/InstanceOf1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/InstanceOf1.scala
rename to src/regression/resources/regression/verification/purescala/valid/InstanceOf1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Justify.scala b/src/regression/resources/regression/verification/purescala/valid/Justify.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Justify.scala
rename to src/regression/resources/regression/verification/purescala/valid/Justify.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/LambdaEquality.scala b/src/regression/resources/regression/verification/purescala/valid/LambdaEquality.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/LambdaEquality.scala
rename to src/regression/resources/regression/verification/purescala/valid/LambdaEquality.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Lambdas.scala b/src/regression/resources/regression/verification/purescala/valid/Lambdas.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Lambdas.scala
rename to src/regression/resources/regression/verification/purescala/valid/Lambdas.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/ListOperations.scala b/src/regression/resources/regression/verification/purescala/valid/ListOperations.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/ListOperations.scala
rename to src/regression/resources/regression/verification/purescala/valid/ListOperations.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Lists1.scala b/src/regression/resources/regression/verification/purescala/valid/Lists1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Lists1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Lists1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Lists2.scala b/src/regression/resources/regression/verification/purescala/valid/Lists2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Lists2.scala
rename to src/regression/resources/regression/verification/purescala/valid/Lists2.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Lists3.scala b/src/regression/resources/regression/verification/purescala/valid/Lists3.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Lists3.scala
rename to src/regression/resources/regression/verification/purescala/valid/Lists3.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Lists4.scala b/src/regression/resources/regression/verification/purescala/valid/Lists4.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Lists4.scala
rename to src/regression/resources/regression/verification/purescala/valid/Lists4.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Lists5.scala b/src/regression/resources/regression/verification/purescala/valid/Lists5.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Lists5.scala
rename to src/regression/resources/regression/verification/purescala/valid/Lists5.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Lists6.scala b/src/regression/resources/regression/verification/purescala/valid/Lists6.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Lists6.scala
rename to src/regression/resources/regression/verification/purescala/valid/Lists6.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/LiteralMaps.scala b/src/regression/resources/regression/verification/purescala/valid/LiteralMaps.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/LiteralMaps.scala
rename to src/regression/resources/regression/verification/purescala/valid/LiteralMaps.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MapGetOrElse2.scala b/src/regression/resources/regression/verification/purescala/valid/MapGetOrElse2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MapGetOrElse2.scala
rename to src/regression/resources/regression/verification/purescala/valid/MapGetOrElse2.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MapGetPlus.scala b/src/regression/resources/regression/verification/purescala/valid/MapGetPlus.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MapGetPlus.scala
rename to src/regression/resources/regression/verification/purescala/valid/MapGetPlus.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MergeSort.scala b/src/regression/resources/regression/verification/purescala/valid/MergeSort.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MergeSort.scala
rename to src/regression/resources/regression/verification/purescala/valid/MergeSort.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Methods.scala b/src/regression/resources/regression/verification/purescala/valid/Methods.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Methods.scala
rename to src/regression/resources/regression/verification/purescala/valid/Methods.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Monads1.scala b/src/regression/resources/regression/verification/purescala/valid/Monads1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Monads1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Monads1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Monads2.scala b/src/regression/resources/regression/verification/purescala/valid/Monads2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Monads2.scala
rename to src/regression/resources/regression/verification/purescala/valid/Monads2.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Monads3.scala b/src/regression/resources/regression/verification/purescala/valid/Monads3.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Monads3.scala
rename to src/regression/resources/regression/verification/purescala/valid/Monads3.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MyMap.scala b/src/regression/resources/regression/verification/purescala/valid/MyMap.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MyMap.scala
rename to src/regression/resources/regression/verification/purescala/valid/MyMap.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MySet.scala b/src/regression/resources/regression/verification/purescala/valid/MySet.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MySet.scala
rename to src/regression/resources/regression/verification/purescala/valid/MySet.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MyTuple1.scala b/src/regression/resources/regression/verification/purescala/valid/MyTuple1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MyTuple1.scala
rename to src/regression/resources/regression/verification/purescala/valid/MyTuple1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MyTuple2.scala b/src/regression/resources/regression/verification/purescala/valid/MyTuple2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MyTuple2.scala
rename to src/regression/resources/regression/verification/purescala/valid/MyTuple2.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MyTuple3.scala b/src/regression/resources/regression/verification/purescala/valid/MyTuple3.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MyTuple3.scala
rename to src/regression/resources/regression/verification/purescala/valid/MyTuple3.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MyTuple4.scala b/src/regression/resources/regression/verification/purescala/valid/MyTuple4.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MyTuple4.scala
rename to src/regression/resources/regression/verification/purescala/valid/MyTuple4.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MyTuple5.scala b/src/regression/resources/regression/verification/purescala/valid/MyTuple5.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MyTuple5.scala
rename to src/regression/resources/regression/verification/purescala/valid/MyTuple5.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/MyTuple6.scala b/src/regression/resources/regression/verification/purescala/valid/MyTuple6.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/MyTuple6.scala
rename to src/regression/resources/regression/verification/purescala/valid/MyTuple6.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Nat.scala b/src/regression/resources/regression/verification/purescala/valid/Nat.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Nat.scala
rename to src/regression/resources/regression/verification/purescala/valid/Nat.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/NotEquals.scala b/src/regression/resources/regression/verification/purescala/valid/NotEquals.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/NotEquals.scala
rename to src/regression/resources/regression/verification/purescala/valid/NotEquals.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Overrides.scala b/src/regression/resources/regression/verification/purescala/valid/Overrides.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Overrides.scala
rename to src/regression/resources/regression/verification/purescala/valid/Overrides.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/ParBalance.scala b/src/regression/resources/regression/verification/purescala/valid/ParBalance.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/ParBalance.scala
rename to src/regression/resources/regression/verification/purescala/valid/ParBalance.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/PositiveMap.scala b/src/regression/resources/regression/verification/purescala/valid/PositiveMap.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/PositiveMap.scala
rename to src/regression/resources/regression/verification/purescala/valid/PositiveMap.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/PropositionalLogic.scala b/src/regression/resources/regression/verification/purescala/valid/PropositionalLogic.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/PropositionalLogic.scala
rename to src/regression/resources/regression/verification/purescala/valid/PropositionalLogic.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/README b/src/regression/resources/regression/verification/purescala/valid/README
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/README
rename to src/regression/resources/regression/verification/purescala/valid/README
diff --git a/src/test/resources/regression/verification/purescala/valid/RealDivisionByZero.scala b/src/regression/resources/regression/verification/purescala/valid/RealDivisionByZero.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/RealDivisionByZero.scala
rename to src/regression/resources/regression/verification/purescala/valid/RealDivisionByZero.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/RedBlackTree.scala b/src/regression/resources/regression/verification/purescala/valid/RedBlackTree.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/RedBlackTree.scala
rename to src/regression/resources/regression/verification/purescala/valid/RedBlackTree.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/SearchLinkedList.scala b/src/regression/resources/regression/verification/purescala/valid/SearchLinkedList.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/SearchLinkedList.scala
rename to src/regression/resources/regression/verification/purescala/valid/SearchLinkedList.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Sets1.scala b/src/regression/resources/regression/verification/purescala/valid/Sets1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Sets1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Sets1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Sets2.scala b/src/regression/resources/regression/verification/purescala/valid/Sets2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Sets2.scala
rename to src/regression/resources/regression/verification/purescala/valid/Sets2.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Subtyping1.scala b/src/regression/resources/regression/verification/purescala/valid/Subtyping1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Subtyping1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Subtyping1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Subtyping2.scala b/src/regression/resources/regression/verification/purescala/valid/Subtyping2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Subtyping2.scala
rename to src/regression/resources/regression/verification/purescala/valid/Subtyping2.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Trees1.scala b/src/regression/resources/regression/verification/purescala/valid/Trees1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Trees1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Trees1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Unapply.scala b/src/regression/resources/regression/verification/purescala/valid/Unapply.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Unapply.scala
rename to src/regression/resources/regression/verification/purescala/valid/Unapply.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Unit1.scala b/src/regression/resources/regression/verification/purescala/valid/Unit1.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Unit1.scala
rename to src/regression/resources/regression/verification/purescala/valid/Unit1.scala
diff --git a/src/test/resources/regression/verification/purescala/valid/Unit2.scala b/src/regression/resources/regression/verification/purescala/valid/Unit2.scala
similarity index 100%
rename from src/test/resources/regression/verification/purescala/valid/Unit2.scala
rename to src/regression/resources/regression/verification/purescala/valid/Unit2.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Array1.scala b/src/regression/resources/regression/verification/xlang/invalid/Array1.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Array1.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Array1.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Array2.scala b/src/regression/resources/regression/verification/xlang/invalid/Array2.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Array2.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Array2.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Array3.scala b/src/regression/resources/regression/verification/xlang/invalid/Array3.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Array3.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Array3.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Array4.scala b/src/regression/resources/regression/verification/xlang/invalid/Array4.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Array4.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Array4.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Array5.scala b/src/regression/resources/regression/verification/xlang/invalid/Array5.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Array5.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Array5.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Array6.scala b/src/regression/resources/regression/verification/xlang/invalid/Array6.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Array6.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Array6.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Asserts.scala b/src/regression/resources/regression/verification/xlang/invalid/Asserts.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Asserts.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Asserts.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Epsilon1.scala b/src/regression/resources/regression/verification/xlang/invalid/Epsilon1.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Epsilon1.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Epsilon1.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Epsilon2.scala b/src/regression/resources/regression/verification/xlang/invalid/Epsilon2.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Epsilon2.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Epsilon2.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Epsilon3.scala b/src/regression/resources/regression/verification/xlang/invalid/Epsilon3.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Epsilon3.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Epsilon3.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Epsilon4.scala b/src/regression/resources/regression/verification/xlang/invalid/Epsilon4.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Epsilon4.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Epsilon4.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Epsilon5.scala b/src/regression/resources/regression/verification/xlang/invalid/Epsilon5.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Epsilon5.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Epsilon5.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Epsilon6.scala b/src/regression/resources/regression/verification/xlang/invalid/Epsilon6.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Epsilon6.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Epsilon6.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/IfExpr1.scala b/src/regression/resources/regression/verification/xlang/invalid/IfExpr1.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/IfExpr1.scala
rename to src/regression/resources/regression/verification/xlang/invalid/IfExpr1.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/IfExpr2.scala b/src/regression/resources/regression/verification/xlang/invalid/IfExpr2.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/IfExpr2.scala
rename to src/regression/resources/regression/verification/xlang/invalid/IfExpr2.scala
diff --git a/src/test/resources/regression/verification/xlang/invalid/Mean.scala b/src/regression/resources/regression/verification/xlang/invalid/Mean.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/invalid/Mean.scala
rename to src/regression/resources/regression/verification/xlang/invalid/Mean.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Arithmetic.scala b/src/regression/resources/regression/verification/xlang/valid/Arithmetic.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Arithmetic.scala
rename to src/regression/resources/regression/verification/xlang/valid/Arithmetic.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Array1.scala b/src/regression/resources/regression/verification/xlang/valid/Array1.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Array1.scala
rename to src/regression/resources/regression/verification/xlang/valid/Array1.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Array2.scala b/src/regression/resources/regression/verification/xlang/valid/Array2.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Array2.scala
rename to src/regression/resources/regression/verification/xlang/valid/Array2.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Array3.scala b/src/regression/resources/regression/verification/xlang/valid/Array3.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Array3.scala
rename to src/regression/resources/regression/verification/xlang/valid/Array3.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Array4.scala b/src/regression/resources/regression/verification/xlang/valid/Array4.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Array4.scala
rename to src/regression/resources/regression/verification/xlang/valid/Array4.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Array5.scala b/src/regression/resources/regression/verification/xlang/valid/Array5.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Array5.scala
rename to src/regression/resources/regression/verification/xlang/valid/Array5.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Array6.scala b/src/regression/resources/regression/verification/xlang/valid/Array6.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Array6.scala
rename to src/regression/resources/regression/verification/xlang/valid/Array6.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Array7.scala b/src/regression/resources/regression/verification/xlang/valid/Array7.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Array7.scala
rename to src/regression/resources/regression/verification/xlang/valid/Array7.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Array8.scala b/src/regression/resources/regression/verification/xlang/valid/Array8.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Array8.scala
rename to src/regression/resources/regression/verification/xlang/valid/Array8.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Array9.scala b/src/regression/resources/regression/verification/xlang/valid/Array9.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Array9.scala
rename to src/regression/resources/regression/verification/xlang/valid/Array9.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Assign1.scala b/src/regression/resources/regression/verification/xlang/valid/Assign1.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Assign1.scala
rename to src/regression/resources/regression/verification/xlang/valid/Assign1.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Choose1.scala b/src/regression/resources/regression/verification/xlang/valid/Choose1.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Choose1.scala
rename to src/regression/resources/regression/verification/xlang/valid/Choose1.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Epsilon1.scala b/src/regression/resources/regression/verification/xlang/valid/Epsilon1.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Epsilon1.scala
rename to src/regression/resources/regression/verification/xlang/valid/Epsilon1.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Epsilon2.scala b/src/regression/resources/regression/verification/xlang/valid/Epsilon2.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Epsilon2.scala
rename to src/regression/resources/regression/verification/xlang/valid/Epsilon2.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Epsilon3.scala b/src/regression/resources/regression/verification/xlang/valid/Epsilon3.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Epsilon3.scala
rename to src/regression/resources/regression/verification/xlang/valid/Epsilon3.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Epsilon4.scala b/src/regression/resources/regression/verification/xlang/valid/Epsilon4.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Epsilon4.scala
rename to src/regression/resources/regression/verification/xlang/valid/Epsilon4.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Epsilon5.scala b/src/regression/resources/regression/verification/xlang/valid/Epsilon5.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Epsilon5.scala
rename to src/regression/resources/regression/verification/xlang/valid/Epsilon5.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/IfExpr1.scala b/src/regression/resources/regression/verification/xlang/valid/IfExpr1.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/IfExpr1.scala
rename to src/regression/resources/regression/verification/xlang/valid/IfExpr1.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/IfExpr2.scala b/src/regression/resources/regression/verification/xlang/valid/IfExpr2.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/IfExpr2.scala
rename to src/regression/resources/regression/verification/xlang/valid/IfExpr2.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/IfExpr3.scala b/src/regression/resources/regression/verification/xlang/valid/IfExpr3.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/IfExpr3.scala
rename to src/regression/resources/regression/verification/xlang/valid/IfExpr3.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/IfExpr4.scala b/src/regression/resources/regression/verification/xlang/valid/IfExpr4.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/IfExpr4.scala
rename to src/regression/resources/regression/verification/xlang/valid/IfExpr4.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Mean.scala b/src/regression/resources/regression/verification/xlang/valid/Mean.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Mean.scala
rename to src/regression/resources/regression/verification/xlang/valid/Mean.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested1.scala b/src/regression/resources/regression/verification/xlang/valid/Nested1.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested1.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested1.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested10.scala b/src/regression/resources/regression/verification/xlang/valid/Nested10.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested10.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested10.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested11.scala b/src/regression/resources/regression/verification/xlang/valid/Nested11.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested11.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested11.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested12.scala b/src/regression/resources/regression/verification/xlang/valid/Nested12.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested12.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested12.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested13.scala b/src/regression/resources/regression/verification/xlang/valid/Nested13.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested13.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested13.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested14.scala b/src/regression/resources/regression/verification/xlang/valid/Nested14.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested14.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested14.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested2.scala b/src/regression/resources/regression/verification/xlang/valid/Nested2.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested2.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested2.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested3.scala b/src/regression/resources/regression/verification/xlang/valid/Nested3.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested3.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested3.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested4.scala b/src/regression/resources/regression/verification/xlang/valid/Nested4.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested4.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested4.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested5.scala b/src/regression/resources/regression/verification/xlang/valid/Nested5.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested5.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested5.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested6.scala b/src/regression/resources/regression/verification/xlang/valid/Nested6.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested6.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested6.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested7.scala b/src/regression/resources/regression/verification/xlang/valid/Nested7.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested7.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested7.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested8.scala b/src/regression/resources/regression/verification/xlang/valid/Nested8.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested8.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested8.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/Nested9.scala b/src/regression/resources/regression/verification/xlang/valid/Nested9.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/Nested9.scala
rename to src/regression/resources/regression/verification/xlang/valid/Nested9.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/NestedVar.scala b/src/regression/resources/regression/verification/xlang/valid/NestedVar.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/NestedVar.scala
rename to src/regression/resources/regression/verification/xlang/valid/NestedVar.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/ShortCircuit.scala b/src/regression/resources/regression/verification/xlang/valid/ShortCircuit.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/ShortCircuit.scala
rename to src/regression/resources/regression/verification/xlang/valid/ShortCircuit.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/While1.scala b/src/regression/resources/regression/verification/xlang/valid/While1.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/While1.scala
rename to src/regression/resources/regression/verification/xlang/valid/While1.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/While2.scala b/src/regression/resources/regression/verification/xlang/valid/While2.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/While2.scala
rename to src/regression/resources/regression/verification/xlang/valid/While2.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/While3.scala b/src/regression/resources/regression/verification/xlang/valid/While3.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/While3.scala
rename to src/regression/resources/regression/verification/xlang/valid/While3.scala
diff --git a/src/test/resources/regression/verification/xlang/valid/WhileConditionSubexpression.scala b/src/regression/resources/regression/verification/xlang/valid/WhileConditionSubexpression.scala
similarity index 100%
rename from src/test/resources/regression/verification/xlang/valid/WhileConditionSubexpression.scala
rename to src/regression/resources/regression/verification/xlang/valid/WhileConditionSubexpression.scala
diff --git a/src/regression/scala/leon/test/LeonTestSuite.scala b/src/regression/scala/leon/test/LeonTestSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..ff6dec6c62ccebe728609385a9f3270a40d5d7d1
--- /dev/null
+++ b/src/regression/scala/leon/test/LeonTestSuite.scala
@@ -0,0 +1,111 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test
+
+import leon._
+import leon.LeonContext
+import leon.utils._
+
+import scala.io.Source
+import org.scalatest._
+import org.scalatest.time.Span
+import org.scalatest.concurrent._
+import org.scalatest.time.SpanSugar._
+import org.scalatest.exceptions.TestFailedException
+
+import java.io.File
+
+trait LeonTestSuite extends FunSuite with Timeouts with BeforeAndAfterEach {
+  // Hard-code resource directory, for Eclipse purposes
+  val resourceDirHard = "src/test/resources/"
+
+  def createLeonContext(opts: String*): LeonContext = {
+    val reporter = new TestSilentReporter
+
+    Main.processOptions(opts.toList).copy(reporter = reporter, interruptManager = new InterruptManager(reporter))
+  }
+
+  var testContext: LeonContext = null
+
+  override def beforeEach() = {
+    testContext = createLeonContext()
+    super.beforeEach()
+  }
+
+  def testIdentifier(name: String): String = {
+    def sanitize(s: String) = s.replaceAll("[^0-9a-zA-Z-]", "")
+
+    sanitize(this.getClass.getName)+"/"+sanitize(name)
+  }
+
+  override implicit val defaultInterruptor = new Interruptor {
+    def apply(t: Thread) {
+      testContext.interruptManager.interrupt()
+    }
+  }
+
+  def testWithTimeout(name: String, timeout: Span)(body: => Unit) {
+    super.test(name) {
+      val id = testIdentifier(name)
+
+      failAfter(timeout) {
+        try {
+          body
+        } catch {
+          case fe: LeonFatalError =>
+            testContext.reporter match {
+              case sr: TestSilentReporter =>
+                sr.lastErrors ++= fe.msg
+                throw new TestFailedException(sr.lastErrors.mkString("\n"), fe, 5)
+            }
+        }
+      }
+    }
+  }
+
+
+  override def test(name: String, tags: Tag*)(body: => Unit) {
+    testWithTimeout(name, 5.minutes)(body)
+  }
+
+  protected val all : String=>Boolean = (s : String) => true
+
+
+  def resourceDir(dir : String) : File = {
+
+    val d = this.getClass.getClassLoader.getResource(dir)
+
+    if(d == null || d.getProtocol != "file") {
+      // We are in Eclipse. The only way we are saved is by hard-coding the path
+      new File(resourceDirHard + dir)
+    }
+    else {
+      new File(d.toURI)
+    }
+  }
+
+
+  
+  
+  def scanFilesIn(f: File, filter: String=>Boolean = all, recursive: Boolean = false): Iterable[File] = {
+    Option(f.listFiles()).getOrElse(Array()).flatMap{f =>
+      if (f.isDirectory && recursive) {
+        scanFilesIn(f, filter, recursive)   
+      } else {
+        List(f) 
+      }
+    }.filter(f => filter(f.getPath))
+  }
+
+  def filesInResourceDir(dir : String, filter : String=>Boolean = all, recursive: Boolean = false) : Iterable[File] = {
+
+    val d = this.getClass.getClassLoader.getResource(dir)
+
+    val asFile = if(d == null || d.getProtocol != "file") {
+      // We are in Eclipse. The only way we are saved is by hard-coding the path
+      new File(resourceDirHard + dir)
+    } else new File(d.toURI)
+
+    scanFilesIn(asFile, filter, recursive)
+  }
+}
diff --git a/src/regression/scala/leon/test/TestSilentReporter.scala b/src/regression/scala/leon/test/TestSilentReporter.scala
new file mode 100644
index 0000000000000000000000000000000000000000..a303d35a99ed6a76d2068a9a279fb5ec664e5d38
--- /dev/null
+++ b/src/regression/scala/leon/test/TestSilentReporter.scala
@@ -0,0 +1,14 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test
+import leon.DefaultReporter
+
+class TestSilentReporter extends DefaultReporter(Set()) {
+  var lastErrors: List[String] = Nil
+
+  override def emit(msg: Message): Unit = msg match { 
+    case Message(this.ERROR, _, msg) => lastErrors ++= List(msg.toString)
+    case Message(this.FATAL, _, msg) => lastErrors ++= List(msg.toString)
+    case _ =>
+  }
+}
diff --git a/src/test/scala/leon/test/frontends/FrontEndsSuite.scala b/src/regression/scala/leon/test/frontends/FrontEndsSuite.scala
similarity index 100%
rename from src/test/scala/leon/test/frontends/FrontEndsSuite.scala
rename to src/regression/scala/leon/test/frontends/FrontEndsSuite.scala
diff --git a/src/test/scala/leon/test/repair/RepairSuite.scala b/src/regression/scala/leon/test/repair/RepairSuite.scala
similarity index 100%
rename from src/test/scala/leon/test/repair/RepairSuite.scala
rename to src/regression/scala/leon/test/repair/RepairSuite.scala
diff --git a/src/test/scala/leon/test/synthesis/StablePrintingSuite.scala b/src/regression/scala/leon/test/synthesis/StablePrintingSuite.scala
similarity index 98%
rename from src/test/scala/leon/test/synthesis/StablePrintingSuite.scala
rename to src/regression/scala/leon/test/synthesis/StablePrintingSuite.scala
index 360b4a5d06fb685d4aaf6254a6b6d9717aeed7e5..0ce980af83622d18c130aff57f9b2076e6c26cbd 100644
--- a/src/test/scala/leon/test/synthesis/StablePrintingSuite.scala
+++ b/src/regression/scala/leon/test/synthesis/StablePrintingSuite.scala
@@ -35,7 +35,7 @@ class StablePrintingSuite extends LeonTestSuite {
                      leon.utils.PreprocessingPhase andThen
                      purescala.FunctionClosure
 
-      val program = pipeline.run(ctx)((content, Nil))
+      val program = pipeline.run(ctx)((List(content), Nil))
 
       (program, opts, ChooseInfo.extractFromProgram(ctx, program))
     }
diff --git a/src/test/scala/leon/test/synthesis/SynthesisRegressionSuite.scala b/src/regression/scala/leon/test/synthesis/SynthesisRegressionSuite.scala
similarity index 100%
rename from src/test/scala/leon/test/synthesis/SynthesisRegressionSuite.scala
rename to src/regression/scala/leon/test/synthesis/SynthesisRegressionSuite.scala
diff --git a/src/test/scala/leon/test/synthesis/SynthesisSuite.scala b/src/regression/scala/leon/test/synthesis/SynthesisSuite.scala
similarity index 99%
rename from src/test/scala/leon/test/synthesis/SynthesisSuite.scala
rename to src/regression/scala/leon/test/synthesis/SynthesisSuite.scala
index 35c7d6f6efd51aa19c0fa04623e5be9d74321e0a..6188d8d6e81d7429e5090f3d8da8fdfbd0e5a431 100644
--- a/src/test/scala/leon/test/synthesis/SynthesisSuite.scala
+++ b/src/regression/scala/leon/test/synthesis/SynthesisSuite.scala
@@ -87,7 +87,7 @@ class SynthesisSuite extends LeonTestSuite {
 
         val pipeline = leon.utils.TemporaryInputPhase andThen leon.frontends.scalac.ExtractionPhase andThen PreprocessingPhase andThen SynthesisProblemExtractionPhase
 
-        val (program, results) = pipeline.run(ctx)((content, Nil))
+        val (program, results) = pipeline.run(ctx)((List(content), Nil))
 
         for ((f,cis) <- results; ci <- cis) {
           info(f"${ci.fd.id.toString}%-20s")
diff --git a/src/test/scala/leon/test/termination/TerminationSuite.scala b/src/regression/scala/leon/test/termination/TerminationSuite.scala
similarity index 100%
rename from src/test/scala/leon/test/termination/TerminationSuite.scala
rename to src/regression/scala/leon/test/termination/TerminationSuite.scala
diff --git a/src/test/scala/leon/test/testcases/TestCasesCompile.scala b/src/regression/scala/leon/test/testcases/TestCasesCompile.scala
similarity index 96%
rename from src/test/scala/leon/test/testcases/TestCasesCompile.scala
rename to src/regression/scala/leon/test/testcases/TestCasesCompile.scala
index f82ff346c2c14cb8ce92664959a4345a0653b12d..5bc11bc87f2a7ed8c8bc6e90aaf59ea5bfcd35be 100644
--- a/src/test/scala/leon/test/testcases/TestCasesCompile.scala
+++ b/src/regression/scala/leon/test/testcases/TestCasesCompile.scala
@@ -9,8 +9,6 @@ import java.io.File
 import org.scalatest.ParallelTestExecution
 
 class TestCasesCompile extends LeonTestSuite {
-  // Hard-code output directory, for Eclipse purposes
-
   val pipeline = frontends.scalac.ExtractionPhase andThen utils.PreprocessingPhase
 
   def testFrontend(f: File, strip: Int): Boolean = {
diff --git a/src/test/scala/leon/test/verification/LibraryVerificationSuite.scala b/src/regression/scala/leon/test/verification/LibraryVerificationSuite.scala
similarity index 100%
rename from src/test/scala/leon/test/verification/LibraryVerificationSuite.scala
rename to src/regression/scala/leon/test/verification/LibraryVerificationSuite.scala
diff --git a/src/test/scala/leon/test/verification/NewSolversSuite.scala b/src/regression/scala/leon/test/verification/NewSolversSuite.scala
similarity index 81%
rename from src/test/scala/leon/test/verification/NewSolversSuite.scala
rename to src/regression/scala/leon/test/verification/NewSolversSuite.scala
index 93b51d436600bc22f68ab3d0215e2ca6a991e652..4e177932ddd280e043203cfb4f77a6cc447203e1 100644
--- a/src/test/scala/leon/test/verification/NewSolversSuite.scala
+++ b/src/regression/scala/leon/test/verification/NewSolversSuite.scala
@@ -6,12 +6,9 @@ import _root_.smtlib.interpreters._
 import leon._
 import leon.verification.AnalysisPhase
 
-// If you add another regression test, make sure it contains one object whose name matches the file name
-// This is because we compile all tests from each folder separately.
-
-// This class is currently NOT in LeonAllTests
+/* @EK: Disabled for now as many tests fail 
 class NewSolversSuite extends VerificationSuite {
-  
+
   val testDir = "regression/verification/newsolvers/"
   val pipeFront = xlang.NoXLangFeaturesChecking
   val pipeBack = AnalysisPhase
@@ -45,3 +42,4 @@ class NewSolversSuite extends VerificationSuite {
 
   }
 }
+*/
diff --git a/src/test/scala/leon/test/verification/PureScalaVerificationSuite.scala b/src/regression/scala/leon/test/verification/PureScalaVerificationSuite.scala
similarity index 100%
rename from src/test/scala/leon/test/verification/PureScalaVerificationSuite.scala
rename to src/regression/scala/leon/test/verification/PureScalaVerificationSuite.scala
diff --git a/src/test/scala/leon/test/verification/VerificationSuite.scala b/src/regression/scala/leon/test/verification/VerificationSuite.scala
similarity index 100%
rename from src/test/scala/leon/test/verification/VerificationSuite.scala
rename to src/regression/scala/leon/test/verification/VerificationSuite.scala
diff --git a/src/test/scala/leon/test/verification/XLangVerificationSuite.scala b/src/regression/scala/leon/test/verification/XLangVerificationSuite.scala
similarity index 100%
rename from src/test/scala/leon/test/verification/XLangVerificationSuite.scala
rename to src/regression/scala/leon/test/verification/XLangVerificationSuite.scala
diff --git a/src/test/scala/leon/test/LeonTestSuite.scala b/src/test/scala/leon/test/LeonTestSuite.scala
index 4defa22568bf6e9ffcf14f2fd621cd98a95b26f0..00ac90e0678acd62356c556a60d65358ef056fc6 100644
--- a/src/test/scala/leon/test/LeonTestSuite.scala
+++ b/src/test/scala/leon/test/LeonTestSuite.scala
@@ -3,180 +3,48 @@
 package leon.test
 
 import leon._
+import leon.purescala.Definitions.Program
 import leon.LeonContext
 import leon.utils._
+import leon.frontends.scalac.ExtractionPhase
 
-import scala.io.Source
 import org.scalatest._
-import org.scalatest.time.Span
-import org.scalatest.concurrent._
-import org.scalatest.time.SpanSugar._
 import org.scalatest.exceptions.TestFailedException
 
-import java.io.File
+trait LeonTestSuite extends fixture.FunSuite {
+  type FixtureParam = LeonContext
 
-trait LeonTestSuite extends FunSuite with Timeouts with BeforeAndAfterEach {
-  // Hard-code resource directory, for Eclipse purposes
-  val resourceDirHard = "src/test/resources/"
-
-  def now() = {
-    System.currentTimeMillis
-  }
-
-  case class Statistics(values: List[Long]) {
-    val n      = values.size
-    val avg    = values.sum.toDouble/n
-    val stddev = Math.sqrt(values.map(v => Math.pow(v.toDouble - avg, 2)).sum/n)
-
-    def accountsFor(ms: Long) = {
-      if (n < 5) {
-        true
-      } else {
-        val msd = ms.toDouble
-        msd < avg + 3*stddev + 20
-      }
-    }
-
-    def withValue(v: Long) = this.copy(v :: values)
-  }
-
-
-  def createLeonContext(opts: String*): LeonContext = {
+  override def withFixture(test: OneArgTest): Outcome = {
     val reporter = new TestSilentReporter
+    val opts     = List[String]()
 
-    Main.processOptions(opts.toList).copy(reporter = reporter, interruptManager = new InterruptManager(reporter))
-  }
-
-  var testContext: LeonContext = null
-
-  override def beforeEach() = {
-    testContext = createLeonContext()
-    super.beforeEach()
-  }
-
-  def testIdentifier(name: String): String = {
-    def sanitize(s: String) = s.replaceAll("[^0-9a-zA-Z-]", "")
-
-    sanitize(this.getClass.getName)+"/"+sanitize(name)
-  }
-
-  def bookKeepingFile(id: String) = {
-    import java.io.File
-
-    val f = new File(System.getProperty("user.dir")+"/.test-history/"+id+".log")
+    val ctx      = Main.processOptions(opts).copy(reporter = reporter)
 
-    f.getParentFile.mkdirs()
-
-    f
-  }
-
-  def getStats(id: String): Statistics = {
-    val f = bookKeepingFile(id)
-
-    if (f.canRead) {
-      Statistics(Source.fromFile(f).getLines().flatMap{ line =>
-        val l = line.trim
-        if (l.length > 0) {
-          Some(line.toLong)
-        } else {
-          None
-        }
-      }.toList)
-    } else {
-      Statistics(Nil)
+    try {
+      test(ctx)
+    } catch {
+      case fe: LeonFatalError =>
+        reporter.lastErrors ++= fe.msg
+        Failed(new TestFailedException(reporter.lastErrors.mkString("\n"), fe, 5))
     }
   }
 
-  def storeStats(id: String, stats: Statistics) {
-    import java.io.FileWriter
-
-    val f = bookKeepingFile(id)
-
-    val fw = new FileWriter(f, true)
-    fw.write(stats.values.head+"\n")
-    fw.close()
+  def parseString(str: String)(implicit ctx: LeonContext): Program = {
+    parseStrings(List(str))(ctx)
   }
 
-  override implicit val defaultInterruptor = new Interruptor {
-    def apply(t: Thread) {
-      testContext.interruptManager.interrupt()
-    }
-  }
-
-  def testWithTimeout(name: String, timeout: Span)(body: => Unit) {
-    super.test(name) {
-      val id = testIdentifier(name)
-
-      val ts = now()
-
-      failAfter(timeout) {
-        try {
-          body
-        } catch {
-          case fe: LeonFatalError =>
-            testContext.reporter match {
-              case sr: TestSilentReporter =>
-                sr.lastErrors ++= fe.msg
-                throw new TestFailedException(sr.lastErrors.mkString("\n"), fe, 5)
-            }
-        }
-      }
-
-      val total = now()-ts
+  def parseStrings(strs: List[String])(implicit ctx: LeonContext): Program = {
+    val pipeline = TemporaryInputPhase andThen
+                   ExtractionPhase andThen
+                   PreprocessingPhase
 
-      val stats = getStats(id)
+    val errorsBefore = ctx.reporter.errorCount
 
-      if (!stats.accountsFor(total)) {
-        info(Console.YELLOW+"[warning] Test took too long to run: "+total+"ms (avg: "+stats.avg+", stddev: "+stats.stddev+")")
-      }
-
-      storeStats(id, stats.withValue(total))
-    }
-  }
+    val program = pipeline.run(ctx)((strs, Nil))
 
+    assert(ctx.reporter.errorCount === errorsBefore)
 
-  override def test(name: String, tags: Tag*)(body: => Unit) {
-    testWithTimeout(name, 5.minutes)(body)
+    program
   }
 
-  protected val all : String=>Boolean = (s : String) => true
-
- 
-  def resourceDir(dir : String) : File = {
-
-    val d = this.getClass.getClassLoader.getResource(dir)
-
-    if(d == null || d.getProtocol != "file") {
-      // We are in Eclipse. The only way we are saved is by hard-coding the path
-      new File(resourceDirHard + dir)
-    }
-    else {
-      new File(d.toURI)
-    }
-  }
-
-
-  
-  
-  def scanFilesIn(f: File, filter: String=>Boolean = all, recursive: Boolean = false): Iterable[File] = {
-    Option(f.listFiles()).getOrElse(Array()).flatMap{f =>
-      if (f.isDirectory && recursive) {
-        scanFilesIn(f, filter, recursive)   
-      } else {
-        List(f) 
-      }
-    }.filter(f => filter(f.getPath))
-  }
-
-  def filesInResourceDir(dir : String, filter : String=>Boolean = all, recursive: Boolean = false) : Iterable[File] = {
-
-    val d = this.getClass.getClassLoader.getResource(dir)
-
-    val asFile = if(d == null || d.getProtocol != "file") {
-      // We are in Eclipse. The only way we are saved is by hard-coding the path
-      new File(resourceDirHard + dir)
-    } else new File(d.toURI)
-
-    scanFilesIn(asFile, filter, recursive)
-  }
 }
diff --git a/src/test/scala/leon/test/LeonTests.scala b/src/test/scala/leon/test/LeonTests.scala
deleted file mode 100644
index 2b64a137e38517731834cd44e0e5c994660e7358..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/LeonTests.scala
+++ /dev/null
@@ -1,65 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test
-
-import org.scalatest.Suites
-import evaluators._
-import codegen._
-import frontends._
-import purescala._
-import solvers._
-import repair._
-import synthesis._
-import termination._
-import utils._
-import verification._
-import testcases._
-
-class LeonAllTests extends Suites(
-  new LeonUnitTests,
-  new LeonFunTests,
-  new TestCasesCompile
-)
-
-class LeonFunTests extends Suites(
-  new FrontEndsSuite,
-
-  new RepairSuite,
-
-  new TerminationSuite,
-
-  new StablePrintingSuite,
-  new SynthesisSuite,
-  new SynthesisRegressionSuite,
-
-  new InliningSuite,
-
-  new LibraryVerificationSuite,
-  new PureScalaVerificationSuite,
-  new XLangVerificationSuite
-)
-
-class LeonUnitTests extends Suites(
-  new CodeGenSuite,
-
-  new ImportsSuite,
-
-  new StreamsSuite,
-
-  new DefOpsSuite,
-  new LikelyEqSuite,
-  new TransformationSuite,
-  new TreeNormalizationsSuite,
-  new TreeOpsSuite,
-  new TreeTestsSuite,
-
-  new EnumerationSolverSuite,
-  new TimeoutSolverSuite,
-  new UnrollingSolverSuite,
-
-  new AlgebraSuite,
-  new LinearEquationsSuite,
-
-  new DefaultEvaluatorSuite,
-  new EvaluatorSuite
-)
diff --git a/src/test/scala/leon/test/evaluators/DefaultEvaluatorSuite.scala b/src/test/scala/leon/test/evaluators/DefaultEvaluatorSuite.scala
deleted file mode 100644
index 86113df87beb774acd56f6c10b01eef48210560c..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/evaluators/DefaultEvaluatorSuite.scala
+++ /dev/null
@@ -1,357 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.evaluators
-
-import leon._
-import leon.evaluators._
-import leon.purescala.Common._
-import leon.purescala.Definitions._
-import leon.purescala.Expressions._
-import leon.purescala.Types._
-import leon.purescala.Constructors._
-
-class DefaultEvaluatorSuite extends leon.test.LeonTestSuite {
-  private implicit lazy val leonContext: LeonContext = createLeonContext()
-  private val emptyProgram = Program.empty
-
-  private val defaultEvaluator = new DefaultEvaluator(leonContext, emptyProgram)
-
-  def expectSuccessful(res: EvaluationResults.Result, expected: Expr): Unit = {
-    res match {
-      case EvaluationResults.Successful(value) => assert(value === expected)
-      case _ => assert(false)
-    }
-  }
-
-  test("eval correctly evaluates literals") {
-    expectSuccessful(defaultEvaluator.eval(BooleanLiteral(true)), BooleanLiteral(true))
-    expectSuccessful(defaultEvaluator.eval(BooleanLiteral(false)), BooleanLiteral(false))
-    expectSuccessful(defaultEvaluator.eval(IntLiteral(0)), IntLiteral(0))
-    expectSuccessful(defaultEvaluator.eval(IntLiteral(42)), IntLiteral(42))
-    expectSuccessful(defaultEvaluator.eval(UnitLiteral()), UnitLiteral())
-    expectSuccessful(defaultEvaluator.eval(InfiniteIntegerLiteral(0)), InfiniteIntegerLiteral(0))
-    expectSuccessful(defaultEvaluator.eval(InfiniteIntegerLiteral(42)), InfiniteIntegerLiteral(42))
-    expectSuccessful(defaultEvaluator.eval(RealLiteral(0)), RealLiteral(0))
-    expectSuccessful(defaultEvaluator.eval(RealLiteral(42)), RealLiteral(42))
-    expectSuccessful(defaultEvaluator.eval(RealLiteral(13.255)), RealLiteral(13.255))
-  }
-
-  test("eval of simple bit vector arithmetic expressions") {
-    expectSuccessful(defaultEvaluator.eval(BVPlus(IntLiteral(3), IntLiteral(5))), IntLiteral(8))
-    expectSuccessful(defaultEvaluator.eval(BVPlus(IntLiteral(0), IntLiteral(5))), IntLiteral(5))
-    expectSuccessful(defaultEvaluator.eval(BVTimes(IntLiteral(3), IntLiteral(3))), IntLiteral(9))
-  }
-
-  test("eval bitwise operations") {
-    expectSuccessful(defaultEvaluator.eval(BVAnd(IntLiteral(3), IntLiteral(1))), IntLiteral(1))
-    expectSuccessful(defaultEvaluator.eval(BVAnd(IntLiteral(3), IntLiteral(3))), IntLiteral(3))
-    expectSuccessful(defaultEvaluator.eval(BVAnd(IntLiteral(5), IntLiteral(3))), IntLiteral(1))
-    expectSuccessful(defaultEvaluator.eval(BVAnd(IntLiteral(5), IntLiteral(4))), IntLiteral(4))
-    expectSuccessful(defaultEvaluator.eval(BVAnd(IntLiteral(5), IntLiteral(2))), IntLiteral(0))
-
-    expectSuccessful(defaultEvaluator.eval(BVOr(IntLiteral(3), IntLiteral(1))), IntLiteral(3))
-    expectSuccessful(defaultEvaluator.eval(BVOr(IntLiteral(3), IntLiteral(3))), IntLiteral(3))
-    expectSuccessful(defaultEvaluator.eval(BVOr(IntLiteral(5), IntLiteral(3))), IntLiteral(7))
-    expectSuccessful(defaultEvaluator.eval(BVOr(IntLiteral(5), IntLiteral(4))), IntLiteral(5))
-    expectSuccessful(defaultEvaluator.eval(BVOr(IntLiteral(5), IntLiteral(2))), IntLiteral(7))
-
-    expectSuccessful(defaultEvaluator.eval(BVXOr(IntLiteral(3), IntLiteral(1))), IntLiteral(2))
-    expectSuccessful(defaultEvaluator.eval(BVXOr(IntLiteral(3), IntLiteral(3))), IntLiteral(0))
-
-    expectSuccessful(defaultEvaluator.eval(BVNot(IntLiteral(1))), IntLiteral(-2))
-
-    expectSuccessful(defaultEvaluator.eval(BVShiftLeft(IntLiteral(3), IntLiteral(1))), IntLiteral(6))
-    expectSuccessful(defaultEvaluator.eval(BVShiftLeft(IntLiteral(4), IntLiteral(2))), IntLiteral(16))
-
-    expectSuccessful(defaultEvaluator.eval(BVLShiftRight(IntLiteral(8), IntLiteral(1))), IntLiteral(4))
-    expectSuccessful(defaultEvaluator.eval(BVAShiftRight(IntLiteral(8), IntLiteral(1))), IntLiteral(4))
-  }
-
-  test("eval of simple arithmetic expressions") {
-    expectSuccessful(
-      defaultEvaluator.eval(Plus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(5))), 
-      InfiniteIntegerLiteral(8))
-    expectSuccessful(
-      defaultEvaluator.eval(Minus(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(2))), 
-      InfiniteIntegerLiteral(5))
-    expectSuccessful(
-      defaultEvaluator.eval(UMinus(InfiniteIntegerLiteral(7))),
-      InfiniteIntegerLiteral(-7))
-    expectSuccessful(
-      defaultEvaluator.eval(Times(InfiniteIntegerLiteral(2), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(6))
-  }
-
-  test("Eval of division, remainder and modulo semantics for BigInt") {
-    expectSuccessful(
-      defaultEvaluator.eval(Division(InfiniteIntegerLiteral(10), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(3))
-    expectSuccessful(
-      defaultEvaluator.eval(Remainder(InfiniteIntegerLiteral(10), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(1))
-    expectSuccessful(
-      defaultEvaluator.eval(Modulo(InfiniteIntegerLiteral(10), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(1))
-
-    expectSuccessful(
-      defaultEvaluator.eval(Division(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(Remainder(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(-1))
-    expectSuccessful(
-      defaultEvaluator.eval(Modulo(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(2))
-
-    expectSuccessful(
-      defaultEvaluator.eval(Division(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(Remainder(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(-1))
-    expectSuccessful(
-      defaultEvaluator.eval(Modulo(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(2))
-
-    expectSuccessful(
-      defaultEvaluator.eval(Division(InfiniteIntegerLiteral(1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(Remainder(InfiniteIntegerLiteral(1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(1))
-    expectSuccessful(
-      defaultEvaluator.eval(Modulo(InfiniteIntegerLiteral(1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(1))
-  }
-
-  test("eval of simple arithmetic comparisons over integers") {
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7))), BooleanLiteral(false)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7))), BooleanLiteral(false)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7))), BooleanLiteral(true)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7))), BooleanLiteral(true)
-    )
-  }
-
-
-  test("Eval of division and remainder semantics for bit vectors") {
-    expectSuccessful(
-      defaultEvaluator.eval(BVDivision(IntLiteral(10), IntLiteral(3))), 
-      IntLiteral(3))
-    expectSuccessful(
-      defaultEvaluator.eval(BVRemainder(IntLiteral(10), IntLiteral(3))), 
-      IntLiteral(1))
-
-    expectSuccessful(
-      defaultEvaluator.eval(BVDivision(IntLiteral(-1), IntLiteral(3))), 
-      IntLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(BVRemainder(IntLiteral(-1), IntLiteral(3))), 
-      IntLiteral(-1))
-
-    expectSuccessful(
-      defaultEvaluator.eval(BVDivision(IntLiteral(-1), IntLiteral(-3))), 
-      IntLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(BVRemainder(IntLiteral(-1), IntLiteral(-3))), 
-      IntLiteral(-1))
-
-    expectSuccessful(
-      defaultEvaluator.eval(BVDivision(IntLiteral(1), IntLiteral(-3))), 
-      IntLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(BVRemainder(IntLiteral(1), IntLiteral(-3))), 
-      IntLiteral(1))
-  }
-
-  test("Eval of simple boolean operations") {
-    expectSuccessful(
-      defaultEvaluator.eval(And(BooleanLiteral(true), BooleanLiteral(true))),
-      BooleanLiteral(true))
-    expectSuccessful(
-      defaultEvaluator.eval(And(BooleanLiteral(true), BooleanLiteral(false))),
-      BooleanLiteral(false))
-    expectSuccessful(
-      defaultEvaluator.eval(And(BooleanLiteral(false), BooleanLiteral(false))),
-      BooleanLiteral(false))
-    expectSuccessful(
-      defaultEvaluator.eval(And(BooleanLiteral(false), BooleanLiteral(true))),
-      BooleanLiteral(false))
-    expectSuccessful(
-      defaultEvaluator.eval(Or(BooleanLiteral(true), BooleanLiteral(true))),
-      BooleanLiteral(true))
-    expectSuccessful(
-      defaultEvaluator.eval(Or(BooleanLiteral(true), BooleanLiteral(false))),
-      BooleanLiteral(true))
-    expectSuccessful(
-      defaultEvaluator.eval(Or(BooleanLiteral(false), BooleanLiteral(false))),
-      BooleanLiteral(false))
-    expectSuccessful(
-      defaultEvaluator.eval(Or(BooleanLiteral(false), BooleanLiteral(true))),
-      BooleanLiteral(true))
-    expectSuccessful(
-      defaultEvaluator.eval(Not(BooleanLiteral(false))),
-      BooleanLiteral(true))
-    expectSuccessful(
-      defaultEvaluator.eval(Not(BooleanLiteral(true))),
-      BooleanLiteral(false))
-  }
-
-  test("eval of simple arithmetic expressions over real") {
-    expectSuccessful(
-      defaultEvaluator.eval(RealPlus(RealLiteral(3), RealLiteral(5))), 
-      RealLiteral(8))
-    expectSuccessful(
-      defaultEvaluator.eval(RealMinus(RealLiteral(7), RealLiteral(2))), 
-      RealLiteral(5))
-    expectSuccessful(
-      defaultEvaluator.eval(RealUMinus(RealLiteral(7))),
-      RealLiteral(-7))
-    expectSuccessful(
-      defaultEvaluator.eval(RealTimes(RealLiteral(2), RealLiteral(3))), 
-      RealLiteral(6))
-
-    expectSuccessful(
-      defaultEvaluator.eval(RealPlus(RealLiteral(2.5), RealLiteral(3.5))), 
-      RealLiteral(6))
-  }
-
-  test("eval of simple arithmetic comparisons over real") {
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(RealLiteral(7), RealLiteral(4))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(RealLiteral(7), RealLiteral(7))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(RealLiteral(4), RealLiteral(7))), BooleanLiteral(false)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(RealLiteral(7), RealLiteral(4))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(RealLiteral(7), RealLiteral(7))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(RealLiteral(4), RealLiteral(7))), BooleanLiteral(false)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(RealLiteral(7), RealLiteral(4))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(RealLiteral(7), RealLiteral(7))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(RealLiteral(4), RealLiteral(7))), BooleanLiteral(true)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(RealLiteral(7), RealLiteral(4))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(RealLiteral(7), RealLiteral(7))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(RealLiteral(4), RealLiteral(7))), BooleanLiteral(true)
-    )
-  }
-
-  test("eval simple variable") {
-    val id = FreshIdentifier("id", Int32Type)
-    expectSuccessful(
-      defaultEvaluator.eval(Variable(id), Map(id -> IntLiteral(23))),
-      IntLiteral(23))
-  }
-
-  test("eval with unbound variable should return EvaluatorError") {
-    val id = FreshIdentifier("id", Int32Type)
-    val foo = FreshIdentifier("foo", Int32Type)
-    val res = defaultEvaluator.eval(Variable(id), Map(foo -> IntLiteral(23)))
-    assert(res.isInstanceOf[EvaluationResults.EvaluatorError])
-  }
-
-  test("eval let expression") {
-    val id = FreshIdentifier("id")
-    expectSuccessful(
-      defaultEvaluator.eval(Let(id, IntLiteral(42), Variable(id))),
-      IntLiteral(42))
-  }
-
-
-  test("eval literal array ops") {
-    expectSuccessful(
-      defaultEvaluator.eval(finiteArray(Map[Int,Expr](), Some(IntLiteral(12), IntLiteral(7)), Int32Type)),
-      finiteArray(Map[Int,Expr](), Some(IntLiteral(12), IntLiteral(7)), Int32Type))
-    expectSuccessful(
-      defaultEvaluator.eval(
-        ArrayLength(finiteArray(Map[Int,Expr](), Some(IntLiteral(12), IntLiteral(7)), Int32Type))),
-      IntLiteral(7))
-    expectSuccessful(
-      defaultEvaluator.eval(ArraySelect(
-        finiteArray(Seq(IntLiteral(2), IntLiteral(4), IntLiteral(7))),
-        IntLiteral(1))),
-      IntLiteral(4))
-    expectSuccessful(
-      defaultEvaluator.eval(
-        ArrayUpdated(
-          finiteArray(Seq(IntLiteral(2), IntLiteral(4), IntLiteral(7))),
-          IntLiteral(1),
-          IntLiteral(42))),
-      finiteArray(Seq(IntLiteral(2), IntLiteral(42), IntLiteral(7))))
-  }
-
-  test("eval variable length of array") {
-    val id = FreshIdentifier("id", Int32Type)
-    expectSuccessful(
-      defaultEvaluator.eval(
-        ArrayLength(
-          finiteArray(Map[Int, Expr](), Some(IntLiteral(12), Variable(id)), Int32Type)),
-        Map(id -> IntLiteral(27))),
-      IntLiteral(27))
-  }
-
-  test("eval variable default value of array") {
-    val id = FreshIdentifier("id", Int32Type)
-    expectSuccessful(
-      defaultEvaluator.eval(
-        finiteArray(Map[Int, Expr](), Some(Variable(id), IntLiteral(7)), Int32Type),
-        Map(id -> IntLiteral(27))),
-      finiteArray(Map[Int, Expr](), Some(IntLiteral(27), IntLiteral(7)), Int32Type))
-  }
-
-}
diff --git a/src/test/scala/leon/test/evaluators/EvaluatorSuite.scala b/src/test/scala/leon/test/evaluators/EvaluatorSuite.scala
index 10722f1b026bc9c11527f1e5f55c7c99d76a00d2..7a6dce5209f5f98e3c496e4a2c2c497c7767045b 100644
--- a/src/test/scala/leon/test/evaluators/EvaluatorSuite.scala
+++ b/src/test/scala/leon/test/evaluators/EvaluatorSuite.scala
@@ -1,703 +1,309 @@
 /* Copyright 2009-2015 EPFL, Lausanne */
 
-package leon.test.evaluators
+package leon.test.allEvaluators
 
 import leon._
-import leon.evaluators._ 
+import leon.test._
+import leon.evaluators._
 
 import leon.utils.{TemporaryInputPhase, PreprocessingPhase}
 import leon.frontends.scalac.ExtractionPhase
 
+import leon.purescala.Common._
 import leon.purescala.Definitions._
 import leon.purescala.Expressions._
 import leon.purescala.DefOps._
 import leon.purescala.Types._
 import leon.purescala.Extractors._
 import leon.purescala.Constructors._
+import leon.codegen._
 
-class EvaluatorSuite extends leon.test.LeonTestSuite {
-  private implicit lazy val leonContext = testContext
+class EvaluatorSuite extends LeonTestSuite with helpers.ExpressionsDSL {
 
-  private val evaluatorConstructors : List[(LeonContext,Program)=>Evaluator] = List(
-    new DefaultEvaluator(_,_),
-    new CodeGenEvaluator(_,_)
-  )
+  implicit val pgm = Program.empty
 
-  private def prepareEvaluators(implicit ctx : LeonContext, prog : Program) : List[Evaluator] = evaluatorConstructors.map(c => c(leonContext, prog))
-
-  private def parseString(str : String) : Program = {
-    val pipeline = TemporaryInputPhase andThen ExtractionPhase andThen PreprocessingPhase
-
-    val errorsBefore   = leonContext.reporter.errorCount
-
-    val program = pipeline.run(leonContext)((str, Nil))
+  def normalEvaluators(implicit ctx: LeonContext, pgm: Program): List[Evaluator] = {
+    List(
+      new DefaultEvaluator(ctx, pgm)
+    )
+  }
 
-    assert(leonContext.reporter.errorCount   === errorsBefore)
+  def codegenEvaluators(implicit ctx: LeonContext, pgm: Program): List[Evaluator] = {
+    List(
+      new CodeGenEvaluator(ctx, pgm)
+    )
+  }
 
-    program
+  def allEvaluators(implicit ctx: LeonContext, pgm: Program): List[Evaluator] = {
+    normalEvaluators ++ codegenEvaluators
   }
 
-  private def mkCall(name : String, args : Expr*)(implicit p : Program) = {
-    val fn = s"Program.$name"
 
-    p.lookup(fn) match {
-      case Some(fd: FunDef) =>
-        FunctionInvocation(fd.typed, args.toSeq)
-      case _ =>
-        throw new AssertionError(s"No function named '$fn' defined in program.")
+  test("Literals") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, BooleanLiteral(true))         === BooleanLiteral(true)
+      eval(e, BooleanLiteral(false))        === BooleanLiteral(false)
+      eval(e, IntLiteral(0))                === IntLiteral(0)
+      eval(e, IntLiteral(42))               === IntLiteral(42)
+      eval(e, UnitLiteral())                === UnitLiteral()
+      eval(e, InfiniteIntegerLiteral(0))    === InfiniteIntegerLiteral(0)
+      eval(e, InfiniteIntegerLiteral(42))   === InfiniteIntegerLiteral(42)
+      eval(e, RealLiteral(0))               === RealLiteral(0)
+      eval(e, RealLiteral(42))              === RealLiteral(42)
+      eval(e, RealLiteral(13.255))          === RealLiteral(13.255)
     }
   }
 
-  private def mkCaseClass(name : String, args : Expr*)(implicit p : Program) = {
-    p.lookup("Program."+name) match {
-      case Some(ccd: CaseClassDef) =>
-        CaseClass(CaseClassType(ccd, Nil), args.toSeq)
-      case _ =>
-        throw new AssertionError(s"No case class named '$name' defined in program.")
+  test("BitVector Arithmetic") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, BVPlus(IntLiteral(3), IntLiteral(5)))  === IntLiteral(8)
+      eval(e, BVPlus(IntLiteral(0), IntLiteral(5)))  === IntLiteral(5)
+      eval(e, BVTimes(IntLiteral(3), IntLiteral(3))) === IntLiteral(9)
     }
   }
 
-  private def checkCompSuccess(evaluator : Evaluator, in : Expr) : Expr = {
-    import EvaluationResults._
+  test("eval bitwise operations") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, BVAnd(IntLiteral(3), IntLiteral(1))) === IntLiteral(1)
+      eval(e, BVAnd(IntLiteral(3), IntLiteral(3))) === IntLiteral(3)
+      eval(e, BVAnd(IntLiteral(5), IntLiteral(3))) === IntLiteral(1)
+      eval(e, BVAnd(IntLiteral(5), IntLiteral(4))) === IntLiteral(4)
+      eval(e, BVAnd(IntLiteral(5), IntLiteral(2))) === IntLiteral(0)
 
-    evaluator.eval(in) match {
-      case RuntimeError(msg) =>
-        throw new AssertionError(s"Evaluation of '$in' with evaluator '${evaluator.name}' should have succeeded, but it failed ($msg).")
+      eval(e, BVOr(IntLiteral(3), IntLiteral(1))) === IntLiteral(3)
+      eval(e, BVOr(IntLiteral(3), IntLiteral(3))) === IntLiteral(3)
+      eval(e, BVOr(IntLiteral(5), IntLiteral(3))) === IntLiteral(7)
+      eval(e, BVOr(IntLiteral(5), IntLiteral(4))) === IntLiteral(5)
+      eval(e, BVOr(IntLiteral(5), IntLiteral(2))) === IntLiteral(7)
 
-      case EvaluatorError(msg) =>
-        throw new AssertionError(s"Evaluation of '$in' with evaluator '${evaluator.name}' should have succeeded, but the evaluator had an internal error ($msg).")
+      eval(e, BVXOr(IntLiteral(3), IntLiteral(1))) === IntLiteral(2)
+      eval(e, BVXOr(IntLiteral(3), IntLiteral(3))) === IntLiteral(0)
 
-      case Successful(result) =>
-        result
-    }
-  }
+      eval(e, BVNot(IntLiteral(1))) === IntLiteral(-2)
 
-  private def checkComp(evaluator : Evaluator, in : Expr, out : Expr) {
-    val result = checkCompSuccess(evaluator, in)
-    if(result != out)
-      throw new AssertionError(s"Evaluation of '$in' with evaluator '${evaluator.name}' should have produced '$out' but produced '$result' instead.")
-  }
+      eval(e, BVShiftLeft(IntLiteral(3), IntLiteral(1))) === IntLiteral(6)
+      eval(e, BVShiftLeft(IntLiteral(4), IntLiteral(2))) === IntLiteral(16)
 
-  private def checkSetComp(evaluator : Evaluator, in : Expr, out : Set[Int]) {
-    val result = checkCompSuccess(evaluator, in)
-
-    def asIntSet(e : Expr) : Option[Set[Int]] = e match {
-      case FiniteSet(es, _) =>
-        val ois = es.map {
-          case IntLiteral(v) => Some(v)
-          case _ => None
-        }
-        if(ois.forall(_.isDefined))
-          Some(ois.map(_.get))
-        else
-          None
-      case _ => None
+      eval(e, BVLShiftRight(IntLiteral(8), IntLiteral(1))) === IntLiteral(4)
+      eval(e, BVAShiftRight(IntLiteral(8), IntLiteral(1))) === IntLiteral(4)
     }
+  }
 
-    asIntSet(result) match {
-      case Some(s) if s == out =>
-        ;
-
-      case _ =>
-        throw new AssertionError(s"Evaluation of '$in' with evaluator '${evaluator.name}' should have produced a set '$out', but it produced '$result' instead.")
+  test("Arithmetic") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, Plus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(5)))  === InfiniteIntegerLiteral(8)
+      eval(e, Minus(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(2))) === InfiniteIntegerLiteral(5)
+      eval(e, UMinus(InfiniteIntegerLiteral(7)))                           === InfiniteIntegerLiteral(-7)
+      eval(e, Times(InfiniteIntegerLiteral(2), InfiniteIntegerLiteral(3))) === InfiniteIntegerLiteral(6)
     }
   }
 
-  private def checkMapComp(evaluator : Evaluator, in : Expr, out : Map[Int,Int]) {
-    val result = checkCompSuccess(evaluator, in)
-
-    def asIntMap(e : Expr) : Option[Map[Int,Int]] = e match {
-      case FiniteMap(ss, _, _) =>
-        val oips : Seq[Option[(Int,Int)]] = ss.map {
-          case (IntLiteral(f), IntLiteral(t)) => Some(f -> t)
-          case _ => None
-        }
-        if(oips.forall(_.isDefined))
-          Some(oips.map(_.get).toMap)
-        else
-          None
-      case _ => None
-    }
+  test("BigInt Modulo and Remainder") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, Division(InfiniteIntegerLiteral(10), InfiniteIntegerLiteral(3)))   === InfiniteIntegerLiteral(3)
+      eval(e, Remainder(InfiniteIntegerLiteral(10), InfiniteIntegerLiteral(3)))  === InfiniteIntegerLiteral(1)
+      eval(e, Modulo(InfiniteIntegerLiteral(10), InfiniteIntegerLiteral(3)))     === InfiniteIntegerLiteral(1)
+
+      eval(e, Division(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(3)))   === InfiniteIntegerLiteral(0)
+      eval(e, Remainder(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(3)))  === InfiniteIntegerLiteral(-1)
+
+      eval(e, Modulo(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(3)))     === InfiniteIntegerLiteral(2)
 
-    asIntMap(result) match {
-      case Some(s) if s == out =>
-        ;
+      eval(e, Division(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(-3)))  === InfiniteIntegerLiteral(0)
+      eval(e, Remainder(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(-3))) === InfiniteIntegerLiteral(-1)
+      eval(e, Modulo(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(-3)))    === InfiniteIntegerLiteral(2)
 
-      case _ =>
-        throw new AssertionError(s"Evaluation of '$in' with evaluator '${evaluator.name}' should produced a map '$out', but it produced '$result' instead.")
+      eval(e, Division(InfiniteIntegerLiteral(1), InfiniteIntegerLiteral(-3)))   === InfiniteIntegerLiteral(0)
+      eval(e, Remainder(InfiniteIntegerLiteral(1), InfiniteIntegerLiteral(-3)))  === InfiniteIntegerLiteral(1)
+      eval(e, Modulo(InfiniteIntegerLiteral(1), InfiniteIntegerLiteral(-3)))     === InfiniteIntegerLiteral(1)
     }
   }
 
-  private def checkError(evaluator : Evaluator, in : Expr) {
-    import EvaluationResults._
+  test("Int Comparisons") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, GreaterEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4)))  === BooleanLiteral(true)
+      eval(e, GreaterEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7)))  === BooleanLiteral(true)
+      eval(e, GreaterEquals(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7)))  === BooleanLiteral(false)
 
-    evaluator.eval(in) match {
-      case EvaluatorError(msg) =>
-        throw new AssertionError(s"Evaluation of '$in' with evaluator '${evaluator.name}' should have failed, but it produced an internal error ($msg).")
+      eval(e, GreaterThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4)))    === BooleanLiteral(true)
+      eval(e, GreaterThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7)))    === BooleanLiteral(false)
+      eval(e, GreaterThan(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7)))    === BooleanLiteral(false)
 
-      case Successful(result) =>
-        throw new AssertionError(s"Evaluation of '$in' with evaluator '${evaluator.name}' should have failed, but it produced the result '$result' instead.")
+      eval(e, LessEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4)))     === BooleanLiteral(false)
+      eval(e, LessEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7)))     === BooleanLiteral(true)
+      eval(e, LessEquals(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7)))     === BooleanLiteral(true)
 
-      case RuntimeError(_) =>
-        // that's the desired outcome
+      eval(e, LessThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4)))       === BooleanLiteral(false)
+      eval(e, LessThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7)))       === BooleanLiteral(false)
+      eval(e, LessThan(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7)))       === BooleanLiteral(true)
     }
   }
 
-  private def checkEvaluatorError(evaluator : Evaluator, in : Expr) {
-    import EvaluationResults._
 
-    evaluator.eval(in) match {
-      case RuntimeError(msg) =>
-        throw new AssertionError(s"Evaluation of '$in' with evaluator '${evaluator.name}' should have produced an internal error, but it failed instead ($msg).")
+  test("Int Modulo and Remainder") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, BVDivision(IntLiteral(10), IntLiteral(3)))    === IntLiteral(3)
+      eval(e, BVRemainder(IntLiteral(10), IntLiteral(3)))   === IntLiteral(1)
 
-      case Successful(result) =>
-        throw new AssertionError(s"Evaluation of '$in' with evaluator '${evaluator.name}' should have produced an internal error, but it produced the result '$result' instead.")
+      eval(e, BVDivision(IntLiteral(-1), IntLiteral(3)))    === IntLiteral(0)
+      eval(e, BVRemainder(IntLiteral(-1), IntLiteral(3)))   === IntLiteral(-1)
 
-      case EvaluatorError(_) =>
-        // that's the desired outcome
-    }
-  }
+      eval(e, BVDivision(IntLiteral(-1), IntLiteral(-3)))   === IntLiteral(0)
+      eval(e, BVRemainder(IntLiteral(-1), IntLiteral(-3)))  === IntLiteral(-1)
 
-  private val T = BooleanLiteral(true)
-  private val F = BooleanLiteral(false)
-  import purescala.Expressions.{IntLiteral => IL, InfiniteIntegerLiteral => BIL, RealLiteral => RL}
-
-  test("Arithmetic") {
-    val p = """|object Program {
-               |  def plus(x : Int, y : Int) : Int = x + y
-               |  def max(x : Int, y : Int) : Int = if(x >= y) x else y
-               |  def square(i : Int) : Int = { val j = i; j * i }
-               |  def abs(i : Int) : Int = if(i < 0) -i else i
-               |  def intSqrt(n : Int) : Int = intSqrt0(abs(n), 0)
-               |  def intSqrt0(n : Int, c : Int) : Int = {
-               |    val s = square(c+1)
-               |    if(s > n) c else intSqrt0(n, c+1)
-               |  }
-               |  def div(x : Int, y : Int) : Int = (x / y)
-               |  def rem(x : Int, y : Int) : Int = (x % y)
-               |}
-               |""".stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-
-    for(e <- evaluators) {
-      // Some simple math.
-      checkComp(e, mkCall("plus", IL(60), BVUMinus(IL(18))), IL(42))
-      checkComp(e, mkCall("max", IL(4), IL(42)), IL(42))
-      checkComp(e, mkCall("max", IL(42), BVUMinus(IL(42))), IL(42))
-      checkComp(e, mkCall("intSqrt", BVUMinus(IL(1800))), IL(42))
-      checkComp(e, mkCall("div", IL(7), IL(5)), IL(1))
-      checkComp(e, mkCall("div", IL(7), IL(-5)), IL(-1))
-      checkComp(e, mkCall("div", IL(-7), IL(5)), IL(-1))
-      checkComp(e, mkCall("div", IL(-7), IL(-5)), IL(1))
-      checkComp(e, mkCall("rem", IL(7), IL(5)), IL(2))
-      checkComp(e, mkCall("rem", IL(7), IL(-5)), IL(2))
-      checkComp(e, mkCall("rem", IL(-7), IL(5)), IL(-2))
-      checkComp(e, mkCall("rem", IL(-7), IL(-5)), IL(-2))
-      checkComp(e, mkCall("rem", IL(-1), IL(5)), IL(-1))
-
-      // Things that should crash.
-      checkError(e, mkCall("div", IL(42), IL(0))) 
-      checkError(e, mkCall("rem", IL(42), IL(0)))
+      eval(e, BVDivision(IntLiteral(1), IntLiteral(-3)))    === IntLiteral(0)
+      eval(e, BVRemainder(IntLiteral(1), IntLiteral(-3)))   === IntLiteral(1)
     }
   }
 
-  test("BigInt Arithmetic") {
-    val p = """|object Program {
-               |  def plus(x : BigInt, y : BigInt) : BigInt = x + y
-               |  def max(x : BigInt, y : BigInt) : BigInt = if(x >= y) x else y
-               |  def square(i : BigInt) : BigInt = { val j = i; j * i }
-               |  def abs(i : BigInt) : BigInt = if(i < 0) -i else i
-               |  def intSqrt(n : BigInt) : BigInt = intSqrt0(abs(n), 0)
-               |  def intSqrt0(n : BigInt, c : BigInt) : BigInt = {
-               |    val s = square(c+1)
-               |    if(s > n) c else intSqrt0(n, c+1)
-               |  }
-               |  def div(x : BigInt, y : BigInt) : BigInt = (x / y)
-               |  def rem(x : BigInt, y : BigInt) : BigInt = (x % y)
-               |  def mod(x : BigInt, y : BigInt) : BigInt = (x mod y)
-               |}
-               |""".stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-
-    for(e <- evaluators) {
-      // Some simple math.
-      checkComp(e, mkCall("plus", BIL(60), UMinus(BIL(18))), BIL(42))
-      checkComp(e, mkCall("max", BIL(4), BIL(42)), BIL(42))
-      checkComp(e, mkCall("max", BIL(42), UMinus(BIL(42))), BIL(42))
-      checkComp(e, mkCall("intSqrt", UMinus(BIL(1800))), BIL(42))
-      checkComp(e, mkCall("div", BIL(7), BIL(5)), BIL(1))
-      checkComp(e, mkCall("div", BIL(7), BIL(-5)), BIL(-1))
-      checkComp(e, mkCall("div", BIL(-7), BIL(5)), BIL(-1))
-      checkComp(e, mkCall("div", BIL(-7), BIL(-5)), BIL(1))
-      checkComp(e, mkCall("rem", BIL(7), BIL(5)), BIL(2))
-      checkComp(e, mkCall("rem", BIL(7), BIL(-5)), BIL(2))
-      checkComp(e, mkCall("rem", BIL(-7), BIL(5)), BIL(-2))
-      checkComp(e, mkCall("rem", BIL(-7), BIL(-5)), BIL(-2))
-      checkComp(e, mkCall("rem", BIL(-1), BIL(5)), BIL(-1))
-      checkComp(e, mkCall("mod", BIL(7), BIL(5)), BIL(2))
-      checkComp(e, mkCall("mod", BIL(7), BIL(-5)), BIL(2))
-      checkComp(e, mkCall("mod", BIL(-7), BIL(5)), BIL(3))
-      checkComp(e, mkCall("mod", BIL(-7), BIL(-5)), BIL(3))
-      checkComp(e, mkCall("mod", BIL(-1), BIL(5)), BIL(4))
-
-      // Things that should crash.
-      checkError(e, mkCall("div", BIL(42), BIL(0))) 
-      checkError(e, mkCall("rem", BIL(42), BIL(0)))
-      checkError(e, mkCall("mod", BIL(42), BIL(0)))
+  test("Boolean Operations") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, And(BooleanLiteral(true), BooleanLiteral(true)))      === BooleanLiteral(true)
+      eval(e, And(BooleanLiteral(true), BooleanLiteral(false)))     === BooleanLiteral(false)
+      eval(e, And(BooleanLiteral(false), BooleanLiteral(false)))    === BooleanLiteral(false)
+      eval(e, And(BooleanLiteral(false), BooleanLiteral(true)))     === BooleanLiteral(false)
+      eval(e, Or(BooleanLiteral(true), BooleanLiteral(true)))       === BooleanLiteral(true)
+      eval(e, Or(BooleanLiteral(true), BooleanLiteral(false)))      === BooleanLiteral(true)
+      eval(e, Or(BooleanLiteral(false), BooleanLiteral(false)))     === BooleanLiteral(false)
+      eval(e, Or(BooleanLiteral(false), BooleanLiteral(true)))      === BooleanLiteral(true)
+      eval(e, Not(BooleanLiteral(false)))                           === BooleanLiteral(true)
+      eval(e, Not(BooleanLiteral(true)))                            === BooleanLiteral(false)
     }
   }
 
-  test("Real Arithmetic") {
-    val p = """|import leon.lang._
-               |object Program {
-               |  def plus(x : Real, y : Real) : Real = x + y
-               |  def max(x : Real, y : Real) : Real = if(x >= y) x else y
-               |  def square(i : Real) : Real = { val j = i; j * i }
-               |  def abs(i : Real) : Real = if(i < Real(0)) -i else i
-               |  def intSqrt(n : Real) : Real = intSqrt0(abs(n), Real(0))
-               |  def intSqrt0(n : Real, c : Real) : Real = {
-               |    val s = square(c+Real(1))
-               |    if(s > n) c else intSqrt0(n, c+Real(1))
-               |  }
-               |  def div(x : Real, y : Real) : Real = (x / y)
-               |}
-               |""".stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-
-    for(e <- evaluators) {
-      // Some simple math.
-      checkComp(e, mkCall("plus", RL(60), RealUMinus(RL(18))), RL(42))
-      checkComp(e, mkCall("max", RL(4), RL(42)), RL(42))
-      checkComp(e, mkCall("max", RL(42), RealUMinus(RL(42))), RL(42))
-      checkComp(e, mkCall("intSqrt", RealUMinus(RL(1800))), RL(42))
-      checkComp(e, mkCall("div", RL(7), RL(7)), RL(1))
-      checkComp(e, mkCall("div", RL(5), RL(2)), RL(2.5))
-
-      // Things that should crash.
-      checkError(e, mkCall("div", RL(42), RL(0))) 
+  test("Real Arightmetic") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, RealPlus(RealLiteral(3), RealLiteral(5)))     === RealLiteral(8)
+      eval(e, RealMinus(RealLiteral(7), RealLiteral(2)))    === RealLiteral(5)
+      eval(e, RealUMinus(RealLiteral(7)))                   === RealLiteral(-7)
+      eval(e, RealTimes(RealLiteral(2), RealLiteral(3)))    === RealLiteral(6)
+      eval(e, RealPlus(RealLiteral(2.5), RealLiteral(3.5))) === RealLiteral(6)
     }
   }
 
-  test("Booleans") {
-    val p = """|object Program {
-               |def and1(x : Boolean, y : Boolean) : Boolean = x && y
-               |def or1(x : Boolean, y : Boolean)  : Boolean = x || y
-               |def and2(x : Boolean, y : Boolean) : Boolean = !(!x || !y)
-               |def or2(x : Boolean, y : Boolean)  : Boolean = !(!x && !y)
-               |def safe(n : Int) : Boolean = (n != 0 && (1/n == n))
-               |def mkTrue() : Boolean = true
-               |def mkFalse() : Boolean = false
-               |}""".stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-
-    for(e <- evaluators) {
-      checkComp(e, mkCall("and1", F, F), F)
-      checkComp(e, mkCall("and1", F, T), F)
-      checkComp(e, mkCall("and1", T, F), F)
-      checkComp(e, mkCall("and1", T, T), T)
-      checkComp(e, mkCall("and2", F, F), F)
-      checkComp(e, mkCall("and2", F, T), F)
-      checkComp(e, mkCall("and2", T, F), F)
-      checkComp(e, mkCall("and2", T, T), T)
-      checkComp(e, mkCall("or1", F, F), F)
-      checkComp(e, mkCall("or1", F, T), T)
-      checkComp(e, mkCall("or1", T, F), T)
-      checkComp(e, mkCall("or1", T, T), T)
-      checkComp(e, mkCall("or2", F, F), F)
-      checkComp(e, mkCall("or2", F, T), T)
-      checkComp(e, mkCall("or2", T, F), T)
-      checkComp(e, mkCall("or2", T, T), T)
-
-      checkComp(e, mkCall("safe", IL(1)), T)
-      checkComp(e, mkCall("safe", IL(2)), F)
-
-      // This one needs short-circuit.
-      checkComp(e, mkCall("safe", IL(0)), F)
-
-      // We use mkTrue/mkFalse to avoid automatic simplifications.
-      checkComp(e, Equals(mkCall("mkTrue"),  mkCall("mkTrue")),  T)
-      checkComp(e, Equals(mkCall("mkTrue"),  mkCall("mkFalse")), F)
-      checkComp(e, Equals(mkCall("mkFalse"), mkCall("mkTrue")),  F)
-      checkComp(e, Equals(mkCall("mkFalse"), mkCall("mkFalse")), T)
-
-      checkComp(e, Implies(mkCall("mkTrue"),  mkCall("mkTrue")),  T)
-      checkComp(e, Implies(mkCall("mkTrue"),  mkCall("mkFalse")), F)
-      checkComp(e, Implies(mkCall("mkFalse"), mkCall("mkTrue")),  T)
-      checkComp(e, Implies(mkCall("mkFalse"), mkCall("mkFalse")), T)
-    }
-  }
+  test("Real Comparisons") { implicit fix =>
+    for(e <- allEvaluators) {
+      eval(e, GreaterEquals(RealLiteral(7), RealLiteral(4))) === BooleanLiteral(true)
+      eval(e, GreaterEquals(RealLiteral(7), RealLiteral(7))) === BooleanLiteral(true)
+      eval(e, GreaterEquals(RealLiteral(4), RealLiteral(7))) === BooleanLiteral(false)
 
-  test("Case classes") {
-    val p = """|object Program {
-               |  sealed abstract class List
-               |  case class Nil() extends List
-               |  case class Cons(head : Int, tail : List) extends List
-               |
-               |  case class MySingleton(i : Int)
-               |
-               |  def size(l : List) : Int = l match {
-               |    case Nil() => 0
-               |    case Cons(_, xs) => 1 + size(xs)
-               |  }
-               |
-               |  def compare(l1 : List, l2 : List) : Boolean = (l1 == l2)
-               |
-               |  def head(l : List) : Int = l match {
-               |    case Cons(h, _) => h
-               |  }
-               |
-               |  def wrap(i : Int) : MySingleton = MySingleton(i)
-               |}""".stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-
-    val nil = mkCaseClass("Nil")
-    val cons12a = mkCaseClass("Cons", IL(1), mkCaseClass("Cons", IL(2), mkCaseClass("Nil")))
-    val cons12b = mkCaseClass("Cons", IL(1), mkCaseClass("Cons", IL(2), mkCaseClass("Nil")))
-    val sing1 = mkCaseClass("MySingleton", IL(1))
-
-    for(e <- evaluators) {
-      checkComp(e, mkCall("size", nil), IL(0))
-      checkComp(e, mkCall("size", cons12a), IL(2))
-      checkComp(e, mkCall("compare", nil, cons12a), F)
-      checkComp(e, mkCall("compare", cons12a, cons12b), T)
-      checkComp(e, mkCall("head", cons12a), IL(1))
-
-      checkComp(e, Equals(mkCall("wrap", IL(1)), sing1), T)
-
-      // Match error
-      checkError(e, mkCall("head", nil))
-    }
-  }
+      eval(e, GreaterThan(RealLiteral(7), RealLiteral(4)))  === BooleanLiteral(true)
+      eval(e, GreaterThan(RealLiteral(7), RealLiteral(7)))  === BooleanLiteral(false)
+      eval(e, GreaterThan(RealLiteral(4), RealLiteral(7)))  === BooleanLiteral(false)
 
-  test("Sets") {
-    val p = """|import leon.lang._
-               |object Program {
-               |  sealed abstract class List
-               |  case class Nil() extends List
-               |  case class Cons(head : Int, tail : List) extends List
-               |
-               |  def content(l : List) : Set[Int] = l match {
-               |    case Nil() => Set.empty[Int]
-               |    case Cons(x, xs) => Set(x) ++ content(xs)
-               |  }
-               |
-               |  def finite() : Set[Int] = Set(1, 2, 3)
-               |  def build(x : Int, y : Int, z : Int) : Set[Int] = Set(x, y, z)
-               |  def union(s1 : Set[Int], s2 : Set[Int]) : Set[Int] = s1 ++ s2
-               |  def inter(s1 : Set[Int], s2 : Set[Int]) : Set[Int] = s1 & s2
-               |  def diff(s1 : Set[Int], s2 : Set[Int]) : Set[Int] = s1 -- s2
-               |}""".stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-
-    val nil = mkCaseClass("Nil")
-    val cons12 = mkCaseClass("Cons", IL(1), mkCaseClass("Cons", IL(2), mkCaseClass("Nil")))
-
-    val s123 = FiniteSet(Set(IL(1), IL(2), IL(3)), Int32Type)
-    val s246 = FiniteSet(Set(IL(2), IL(4), IL(6)), Int32Type)
-
-    for(e <- evaluators) {
-      checkSetComp(e, mkCall("finite"), Set(1, 2, 3))
-      checkSetComp(e, mkCall("content", nil), Set.empty)
-      checkSetComp(e, mkCall("content", cons12), Set(1,2))
-      checkSetComp(e, mkCall("build", IL(1), IL(2), IL(3)), Set(1,2,3))
-      checkSetComp(e, mkCall("build", IL(1), IL(2), IL(2)), Set(1,2))
-      checkSetComp(e, mkCall("union", s123, s246), Set(1,2,3,4,6))
-      checkSetComp(e, mkCall("union", s246, s123), Set(1,2,3,4,6))
-      checkComp(e, Equals(mkCall("union", s123, s246), mkCall("union", s246, s123)), T)
-      checkSetComp(e, mkCall("inter", s123, s246), Set(2))
-      checkSetComp(e, mkCall("inter", s246, s123), Set(2))
-      checkComp(e, Equals(mkCall("inter", s123, s246), mkCall("inter", s246, s123)), T)
-      checkSetComp(e, mkCall("diff", s123, s246), Set(1,3))
-      checkSetComp(e, mkCall("diff", s246, s123), Set(4,6))
-      checkComp(e, Equals(mkCall("diff", s123, s246), mkCall("diff", s246, s123)), F)
-    }
-  }
+      eval(e, LessEquals(RealLiteral(7), RealLiteral(4)))   === BooleanLiteral(false)
+      eval(e, LessEquals(RealLiteral(7), RealLiteral(7)))   === BooleanLiteral(true)
+      eval(e, LessEquals(RealLiteral(4), RealLiteral(7)))   === BooleanLiteral(true)
 
-  test("Maps") {
-    val p = """|import leon.lang._
-               |object Program {
-               |  sealed abstract class PList
-               |  case class PNil() extends PList
-               |  case class PCons(headfst : Int, headsnd : Int, tail : PList) extends PList
-               |
-               |  def toMap(pl : PList) : Map[Int,Int] = pl match {
-               |    case PNil() => Map.empty[Int,Int]
-               |    case PCons(f,s,xs) => toMap(xs).updated(f, s)
-               |  }
-               |
-               |  def finite0() : Map[Int,Int] = Map[Int, Int]()
-               |  def finite1() : Map[Int,Int] = Map(1 -> 2)
-               |  def finite2() : Map[Int,Int] = Map(2 -> 3, 1 -> 2)
-               |  def finite3() : Map[Int,Int] = finite1().updated(2, 3)
-               |}""".stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-
-    val cons1223 = mkCaseClass("PCons", IL(1), IL(2), mkCaseClass("PCons", IL(2), IL(3), mkCaseClass("PNil")))
-
-    for(e <- evaluators) {
-      checkMapComp(e, mkCall("finite0"), Map.empty)
-      checkMapComp(e, mkCall("finite1"), Map(1 -> 2))
-      checkMapComp(e, mkCall("finite2"), Map(1 -> 2, 2 -> 3))
-      checkComp(e, Equals(mkCall("finite1"), mkCall("finite2")), F)
-      checkComp(e, Equals(mkCall("finite2"), mkCall("finite3")), T)
-      checkMapComp(e, mkCall("toMap", cons1223), Map(1 -> 2, 2 -> 3))
-      checkComp(e, MapIsDefinedAt(mkCall("finite2"), IL(2)), T)
-      checkComp(e, MapIsDefinedAt(mkCall("finite2"), IL(3)), F)
+      eval(e, LessThan(RealLiteral(7), RealLiteral(4)))     === BooleanLiteral(false)
+      eval(e, LessThan(RealLiteral(7), RealLiteral(7)))     === BooleanLiteral(false)
+      eval(e, LessThan(RealLiteral(4), RealLiteral(7)))     === BooleanLiteral(true)
     }
   }
 
-  test("Arrays") {
-    val p = """|import leon.lang._
-               |object Program {
-               |  def boolArrayRead(bools : Array[Boolean], index : Int) : Boolean = bools(index)
-               |
-               |  def intArrayRead(ints : Array[Int], index : Int) : Int = ints(index)
-               |
-               |  def intArrayUpdate(ints : Array[Int], index : Int, value: Int) : Int = {
-               |    val na = ints.updated(index, value)
-               |    na(index)
-               |  }
-               |}
-               |""".stripMargin
-
-    implicit val progs = parseString(p)
-    val evaluators = prepareEvaluators
-    
-    val ba = finiteArray(Seq(T, F))
-    val ia = finiteArray(Seq(IL(41), IL(42), IL(43)))
-
-    for(e <- evaluators) {
-      checkComp(e, mkCall("boolArrayRead", ba, IL(0)), T)
-      checkComp(e, mkCall("boolArrayRead", ba, IL(1)), F)
-      checkComp(e, mkCall("intArrayRead", ia, IL(0)), IL(41))
-      checkComp(e, mkCall("intArrayRead", ia, IL(1)), IL(42))
-      checkComp(e, ArrayLength(ia), IL(3))
-
-      checkComp(e, mkCall("intArrayUpdate", ia, IL(0), IL(13)), IL(13))
-      checkComp(e, mkCall("intArrayUpdate", ia, IL(1), IL(17)), IL(17))
-
-      checkError(e, mkCall("boolArrayRead", ba, IL(2)))
+  test("Simple Variable") { implicit fix =>
+    for(e <- allEvaluators) {
+      val id = FreshIdentifier("id", Int32Type)
+
+      eval(e, Variable(id), Map(id -> IntLiteral(23))) === IntLiteral(23)
     }
   }
 
-  test("Sets and maps of structures") {
-    val p = """|import leon.lang._
-               |object Program {
-               |  case class MyPair(x : Int, y : Boolean)
-               |
-               |  def buildPairCC(x : Int, y : Boolean) : MyPair = MyPair(x,y)
-               |  def mkSingletonCC(p : MyPair) : Set[MyPair] = Set(p)
-               |  def containsCC(s : Set[MyPair], p : MyPair) : Boolean = s.contains(p)
-               |
-               |  def buildPairT(x : Int, y : Boolean) : (Int,Boolean) = (x,y)
-               |  def mkSingletonT(p : (Int,Boolean)) : Set[(Int,Boolean)] = Set(p)
-               |  def containsT(s : Set[(Int,Boolean)], p : (Int,Boolean)) : Boolean = s.contains(p)
-               |}""".stripMargin
-
-    implicit val progs = parseString(p)
-    val evaluators = prepareEvaluators
-
-    for(e <- evaluators) {
-      checkComp(e, mkCall("containsCC", mkCall("mkSingletonCC", mkCall("buildPairCC", IL(42), T)), mkCall("buildPairCC", IL(42), T)), T)
-      checkComp(e, mkCall("containsT", mkCall("mkSingletonT", mkCall("buildPairT", IL(42), T)), mkCall("buildPairT", IL(42), T)), T)
+  test("Undefined Variable") { implicit fix =>
+    for(e <- allEvaluators) {
+      val id = FreshIdentifier("id", Int32Type)
+      val foo = FreshIdentifier("foo", Int32Type)
+
+      eval(e, Variable(id), Map(foo -> IntLiteral(23))).failed
     }
   }
 
-  test("Executing Chooses") {
-    val p = """|import leon.lang._
-               |object Program {
-               |  import leon.lang._
-               |  import leon.lang.synthesis._
-               |
-               |  def c(i : Int) : Int = choose { (j : Int) => j > i && j < i + 2 }
-               |}
-               |""".stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-
-    for(e <- evaluators) {
-      checkComp(e, mkCall("c", IL(42)), IL(43))
+  test("Let") { implicit fix =>
+    for(e <- normalEvaluators) {
+      val id = FreshIdentifier("id")
+      eval(e, Let(id, IntLiteral(42), Variable(id))) === IntLiteral(42)
     }
   }
 
-  test("Infinite Recursion") {
-    import leon.codegen._
 
-    val p = """|import leon.lang._
-               |object Program {
-               |  import leon.lang._
-               |
-               |  def c(i : Int) : Int = c(i-1)
-               |}
-               |""".stripMargin
+  def eqArray(a1: Expr, a2: Expr) = (a1, a2) match {
+    case (FiniteArray(es1, d1, IntLiteral(l1)), FiniteArray(es2, d2, IntLiteral(l2))) =>
+      assert(l1 === l2)
+      for (i <- 0 until l1) {
+        val v1 = es1.get(i).orElse(d1)
+        val v2 = es2.get(i).orElse(d2)
+        assert(v1 === v2)
+      }
+    case (e, _) =>
+      fail("Expected array, got "+e)
+  }
 
-    implicit val prog = parseString(p)
+  test("Array Operations") { implicit fix =>
+    for (e <- allEvaluators) {
+      eqArray(eval(e, finiteArray(Map[Int,Expr](), Some(IntLiteral(12), IntLiteral(7)), Int32Type)).res,
+                      finiteArray(Map[Int,Expr](), Some(IntLiteral(12), IntLiteral(7)), Int32Type))
 
-    val e = new CodeGenEvaluator(leonContext, prog, CodeGenParams.default.copy(maxFunctionInvocations = 32))
-    checkEvaluatorError(e, mkCall("c", IL(42)))
-  }
+      eval(e, ArrayLength(finiteArray(Map[Int,Expr](), Some(IntLiteral(12), IntLiteral(7)), Int32Type))) ===
+                      IntLiteral(7)
 
-  test("Wrong Contracts") {
-    import leon.codegen._
+      eval(e, ArraySelect(finiteArray(Seq(IntLiteral(2), IntLiteral(4), IntLiteral(7))), IntLiteral(1))) ===
+                      IntLiteral(4)
 
-    val p = """|import leon.lang._
-               |object Program {
-               |  import leon.lang._
-               |
-               |  def c(i : Int) : Int = {
-               |    require(i > 0);
-               |    c(i-1)
-               |  }
-               |}
-               |""".stripMargin
+      eqArray(eval(e, ArrayUpdated( finiteArray(Seq(IntLiteral(2), IntLiteral(4), IntLiteral(7))), IntLiteral(1), IntLiteral(42))).res,
+                      finiteArray(Seq(IntLiteral(2), IntLiteral(42), IntLiteral(7))))
 
-    implicit val prog = parseString(p)
+    }
+  }
 
-    val e = new CodeGenEvaluator(leonContext, prog, CodeGenParams.default)
-    checkError(e, mkCall("c", IL(-42)))
+  test("Array with variable length") { implicit fix =>
+    // This does not work with CodegenEvaluator
+    for (e <- normalEvaluators) {
+      val len = FreshIdentifier("len", Int32Type)
+      eval(e, ArrayLength(finiteArray(Map[Int, Expr](), Some(IntLiteral(12), Variable(len)), Int32Type)), Map(len -> IntLiteral(27))) ===
+        IntLiteral(27)
+    }
   }
 
-  test("Pattern Matching") {
-    val p = """|import leon.lang._
-               |object Program {
-               |  abstract class List;
-               |  case class Cons(h: Int, t: List) extends List;
-               |  case object Nil extends List;
-               |
-               |  def f1: Int = (Cons(1, Nil): List) match {
-               |    case Cons(h, t) => h
-               |    case Nil => 0
-               |  }
-               |
-               |  def f2: Int = (Cons(1, Nil): List) match {
-               |    case Cons(h, _) => h
-               |    case Nil => 0
-               |  }
-               |
-               |  def f3: Int = (Nil: List) match {
-               |    case _ => 1
-               |  }
-               |
-               |  def f4: Int = (Cons(1, Cons(2, Nil)): List) match {
-               |    case a: Cons => 1
-               |    case _ => 0
-               |  }
-               |
-               |  def f5: Int = ((Cons(1, Nil), Nil): (List, List)) match {
-               |    case (a: Cons, _) => 1
-               |    case _ => 0
-               |  }
-               |
-               |  def f6: Int = (Cons(2, Nil): List) match {
-               |    case Cons(h, t) if h > 0 => 1
-               |    case _ => 0
-               |  }
-               |}""".stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-
-    for(e <- evaluators) {
-      // Some simple math.
-      checkComp(e, mkCall("f1"), IL(1))
-      checkComp(e, mkCall("f2"), IL(1))
-      checkComp(e, mkCall("f3"), IL(1))
-      checkComp(e, mkCall("f4"), IL(1))
-      checkComp(e, mkCall("f5"), IL(1))
-      checkComp(e, mkCall("f6"), IL(1))
+  test("Array Default Value") { implicit fix  =>
+    for (e <- allEvaluators) {
+      val id = FreshIdentifier("id", Int32Type)
+      eqArray(eval(e, finiteArray(Map[Int, Expr](), Some(Variable(id), IntLiteral(7)), Int32Type), Map(id -> IntLiteral(27))).res, 
+                      finiteArray(Map[Int, Expr](), Some(IntLiteral(27), IntLiteral(7)), Int32Type))
     }
   }
 
-  test("Lambda functions") {
-    val p = """import leon.lang._
-              |object Program {
-              |  val foo1 = (x: BigInt) => x
-              |  val foo2 = {
-              |    val a = BigInt(1)
-              |    (x: BigInt) => a + x
-              |  }
-              |  val foo3 = {
-              |    val f1 = (x: BigInt) => x + 1
-              |    val f2 = (x: BigInt) => x + 2
-              |    (x: BigInt, y: BigInt) => f1(x) + f2(y)
-              |  }
-              |  def foo4(x: BigInt) = (i: BigInt) => i + x
-              |}""".stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-
-    def checkLambda(evaluator: Evaluator, in: Expr, out: PartialFunction[Expr, Boolean]) {
-      val result = checkCompSuccess(evaluator, in)
-      if (!out.isDefinedAt(result) || !out(result))
-        throw new AssertionError(s"Evaluation of '$in' with evaluator '${evaluator.name}' produced invalid '$result'.")
+  abstract class EvalDSL {
+    def res: Expr
+    def ===(res: Expr): Unit
+    def failed: Unit = {}
+    def success: Expr = res
+  }
+
+  case class Success(expr: Expr, env: Map[Identifier, Expr], evaluator: Evaluator, res: Expr) extends EvalDSL {
+    override def failed = {
+      fail(s"Evaluation of '$expr' with '$evaluator' (and env $env) should have failed")
     }
 
-    val ONE = BIL(1)
-    val TWO = BIL(2)
+    def ===(exp: Expr) = {
+      assert(res === exp)
+    }
+  }
 
-    for(e <- evaluators) {
-      checkLambda(e, mkCall("foo1"), { case Lambda(Seq(vd), Variable(id)) if vd.id == id => true })
-      checkLambda(e, mkCall("foo2"), { case Lambda(Seq(vd), Plus(ONE, Variable(id))) if vd.id == id => true })
-      checkLambda(e, mkCall("foo3"), { case Lambda(Seq(vx, vy), Plus(Plus(Variable(x), ONE), Plus(Variable(y), TWO))) if vx.id == x && vy.id == y => true })
-      checkLambda(e, mkCall("foo4", TWO), { case Lambda(Seq(vd), Plus(Variable(id), TWO)) if vd.id == id => true })
+  case class Failed(expr: Expr, env: Map[Identifier, Expr], evaluator: Evaluator, err: String) extends EvalDSL {
+    override def success = {
+      fail(s"Evaluation of '$expr' with '$evaluator' (and env $env) should have succeeded but failed with $err")
     }
+
+    def res = success
+
+    def ===(res: Expr) = success
   }
 
-  test("Methods") {
-    val p =
-      """object Program {
-        |  abstract class A
-        |
-        |  abstract class B extends A {
-        |    def foo(i: BigInt) = {
-        |      require(i > 0)
-        |      i + 1
-        |    } ensuring ( _ >= 0 )
-        |  }
-        |
-        |  case class C(x: BigInt) extends B {
-        |    val y = BigInt(42)
-        |    override def foo(i: BigInt) = {
-        |      x + y + (if (i>0) i else -i)
-        |    } ensuring ( _ >= x )
-        |  }
-        |
-        |  case class D() extends A
-        |
-        |  def f1 = {
-        |    val c = C(42)
-        |    (if (c.foo(0) + c.x > 0) c else D()).isInstanceOf[B]
-        |  }
-        |  def f2 = D().isInstanceOf[B]
-        |  def f3 = C(42).isInstanceOf[A]
-        |}
-        |
-        |
-      """.stripMargin
-
-    implicit val prog = parseString(p)
-    val evaluators = prepareEvaluators
-    for(e <- evaluators) {
-      // Some simple math.
-      checkComp(e, mkCall("f1"), BooleanLiteral(true))
-      checkComp(e, mkCall("f2"), BooleanLiteral(false))
-      checkComp(e, mkCall("f3"), BooleanLiteral(true))
+  def eval(e: Evaluator, toEval: Expr, env: Map[Identifier, Expr] = Map()): EvalDSL = {
+    e.eval(toEval, env) match {
+      case EvaluationResults.Successful(res)     => Success(toEval, env, e, res)
+      case EvaluationResults.RuntimeError(err)   => Failed(toEval, env, e, err)
+      case EvaluationResults.EvaluatorError(err) => Failed(toEval, env, e, err)
     }
   }
 }
diff --git a/src/test/scala/leon/test/frontends/ImportsSuite.scala b/src/test/scala/leon/test/frontends/ImportsSuite.scala
deleted file mode 100644
index 8d1cdbbdb6a4cca0f5fe182226622d26afe86133..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/frontends/ImportsSuite.scala
+++ /dev/null
@@ -1,82 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.frontends
-
-import leon.test.LeonTestSuite
-import leon._
-import purescala.Definitions._
-import purescala.ScalaPrinter
-import frontends.scalac._
-import utils._
-
-class ImportsSuite extends LeonTestSuite {
-  private def parseStrings(strs : List[String]) : Program = {
-
-    val reporter = new DefaultReporter(Set())
-    val context : LeonContext = LeonContext(
-      reporter,
-      new InterruptManager(reporter),
-      Seq()
-    )
-    
-    val pipeline = 
-      ExtractionPhase andThen 
-      PreprocessingPhase 
-      
-    val inputs = strs map { str => TemporaryInputPhase.run(context)((str, Nil)).head }
-    val program = pipeline.run(testContext)(inputs)
-    
-    program
-  }
-  
-  // Print and reparse tests
-  private def testPrint(name : String, strs : List[String]) { test(name){
-    val orig = parseStrings(strs )
-    // FIXME This is just nonsense. What are we reparsing?
-    val output = orig.units map { ScalaPrinter(_) }
-    // If we can reparse, we consider it successful.
-    val after = parseStrings(strs)
-  }}
-  
-  val testPrint1 = ("testPrint1", List(
-    """ |package foo.bar.baz
-  	    |import other.hello.world.Foo._
-  	    |
-    		|object Bar {
-    		|  val x = 42
-    		|  abstract class A
-    		|  case class C(i : Int) extends A
-    		|}
-    		|
-    		|object Foo {
-    		|  import Bar.C
-    		|  case class FooC()
-    		|  val m = Bar.x + y + x
-    		|  val ? = C(m)
-    		|  val fooC = ? match {
-    		|    case C(i) if i == 0 => FooC()
-    		|    case _ => FooC()
-    		|  }
-    		|}""".stripMargin,
-	
-  	""" |package other.hello.world
-    		|
-    		|object Foo {
-    		|  val y = 0 
-    		|}""".stripMargin,
-  	
-  	"""	|package foo.bar
-    		|package object baz {
-    		|  val x = 42 
-    		|}""".stripMargin
-  ))
-  
-  for ((name,units) <- Seq(testPrint1)) {
-    testPrint(name, units)
-  }
-  
-  
-}
-
-
-
diff --git a/src/test/scala/leon/test/helpers/ExpressionsDSL.scala b/src/test/scala/leon/test/helpers/ExpressionsDSL.scala
new file mode 100644
index 0000000000000000000000000000000000000000..08ab658815eb5cd51ef5b821261d5484ba878112
--- /dev/null
+++ b/src/test/scala/leon/test/helpers/ExpressionsDSL.scala
@@ -0,0 +1,72 @@
+package leon.test.helpers
+
+import org.scalatest.Assertions
+
+import leon.purescala.Definitions._
+import leon.purescala.Common._
+import leon.purescala.Types._
+import leon.purescala.Expressions._
+
+trait ExpressionsDSL {
+  self: Assertions =>
+
+  val F = BooleanLiteral(false)
+  val T = BooleanLiteral(true)
+
+  def bi(x: Int)    = InfiniteIntegerLiteral(x)
+  def b(x: Boolean) = BooleanLiteral(x)
+  def i(x: Int)     = IntLiteral(x)
+  def r(x: Double)  = RealLiteral(BigDecimal(x))
+
+  val a = FreshIdentifier("a", Int32Type).toVariable
+  val b = FreshIdentifier("b", Int32Type).toVariable
+  val c = FreshIdentifier("c", Int32Type).toVariable
+
+  val x = FreshIdentifier("x", IntegerType).toVariable
+  val y = FreshIdentifier("y", IntegerType).toVariable
+  val z = FreshIdentifier("z", IntegerType).toVariable
+
+  val m = FreshIdentifier("m", RealType).toVariable
+  val n = FreshIdentifier("n", RealType).toVariable
+  val o = FreshIdentifier("o", RealType).toVariable
+
+  val p = FreshIdentifier("p", BooleanType).toVariable
+  val q = FreshIdentifier("q", BooleanType).toVariable
+  val r = FreshIdentifier("r", BooleanType).toVariable
+
+
+  def funDef(name: String)(implicit pgm: Program): FunDef = {
+    pgm.lookupAll(name).collect {
+      case fd: FunDef => fd
+    }.headOption.getOrElse {
+      fail(s"Failed to lookup function '$name' in program")
+    }
+  }
+
+  def classDef(name: String)(implicit pgm: Program): ClassDef = {
+    pgm.lookupAll(name).collect {
+      case cd: ClassDef => cd
+    }.headOption.getOrElse {
+      fail(s"Failed to lookup class '$name' in program")
+    }
+  }
+
+  def caseClassDef(name: String)(implicit pgm: Program): CaseClassDef = {
+    pgm.lookupAll(name).collect {
+      case ccd: CaseClassDef => ccd
+    }.headOption.getOrElse {
+      fail(s"Failed to lookup case class '$name' in program")
+    }
+  }
+
+  def cc(name: String)(args: Expr*)(implicit pgm: Program): Expr = {
+    val cct = caseClassDef(name).typed(Seq())
+    CaseClass(cct, args.toSeq)
+  }
+
+  def fcall(name: String)(args: Expr*)(implicit pgm: Program): Expr = {
+    val tfd = funDef(name).typed(Seq())
+    FunctionInvocation(tfd, args.toSeq)
+  }
+
+}
diff --git a/src/test/scala/leon/test/helpers/WithLikelyEq.scala b/src/test/scala/leon/test/helpers/WithLikelyEq.scala
new file mode 100644
index 0000000000000000000000000000000000000000..aee9e7671d5f0d64e4e81bd0a6b82c6b514b2e20
--- /dev/null
+++ b/src/test/scala/leon/test/helpers/WithLikelyEq.scala
@@ -0,0 +1,65 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.helpers
+
+import org.scalatest.Assertions
+
+import leon.test._
+import leon.evaluators._
+import leon.purescala.Common._
+import leon.LeonContext
+import leon.purescala.Types._
+import leon.purescala.Definitions._
+import leon.purescala.ExprOps._
+import leon.purescala.Expressions._
+import leon.utils.SeqUtils._
+
+/*
+ * Determine if two expressions over arithmetic variables are likely to be equal.
+ *
+ * This is a probabilistic based approach, it does not rely on any external solver and can
+ * only prove the non equality of two expressions.
+ */
+trait WithLikelyEq {
+  self: Assertions =>
+
+  val typesValues = Map[TypeTree, Seq[Expr]](
+    IntegerType -> Seq(-42, -1, 0, 1, 7, 42).map(InfiniteIntegerLiteral(_)),
+    Int32Type   -> Seq(-42, -1, 0, 1, 7, 42).map(IntLiteral(_)),
+    BooleanType -> Seq(BooleanLiteral(false), BooleanLiteral(true))
+  )
+
+  def checkLikelyEq(ctx: LeonContext, pgm: Program = Program.empty)(e1: Expr, e2: Expr, pre: Option[Expr] = None, values: Map[Identifier, Expr] = Map()): Unit = {
+    val evaluator = new DefaultEvaluator(ctx, pgm)
+
+    val freeVars = (variablesOf(e1) ++ variablesOf(e2)).toSeq.sortBy(_.globalId)
+
+    if (freeVars.isEmpty) {
+      val r1 = evaluator.eval(e1)
+      val r2 = evaluator.eval(e2)
+
+      assert(r1 === r2, s"'$e1' != '$e2' ('$r1' != '$r2')")
+    } else {
+
+      val allValues = freeVars.map(id => values.get(id).map(Seq(_)).getOrElse(typesValues(id.getType)))
+
+      cartesianProduct(allValues).foreach { vs =>
+        val m = (freeVars zip vs).toMap
+
+        val doTest = pre.map { p =>
+          evaluator.eval(p, m).result match {
+            case Some(BooleanLiteral(b)) => b
+            case _ => fail("Precondition is not a boolean expression")
+          }
+        }.getOrElse(true)
+
+        if (doTest) {
+          val r1 = evaluator.eval(e1, m)
+          val r2 = evaluator.eval(e2, m)
+
+          assert(r1 === r2, s"'$e1' != '$e2' with '$m' ('$r1' != '$r2')")
+        }
+      }
+    }
+  }
+}
diff --git a/src/test/scala/leon/test/performance/CegisPerformanceTest.scala b/src/test/scala/leon/test/performance/CegisPerformanceTest.scala
deleted file mode 100644
index f2ad6c2b7f0d1cd466a68c0e8f97ac197c73a8fa..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/performance/CegisPerformanceTest.scala
+++ /dev/null
@@ -1,65 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.performance
-
-import leon._
-import leon.synthesis._
-import leon.synthesis.rules._
-import leon.test._
-import leon.utils._
-import leon.frontends.scalac._
-
-import org.scalameter.api._
-
-class CegisPerformanceTest extends PerformanceTest.OfflineRegressionReport {
-
-  override def persistor = new SerializationPersistor
-  override def executor: Executor = LocalExecutor(warmer, aggregator, measurer)
-
-
-  val lt = new LeonTestSuite{}
-
-  val ctxPrograms = for (f <- lt.filesInResourceDir("regression/performance/cegis/", _.endsWith(".scala"))) yield {
-    val extraction =
-      ExtractionPhase andThen
-      PreprocessingPhase
-
-    val leonReporter = new TestSilentReporter
-
-    val paths = List(f.getPath)
-    val ctx = Main.processOptions(paths).copy(
-      reporter = leonReporter,
-      interruptManager = new InterruptManager(leonReporter)
-    )
-
-    (f.getName.dropRight(6), ctx, extraction.run(ctx)(paths))
-  }
-
-  val cegisRules = List(
-    OnePoint,
-    Ground,
-    UnusedInput,
-    EquivalentInputs,
-    UnconstrainedOutput,
-    CEGIS,
-    Assert
-  )
-
-  val settings =  SynthesisSettings(timeoutMs = Some(20000), rules = cegisRules)
-
-  performance of "CEGIS" in {
-    for ((name, ctx, pgm) <- ctxPrograms) {
-      measure.method(name) in {
-        using(Gen.unit("test")) in { _ =>
-          val cis = ChooseInfo.extractFromProgram(ctx, pgm).filterNot(_.fd.annotations("library"))
-          for (ci <- cis) {
-            val synth = new Synthesizer(ctx, pgm, ci, settings)
-            val s = synth.getSearch
-            val sols = s.search(synth.sctx)
-          }
-        }
-      }
-    }
-  }
-
-}
diff --git a/src/test/scala/leon/test/purescala/DataGenSuite.scala b/src/test/scala/leon/test/purescala/DataGenSuite.scala
deleted file mode 100644
index 6784078c4fc3f10c6e53c5bdcec23be63c214b58..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/purescala/DataGenSuite.scala
+++ /dev/null
@@ -1,125 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.purescala
-
-import leon.test._
-import leon.utils.{TemporaryInputPhase, PreprocessingPhase}
-import leon.frontends.scalac.ExtractionPhase
-
-import leon.purescala.Common._
-import leon.purescala.Expressions._
-import leon.purescala.Definitions._
-import leon.purescala.Types._
-import leon.datagen._
-
-import leon.evaluators._
-
-class DataGenSuite extends LeonTestSuite {
-  private def parseString(str : String) : Program = {
-    val pipeline = TemporaryInputPhase andThen ExtractionPhase andThen PreprocessingPhase
-
-    val errorsBefore   = testContext.reporter.errorCount
-    val warningsBefore = testContext.reporter.warningCount
-
-    val program = pipeline.run(testContext)((str, Nil))
-  
-    assert(testContext.reporter.errorCount   === errorsBefore)
-    assert(testContext.reporter.warningCount === warningsBefore)
-
-    program
-  }
-
-  test("Lists") {
-    val p = """|import leon.lang._
-               |object Program {
-               |  sealed abstract class List
-               |  case class Cons(head : Int, tail : List) extends List
-               |  case object Nil extends List
-               |
-               |  def size(lst : List) : Int = lst match {
-               |    case Cons(_, xs) => 1 + size(xs)
-               |    case Nil => 0
-               |  }
-               |
-               |  def isSorted(lst : List) : Boolean = lst match {
-               |    case Nil => true
-               |    case Cons(_, Nil) => true
-               |    case Cons(x, xs @ Cons(y, ys)) => x < y && isSorted(xs)
-               |  }
-               |
-               |  def content(lst : List) : Set[Int] = lst match {
-               |    case Nil => Set.empty[Int]
-               |    case Cons(x, xs) => Set(x) ++ content(xs)
-               |  }
-               |
-               |  def insertSpec(elem : Int, list : List, res : List) : Boolean = {
-               |    isSorted(res) && content(res) == (content(list) ++ Set(elem))
-               |  }
-               |}""".stripMargin
-
-    val prog = parseString(p)
-
-    val eval      = new DefaultEvaluator(testContext, prog)
-    val generator = new GrammarDataGen(eval)
-
-    generator.generate(BooleanType).toSet.size === 2
-    generator.generate(TupleType(Seq(BooleanType,BooleanType))).toSet.size === 4
-
-    // Make sure we target our own lists
-    val module = prog.units.flatMap{_.modules}.find(_.id.name == "Program").get
-    val listType : TypeTree = module.classHierarchyRoots.head.typed
-    val sizeDef    : FunDef = module.definedFunctions.find(_.id.name == "size").get
-    val sortedDef  : FunDef = module.definedFunctions.find(_.id.name == "isSorted").get
-    val contentDef : FunDef = module.definedFunctions.find(_.id.name == "content").get
-    val insSpecDef : FunDef = module.definedFunctions.find(_.id.name == "insertSpec").get
-
-    val consDef : CaseClassDef = module.definedClasses.collect {
-      case ccd: CaseClassDef if ccd.id.name == "Cons" => ccd
-    }.head
-
-    assert(generator.generate(listType).take(100).toSet.size === 100, "Should be able to generate 100 different lists")
-
-    val a = Variable(FreshIdentifier("a", Int32Type))
-    val b = Variable(FreshIdentifier("b", Int32Type))
-    val x = Variable(FreshIdentifier("x", listType))
-    val y = Variable(FreshIdentifier("y", listType))
-
-    val sizeX    = FunctionInvocation(sizeDef.typed, Seq(x))
-    val contentX = FunctionInvocation(contentDef.typed, Seq(x))
-    val contentY = FunctionInvocation(contentDef.typed, Seq(y))
-    val sortedX  = FunctionInvocation(sortedDef.typed, Seq(x))
-    val sortedY  = FunctionInvocation(sortedDef.typed, Seq(y))
-
-    assert(generator.generateFor(
-      Seq(x.id),
-      GreaterThan(sizeX, IntLiteral(0)),
-      10,
-      500
-    ).size === 10, "Should find 10 non-empty lists in the first 500 enumerated")
-
-    assert(generator.generateFor(
-      Seq(x.id, y.id),
-      And(Equals(contentX, contentY), sortedY),
-      10,
-      500
-    ).size === 10, "Should find 2x 10 lists with same content in the first 500 enumerated")
-
-    assert(generator.generateFor(
-      Seq(x.id, y.id),
-      And(Seq(Equals(contentX, contentY), sortedX, sortedY, Not(Equals(x, y)))),
-      1,
-      500
-    ).isEmpty, "There should be no models for this problem")
-
-    assert(generator.generateFor(
-      Seq(x.id, y.id, b.id, a.id),
-      And(Seq(
-        LessThan(a, b),
-        FunctionInvocation(sortedDef.typed, Seq(CaseClass(CaseClassType(consDef, Nil), Seq(a, x)))),
-        FunctionInvocation(insSpecDef.typed, Seq(b, x, y))
-      )),
-      10,
-      500
-    ).size >= 5, "There should be at least 5 models for this problem.")
-  }
-}
diff --git a/src/test/scala/leon/test/purescala/DefOpsSuite.scala b/src/test/scala/leon/test/purescala/DefOpsSuite.scala
deleted file mode 100644
index 86350f2948a1e9d01487203d02dd23482179cdd4..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/purescala/DefOpsSuite.scala
+++ /dev/null
@@ -1,117 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.purescala
-
-import leon._
-import purescala.Definitions._
-import purescala.DefOps._
-import frontends.scalac._
-import utils._
-import leon.test.LeonTestSuite
-
-private [purescala] object DefOpsHelper extends LeonTestSuite { 
-  private def parseStrings(strs : List[String]) : Program = {
-    val context = createLeonContext()
-
-    val pipeline =
-      ExtractionPhase andThen
-      PreprocessingPhase
-
-    val inputs = strs map { str => TemporaryInputPhase.run(context)((str, Nil)).head }
-    val program = pipeline.run(context)(inputs)
-
-    program
-  }
-
-  val test1 = List(
-    """ |package foo.bar.baz
-        |import other.hello.world.Foo
-        |import other.hello.world.Foo._
-        |import other.hello.world.!!!._
-        |import other.hello.world.m
-        |object Bar {
-        |  val x = 42
-        |  abstract class A
-        |  case class C(i : Int) extends A
-        |}
-        |
-        |object Foo {
-        |  import Bar.C
-        |  case class FooC()
-        |  val m = Bar.x + y + x
-        |  val ? = C(m)
-        |  val fooC = ? match {
-        |    case C(i) if i == 0 => FooC()
-        |    case _ => FooC()
-        |  }
-        |}""".stripMargin,
-  
-    """ |package other.hello.world
-        |
-        |object !!! { val m = 42 }
-        |object m { val x = 0 }
-        |
-        |object Foo {
-        |  val y = 0 
-        |}""".stripMargin,
-    
-    """ |package foo.bar
-        |package object baz {
-        |  val x = 42 
-        |}""".stripMargin,
-        
-    """ |package foo.bar.baz.and.some.more
-        |object InSubpackage {}
-        |""".stripMargin,
-
-    """ object InEmpty { def arrayLookup(a : Array[Int], i : Int) = a(i) } """
-  )
-  implicit val program = parseStrings(test1)
-  lazy val fooC = program.lookup("foo.bar.baz.Foo.fooC")
-}
-
-class DefOpsSuite extends LeonTestSuite {
-    import DefOpsHelper._
-    
-    test("Find base definition"){
-      assert(fooC.isDefined)
-    }
-
-    
-    test("In empty package") { 
-      val name = "InEmpty.arrayLookup"
-      val df = program.lookup(name)
-      assert(df.isDefined)
-      assert{fullName(df.get) == name } 
-    }
-    
-    // Search by full name    
-   
-    def mustFind(name: String, msg: String) = test(msg) {assert(searchRelative(name, fooC.get).nonEmpty) }
-    def mustFail(name: String, msg: String) = test(msg) {assert(searchRelative(name, fooC.get).isEmpty) }
-
-    mustFind("fooC", "Find yourself")
-    mustFind("FooC", "Find a definition in the same scope 1")
-    mustFind("?",    "Find a definition in the same scope 2")
-    mustFind("m",    "Find a definition in the same scope 3")
-    mustFind("Foo",  "Find an enclosing definition")
-    mustFind("Bar",  "Find a definition in an enclosing scope")
- 
-    mustFind("Bar.A",    "Find a definition in an object 1")
-    mustFind("Foo.fooC", "Find a definition in an object 2")
-
-    mustFind("y", "Find imported definition 1")
-    mustFind("x", "Find imported definition 2")
-    
-    mustFind("other.hello.world.Foo",     "Find a definition in another package")
-    mustFind("and.some.more.InSubpackage","Find a definition in a subpackage")
-    mustFind("InEmpty.arrayLookup",       "Find a definition in the empty package")
-
-    mustFail("nonExistent",    "Don't find non-existent definition")
-    mustFail("A",              "Don't find definition in another object")
-    mustFail("InSubpackage",   "Don't find definition in another package")
-    mustFail("hello.world.Foo","Don't find definition in non-visible nested package")
-    mustFail("!!!",            "Don't find definition that is root of a wildcard import")
-    mustFail("m.x",            "Don't find imported definition shadowed by local definition")
-      
-}
diff --git a/src/unit-test/scala/leon/purescala/ExprOpsSuite.scala b/src/test/scala/leon/test/purescala/ExprOpsSuite.scala
similarity index 65%
rename from src/unit-test/scala/leon/purescala/ExprOpsSuite.scala
rename to src/test/scala/leon/test/purescala/ExprOpsSuite.scala
index d929ce295daf6ff12c257bea272c6ea0726cc19a..482777b744e1c892e03c162cf2c2645cee46faa8 100644
--- a/src/unit-test/scala/leon/purescala/ExprOpsSuite.scala
+++ b/src/test/scala/leon/test/purescala/ExprOpsSuite.scala
@@ -1,15 +1,14 @@
 /* Copyright 2009-2015 EPFL, Lausanne */
 
-package leon
-package purescala
+package leon.test.purescala
 
-import Common._
-import Expressions._
-import Types._
-import ExprOps._
+import leon.test._
+import leon.purescala.Common._
+import leon.purescala.Expressions._
+import leon.purescala.Types._
+import leon.purescala.ExprOps._
 
-class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuilder {
-  
+class ExprOpsSuite extends LeonTestSuite with helpers.WithLikelyEq with helpers.ExpressionsDSL {
 
   private def foldConcatNames(e: Expr, subNames: Seq[String]): String = e match {
     case Variable(id) => subNames.mkString + id.name
@@ -20,14 +19,14 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     case _ => subCounts.sum
   }
 
-  test("foldRight works on single variable expression") {
+  test("foldRight works on single variable expression") { ctx =>
     assert(foldRight(foldConcatNames)(x) === x.id.name)
     assert(foldRight(foldConcatNames)(y) === y.id.name)
     assert(foldRight(foldCountVariables)(x) === 1)
     assert(foldRight(foldCountVariables)(y) === 1)
   }
 
-  test("foldRight works on simple expressions without nested structure") {
+  test("foldRight works on simple expressions without nested structure") { ctx =>
     assert(foldRight(foldConcatNames)(And(p, q)) === (p.id.name + q.id.name))
     assert(foldRight(foldConcatNames)(And(q, p)) === (q.id.name + p.id.name))
     assert(foldRight(foldConcatNames)(And(Seq(p, p, p, q, r))) ===
@@ -43,7 +42,7 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     assert(foldRight(foldCountVariables)(Or(Seq(p, p, p, q, r))) === 5)
   }
 
-  test("foldRight works on simple structure of nested expressions") {
+  test("foldRight works on simple structure of nested expressions") { ctx =>
     assert(foldRight(foldConcatNames)(And(And(p, q), r)) === (p.id.name + q.id.name + r.id.name))
     assert(foldRight(foldConcatNames)(And(p, Or(q, r))) === (p.id.name + q.id.name + r.id.name))
   }
@@ -54,7 +53,7 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     def get = c
   }
 
-  test("preTraversal works on a single node") {
+  test("preTraversal works on a single node") { ctx =>
     val c = new LocalCounter
     preTraversal(e => c.inc())(x)
     assert(c.get === 1)
@@ -69,7 +68,7 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     assert(names === List(x.id.name))
   }
 
-  test("preTraversal correctly applies on every nodes on a simple expression") {
+  test("preTraversal correctly applies on every nodes on a simple expression") { ctx =>
     val c1 = new LocalCounter
     preTraversal(e => c1.inc())(And(Seq(p, q, r)))
     assert(c1.get === 4)
@@ -80,7 +79,7 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     assert(c2.get === 6)
   }
 
-  test("preTraversal visits children from left to right") {
+  test("preTraversal visits children from left to right") { ctx =>
     var names: List[String] = List()
     preTraversal({
       case Variable(id) => names ::= id.name
@@ -89,13 +88,13 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     assert(names === List(r.id.name, q.id.name, p.id.name))
   }
 
-  test("preTraversal works on nexted expressions") {
+  test("preTraversal works on nexted expressions") { ctx =>
     val c = new LocalCounter
     preTraversal(e => c.inc())(And(p, And(q, r)))
     assert(c.get === 5)
   }
 
-  test("preTraversal traverses in pre-order") {
+  test("preTraversal traverses in pre-order") { ctx =>
     var nodes: List[Expr] = List()
     val node = And(List(p, q, r))
     preTraversal(e => nodes ::= e)(node)
@@ -103,7 +102,7 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
   }
 
 
-  test("postTraversal works on a single node") {
+  test("postTraversal works on a single node") { ctx =>
     val c = new LocalCounter
     postTraversal(e => c.inc())(x)
     assert(c.get === 1)
@@ -118,7 +117,7 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     assert(names === List(x.id.name))
   }
 
-  test("postTraversal correctly applies on every nodes on a simple expression") {
+  test("postTraversal correctly applies on every nodes on a simple expression") { ctx =>
     val c1 = new LocalCounter
     postTraversal(e => c1.inc())(And(Seq(p, q, r)))
     assert(c1.get === 4)
@@ -129,7 +128,7 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     assert(c2.get === 6)
   }
 
-  test("postTraversal visits children from left to right") {
+  test("postTraversal visits children from left to right") { ctx =>
     var names: List[String] = List()
     postTraversal({
       case Variable(id) => names ::= id.name
@@ -138,20 +137,19 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     assert(names === List(r.id.name, q.id.name, p.id.name))
   }
 
-  test("postTraversal works on nexted expressions") {
+  test("postTraversal works on nexted expressions") { ctx =>
     val c = new LocalCounter
     postTraversal(e => c.inc())(And(p, And(q, r)))
     assert(c.get === 5)
   }
 
-  test("postTraversal traverses in pre-order") {
+  test("postTraversal traverses in pre-order") { ctx =>
     var nodes: List[Expr] = List()
     val node = And(List(p, q, r))
     postTraversal(e => nodes ::= e)(node)
     assert(nodes === List(node, r, q, p))
   }
 
-
   /**
    * If the formula consist of some top level AND, find a top level
    * Equals and extract it, return the remaining formula as well
@@ -169,47 +167,42 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
   }
 
 
-  def checkSameExpr(e1: Expr, e2: Expr, vs: Set[Identifier]) {
-    assert( //this outer assert should not be needed because of the nested one
-      LikelyEq(e1, e2, vs, BooleanLiteral(true), (e1, e2) => {assert(e1 === e2); true})
-    )
-  }
 
-  test("simplifyArithmetic") {
-    val e1 = Plus(i(3), i(2))
-    checkSameExpr(e1, simplifyArithmetic(e1), Set())
-    val e2 = Plus(a, Plus(i(3), i(2)))
-    checkSameExpr(e2, simplifyArithmetic(e2), Set(aId))
-
-    val e3 = Minus(i(3), i(2))
-    checkSameExpr(e3, simplifyArithmetic(e3), Set())
-    val e4 = Plus(a, Minus(i(3), i(2)))
-    checkSameExpr(e4, simplifyArithmetic(e4), Set(aId))
-    val e5 = Plus(a, Minus(a, i(2)))
-    checkSameExpr(e5, simplifyArithmetic(e5), Set(aId))
-
-    val e6 = Times(i(9), Plus(Division(a, i(3)), Division(a, i(6))))
-    checkSameExpr(e6, simplifyArithmetic(e6), Set(aId))
+  test("simplifyArithmetic") { ctx =>
+    val e1 = Plus(bi(3), bi(2))
+    checkLikelyEq(ctx)(e1, simplifyArithmetic(e1))
+    val e2 = Plus(x, Plus(bi(3), bi(2)))
+    checkLikelyEq(ctx)(e2, simplifyArithmetic(e2))
+
+    val e3 = Minus(bi(3), bi(2))
+    checkLikelyEq(ctx)(e3, simplifyArithmetic(e3))
+    val e4 = Plus(x, Minus(bi(3), bi(2)))
+    checkLikelyEq(ctx)(e4, simplifyArithmetic(e4))
+    val e5 = Plus(x, Minus(x, bi(2)))
+    checkLikelyEq(ctx)(e5, simplifyArithmetic(e5))
+
+    val e6 = Times(bi(9), Plus(Division(x, bi(3)), Division(x, bi(6))))
+    checkLikelyEq(ctx)(e6, simplifyArithmetic(e6))
   }
 
-  test("expandAndSimplifyArithmetic") {
-    val e1 = Plus(i(3), i(2))
-    checkSameExpr(e1, expandAndSimplifyArithmetic(e1), Set())
-    val e2 = Plus(a, Plus(i(3), i(2)))
-    checkSameExpr(e2, expandAndSimplifyArithmetic(e2), Set(aId))
-
-    val e3 = Minus(i(3), i(2))
-    checkSameExpr(e3, expandAndSimplifyArithmetic(e3), Set())
-    val e4 = Plus(a, Minus(i(3), i(2)))
-    checkSameExpr(e4, expandAndSimplifyArithmetic(e4), Set(aId))
-    val e5 = Plus(a, Minus(a, i(2)))
-    checkSameExpr(e5, expandAndSimplifyArithmetic(e5), Set(aId))
-
-    val e6 = Times(i(9), Plus(Division(a, i(3)), Division(a, i(6))))
-    checkSameExpr(e6, expandAndSimplifyArithmetic(e6), Set(aId))
+  test("expandAndSimplifyArithmetic") { ctx =>
+    val e1 = Plus(bi(3), bi(2))
+    checkLikelyEq(ctx)(e1, expandAndSimplifyArithmetic(e1))
+    val e2 = Plus(x, Plus(bi(3), bi(2)))
+    checkLikelyEq(ctx)(e2, expandAndSimplifyArithmetic(e2))
+
+    val e3 = Minus(bi(3), bi(2))
+    checkLikelyEq(ctx)(e3, expandAndSimplifyArithmetic(e3))
+    val e4 = Plus(x, Minus(bi(3), bi(2)))
+    checkLikelyEq(ctx)(e4, expandAndSimplifyArithmetic(e4))
+    val e5 = Plus(x, Minus(x, bi(2)))
+    checkLikelyEq(ctx)(e5, expandAndSimplifyArithmetic(e5))
+
+    val e6 = Times(bi(9), Plus(Division(x, bi(3)), Division(x, bi(6))))
+    checkLikelyEq(ctx)(e6, expandAndSimplifyArithmetic(e6))
   }
 
-  test("extractEquals") {
+  test("extractEquals") { ctx =>
     val eq = Equals(a, b)
     val lt1 = LessThan(a, b)
     val lt2 = LessThan(b, a)
@@ -237,8 +230,8 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     assert(extractEquals(r4)._1 === None)
   }
 
-  test("pre and post traversal") {
-    val expr = Plus(i(1), Minus(i(2), i(3)))
+  test("pre and post traversal") { ctx =>
+    val expr = Plus(bi(1), Minus(bi(2), bi(3)))
     var res = ""
     def f(e: Expr): Unit = e match {
       case InfiniteIntegerLiteral(i) => res += i
@@ -254,36 +247,19 @@ class ExprOpsSuite extends LeonTestSuite with WithLikelyEq with ExpressionsBuild
     assert(res === "123MP")
   }
 
-  test("pre- and postMap") {
-    val expr = Plus(i(1), Minus(i(2), i(3)))
+  test("pre- and postMap") { ctx =>
+    val expr = Plus(bi(1), Minus(bi(2), bi(3)))
     def op(e : Expr ) = e match {
-      case Minus(InfiniteIntegerLiteral(two), e2) if two == BigInt(2) => Some(i(2))
-      case InfiniteIntegerLiteral(one) if one == BigInt(1) => Some(i(2))
-      case InfiniteIntegerLiteral(two) if two == BigInt(2) => Some(i(42))
+      case Minus(InfiniteIntegerLiteral(two), e2) if two == BigInt(2) => Some(bi(2))
+      case InfiniteIntegerLiteral(one) if one == BigInt(1) => Some(bi(2))
+      case InfiniteIntegerLiteral(two) if two == BigInt(2) => Some(bi(42))
       case _ => None
     }
     
-    assert( preMap(op, false)(expr) == Plus(i(2),  i(2))  )
-    assert( preMap(op, true )(expr) == Plus(i(42), i(42)) )
-    assert( postMap(op, false)(expr) == Plus(i(2),  Minus(i(42), i(3))) )
-    assert( postMap(op, true)(expr)  == Plus(i(42), Minus(i(42), i(3))) )
+    assert( preMap(op, false)(expr) == Plus(bi(2),  bi(2))  )
+    assert( preMap(op, true )(expr) == Plus(bi(42), bi(42)) )
+    assert( postMap(op, false)(expr) == Plus(bi(2),  Minus(bi(42), bi(3))) )
+    assert( postMap(op, true)(expr)  == Plus(bi(42), Minus(bi(42), bi(3))) )
     
   }
-
-
-  test("negate of literal returns the correct literal") {
-    assert(negate(BooleanLiteral(true)) === BooleanLiteral(false))
-    assert(negate(BooleanLiteral(false)) === BooleanLiteral(true))
-  }
-
-  test("negate of a variable simply wraps it with a Not node") {
-    assert(negate(p) === Not(p))
-    assert(negate(q) === Not(q))
-  }
-
-  test("negate of a negated variable simply returns the variable") {
-    assert(negate(Not(p)) === p)
-    assert(negate(Not(q)) === q)
-  }
-  
 }
diff --git a/src/test/scala/leon/test/purescala/InliningSuite.scala b/src/test/scala/leon/test/purescala/InliningSuite.scala
deleted file mode 100644
index 36dded6ff3c8a700df4e5fbc2afbe851d721d25b..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/purescala/InliningSuite.scala
+++ /dev/null
@@ -1,63 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.purescala
-
-import leon._
-import purescala.Definitions._
-import purescala.DefOps._
-import purescala.Expressions._
-import frontends.scalac._
-import utils._
-import leon.test.LeonTestSuite
-
-class InliningSuite extends LeonTestSuite {
-  private def parseProgram(str: String): (Program, LeonContext) = {
-    val context = createLeonContext()
-
-    val pipeline =
-      TemporaryInputPhase andThen
-      ExtractionPhase andThen
-      PreprocessingPhase
-
-    val program = pipeline.run(context)((str, Nil))
-
-    (program, context)
-  }
-
-  test("Simple Inlining") {
-    val (pgm, ctx) = parseProgram(
-      """|
-         |import leon.lang._
-         |import leon.annotation._
-         |
-         |object InlineGood {
-         |
-         |  @inline
-         |  def foo(a: BigInt) = true
-         |
-         |  def bar(a: BigInt) = foo(a)
-         |
-         |} """.stripMargin)
-
-    val bar = pgm.lookup("InlineGood.bar").collect { case fd: FunDef => fd }.get
-
-    assert(bar.fullBody == BooleanLiteral(true), "Function not inlined?")
-  }
-
-  test("Recursive Inlining") {
-    val (pgm, ctx) = parseProgram(
-      """ |import leon.lang._
-         |import leon.annotation._
-         |
-         |object InlineBad {
-         |
-         |  @inline
-         |  def foo(a: BigInt): BigInt = if (a > 42) foo(a-1) else 0
-         |
-         |  def bar(a: BigInt) = foo(a)
-         |
-         |}""".stripMargin)
-
-     assert(ctx.reporter.warningCount > 0, "Warning received for the invalid inline")
-  }
-}
diff --git a/src/test/scala/leon/test/purescala/LikelyEqSuite.scala b/src/test/scala/leon/test/purescala/LikelyEqSuite.scala
deleted file mode 100644
index 71115fac6993239883da8773f95ba1c09979c7bc..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/purescala/LikelyEqSuite.scala
+++ /dev/null
@@ -1,48 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.purescala
-
-import leon.test._
-import leon.purescala.Common._
-import leon.purescala.Expressions._
-import leon.purescala.Types._
-
-class LikelyEqSuite extends LeonTestSuite with WithLikelyEq {
-  def i(x: Int) = InfiniteIntegerLiteral(x)
-
-  val xId = FreshIdentifier("x", IntegerType)
-  val x = Variable(xId)
-  val yId = FreshIdentifier("y", IntegerType)
-  val y = Variable(yId)
-  val zId = FreshIdentifier("z", IntegerType)
-  val z = Variable(zId)
-
-  test("apply") {
-    assert(LikelyEq(Plus(x, x), Times(i(2), x), Set(xId)))
-    assert(LikelyEq(Plus(x, x), Times(x, i(2)), Set(xId)))
-
-    assert(LikelyEq(Plus(x, y), Plus(y, x), Set(xId, yId)))
-    assert(LikelyEq(Plus(Plus(x, y), y), Plus(x, Times(i(2), y)), Set(xId, yId)))
-
-    def defaultCompare(e1: Expr, e2: Expr) = e1 == e2
-
-    assert(LikelyEq(
-      Plus(i(2), Plus(x, y)), 
-      Plus(i(3), Plus(x, z)), 
-      Set(xId), 
-      BooleanLiteral(true),
-      defaultCompare, 
-      Map(yId -> i(2), zId -> i(1)))
-    )
-
-
-    assert(LikelyEq(
-      Plus(x, Times(i(2), Division(y, i(2))))
-      , Plus(x, y)
-      , Set(xId, yId)
-      , Equals(Modulo(y, i(2)), i(0))
-    ))
-
-  }
-  
-}
diff --git a/src/test/scala/leon/test/purescala/SimplifyLetsSuite.scala b/src/test/scala/leon/test/purescala/SimplifyLetsSuite.scala
new file mode 100644
index 0000000000000000000000000000000000000000..db5e12deecae9740577d7ba71d21fa1762b0d5ee
--- /dev/null
+++ b/src/test/scala/leon/test/purescala/SimplifyLetsSuite.scala
@@ -0,0 +1,54 @@
+/* Copyright 2009-2015 EPFL, Lausanne */
+
+package leon.test.purescala
+
+import leon.test._
+
+import leon.purescala.Expressions._
+import leon.purescala.Types._
+import leon.purescala.Common._
+import leon.purescala.ExprOps._
+
+class SimplifyLetsSuite extends LeonTestSuite {
+  val a = FreshIdentifier("a", IntegerType)
+  val b = FreshIdentifier("b", IntegerType)
+  val c = FreshIdentifier("c", IntegerType)
+  val l42 = InfiniteIntegerLiteral(42)
+  val l43 = InfiniteIntegerLiteral(43)
+
+  test("Simplify Lets 01 - double use of simple let") { ctx => 
+    val in  = Let(b, l42, Plus(a.toVariable, Plus(b.toVariable, b.toVariable)))
+    val exp = Plus(a.toVariable, Plus(l42, l42))
+
+    val out = simplifyLets(in)
+    assert(out === exp)
+  }
+
+  test("Simplify Lets 02 - single use of expr let") { ctx => 
+    val in  = Let(b, Plus(l42, a.toVariable), Plus(a.toVariable, b.toVariable))
+    val exp = Plus(a.toVariable, Plus(l42, a.toVariable))
+
+    val out = simplifyLets(in)
+    assert(out === exp)
+  }
+
+  test("Simplify Lets 03 - unused let") { ctx => 
+    val in  = Let(b, l42,
+              Let(c, l43,
+                Plus(a.toVariable, c.toVariable)))
+
+    val exp = Plus(a.toVariable, l43)
+
+    val out = simplifyLets(in)
+    assert(out === exp)
+  }
+
+  test("Simplify Lets 04 - double use of expr let") { ctx => 
+    val in  = Let(b, Plus(l42, a.toVariable), Plus(a.toVariable, Plus(b.toVariable, b.toVariable)))
+    val exp = in
+
+    val out = simplifyLets(in)
+    assert(out === exp)
+  }
+
+}
diff --git a/src/test/scala/leon/test/purescala/TransformationSuite.scala b/src/test/scala/leon/test/purescala/TransformationSuite.scala
deleted file mode 100644
index 9e8cefb6165c487591b2f30afa1afcf505f68a74..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/purescala/TransformationSuite.scala
+++ /dev/null
@@ -1,90 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.purescala
-
-import leon.test._
-import leon.utils. PreprocessingPhase
-import leon.frontends.scalac.ExtractionPhase
-
-import leon.purescala.Definitions._
-import leon.purescala.Expressions._
-import leon.purescala.ExprOps._
-
-import leon.solvers.z3.UninterpretedZ3Solver
-import leon.solvers._
-
-class TransformationSuite extends LeonTestSuite {
-
-  val pipeline = ExtractionPhase andThen PreprocessingPhase
- 
-  val simpPaths = (p: Program, e : Expr) => {
-    val uninterpretedZ3 = SolverFactory(() => new UninterpretedZ3Solver(testContext, p))
-    try {
-      simplifyPaths(uninterpretedZ3)(e)
-    } finally {
-      uninterpretedZ3.shutdown()
-    }
-  }
-
-  filesInResourceDir("regression/transformations").foreach { file =>
-    // Configure which file corresponds to which transformation:
-
-    val (title: String, transformer: ((Program,Expr) => Expr)) = file.getName match {
-      case "SimplifyLets.scala" =>
-        (
-          "Simplifying Lets",
-          (_:Program, e : Expr) => simplifyLets(e)
-        )
-      case "SimplifyPaths.scala" =>
-        (
-          "Simplifying paths",
-          simpPaths
-        )
-      case n =>
-        fail("Unknown name "+n)
-    }
-
-    test(title) {
-      val ctx = testContext.copy(
-        files   = List(file)
-      )
-
-      val prog = pipeline.run(ctx)(file.getPath :: Nil)
-
-      // Proceed with the actual tests
-      val inputs = prog.definedFunctions.collect{
-        case fd if fd.id.name.startsWith("input") =>
-          (fd.id.name.substring(5,7), fd)
-      }.toSeq.sortBy(_._1)
-
-      val outputs = prog.definedFunctions.collect{
-        case fd if fd.id.name.startsWith("output") =>
-          (fd.id.name.substring(6,8), fd)
-      }.toMap
-
-      for ((n, fdin) <- inputs) {
-        info(title +" ["+n+"]")
-        val in = fdin.body.get
-        outputs.get(n) match {
-          case Some(fdexp) =>
-            val out = transformer(prog, in)
-            val exp = fdexp.body.get
-
-            val map = (fdin.params.map(_.id) zip fdexp.params.map(_.id)).toMap
-
-            if (!isHomomorphic(out, exp)(map)) {
-              fail("Produced tree does not match\nGot:\n"+out+"\nExpected:\n"+exp+"\n")
-            }
-
-          case None =>
-            fail("No output for "+n+" ?!?")
-        }
-      }
-    }
-  }
-
-  def apply(trs: Expr => Expr *): Expr => Expr = {
-    { (e: Expr) => trs.foldLeft(e){ (x, tr) => tr(x) } }
-  }
-}
-
diff --git a/src/test/scala/leon/test/purescala/TreeNormalizationsSuite.scala b/src/test/scala/leon/test/purescala/TreeNormalizationsSuite.scala
index fc11c8a0911d937e3c81195bbca99490eb31ee39..08345e9b3625e328d6cf56c6b9483c76fa5ee604 100644
--- a/src/test/scala/leon/test/purescala/TreeNormalizationsSuite.scala
+++ b/src/test/scala/leon/test/purescala/TreeNormalizationsSuite.scala
@@ -4,81 +4,65 @@ package leon.test.purescala
 
 import leon.test._
 
+import leon.LeonContext
 import leon.purescala.Common._
 import leon.purescala.Types._
 import leon.purescala.Expressions._
 import leon.purescala.TreeNormalizations._
 
-class TreeNormalizationsSuite extends LeonTestSuite with WithLikelyEq {
-  def i(x: Int) = InfiniteIntegerLiteral(x)
-
-  val xId = FreshIdentifier("x", IntegerType)
-  val x = Variable(xId)
-  val yId = FreshIdentifier("y", IntegerType)
-  val y = Variable(yId)
-  val xs = Set(xId, yId)
-
-  val aId = FreshIdentifier("a", IntegerType)
-  val a = Variable(aId)
-  val bId = FreshIdentifier("b", IntegerType)
-  val b = Variable(bId)
-  val as = Set(aId, bId)
-  
-
-  def checkSameExpr(e1: Expr, e2: Expr, vs: Set[Identifier]) {
-    assert( //this outer assert should not be needed because of the nested one
-      LikelyEq(e1, e2, vs, BooleanLiteral(true), (e1, e2) => {assert(e1 === e2); true})
-    )
-  }
+class TreeNormalizationsSuite extends LeonTestSuite with helpers.WithLikelyEq with helpers.ExpressionsDSL {
 
   def toSum(es: Seq[Expr]) = es.reduceLeft(Plus)
   def coefToSum(es: Array[Expr], vs: Array[Expr]) = es.zip(Array[Expr](InfiniteIntegerLiteral(1)) ++ vs).foldLeft[Expr](InfiniteIntegerLiteral(0))((acc, p) => Plus(acc, Times(p._1, p._2)))
   
-  test("checkSameExpr") {
-    checkSameExpr(Plus(x, y), Plus(y, x), xs)
-    checkSameExpr(Plus(x, x), Times(x, i(2)), xs)
-    checkSameExpr(Plus(x, Plus(x, x)), Times(x, i(3)), xs)
+  test("checkSameExpr") { ctx =>
+    checkLikelyEq(ctx)(Plus(x, y), Plus(y, x))
+    checkLikelyEq(ctx)(Plus(x, x), Times(x, bi(2)))
+    checkLikelyEq(ctx)(Plus(x, Plus(x, x)), Times(x, bi(3)))
   }
 
-  test("multiply") {
-    val lhs = Seq(x, i(2))
-    val rhs = Seq(y, i(1))
-    checkSameExpr(Times(toSum(lhs), toSum(rhs)), toSum(multiply(lhs, rhs)), xs)
-    checkSameExpr(Times(toSum(rhs), toSum(lhs)), toSum(multiply(rhs, lhs)), xs)
+  test("multiply") { ctx =>
+    val lhs = Seq(x, bi(2))
+    val rhs = Seq(y, bi(1))
+    checkLikelyEq(ctx)(Times(toSum(lhs), toSum(rhs)), toSum(multiply(lhs, rhs)))
+    checkLikelyEq(ctx)(Times(toSum(rhs), toSum(lhs)), toSum(multiply(rhs, lhs)))
 
-    val lhs2 = Seq(x, y, i(2))
-    val rhs2 = Seq(y, i(1), Times(i(2), x))
-    checkSameExpr(Times(toSum(lhs2), toSum(rhs2)), toSum(multiply(lhs2, rhs2)), xs)
+    val lhs2 = Seq(x, y, bi(2))
+    val rhs2 = Seq(y, bi(1), Times(bi(2), x))
+    checkLikelyEq(ctx)(Times(toSum(lhs2), toSum(rhs2)), toSum(multiply(lhs2, rhs2)))
   }
 
-  test("expandedForm") {
-    val e1 = Times(Plus(x, i(2)), Plus(y, i(1)))
-    checkSameExpr(toSum(expandedForm(e1)), e1, xs)
+  test("expandedForm") { ctx =>
+    val e1 = Times(Plus(x, bi(2)), Plus(y, bi(1)))
+    checkLikelyEq(ctx)(toSum(expandedForm(e1)), e1)
 
-    val e2 = Times(Plus(x, Times(i(2), y)), Plus(Plus(x, y), i(1)))
-    checkSameExpr(toSum(expandedForm(e2)), e2, xs)
+    val e2 = Times(Plus(x, Times(bi(2), y)), Plus(Plus(x, y), bi(1)))
+    checkLikelyEq(ctx)(toSum(expandedForm(e2)), e2)
 
-    val e3 = Minus(Plus(x, Times(i(2), y)), Plus(Plus(x, y), i(1)))
-    checkSameExpr(toSum(expandedForm(e3)), e3, xs)
+    val e3 = Minus(Plus(x, Times(bi(2), y)), Plus(Plus(x, y), bi(1)))
+    checkLikelyEq(ctx)(toSum(expandedForm(e3)), e3)
 
-    val e4 = UMinus(Plus(x, Times(i(2), y)))
-    checkSameExpr(toSum(expandedForm(e4)), e4, xs)
+    val e4 = UMinus(Plus(x, Times(bi(2), y)))
+    checkLikelyEq(ctx)(toSum(expandedForm(e4)), e4)
   }
 
-  test("linearArithmeticForm") {
-    val xsOrder = Array(xId, yId)
+  test("linearArithmeticForm") { ctx =>
+    val xsOrder = Array(x.id, y.id)
+
+    val aa = FreshIdentifier("aa", IntegerType).toVariable
+    val bb = FreshIdentifier("bb", IntegerType).toVariable
 
-    val e1 = Plus(Times(Plus(x, i(2)), i(3)), Times(i(4), y))
-    checkSameExpr(coefToSum(linearArithmeticForm(e1, xsOrder), Array(x, y)), e1, xs)
+    val e1 = Plus(Times(Plus(x, bi(2)), bi(3)), Times(bi(4), y))
+    checkLikelyEq(ctx)(coefToSum(linearArithmeticForm(e1, xsOrder), Array(x, y)), e1)
 
-    val e2 = Plus(Times(Plus(x, i(2)), i(3)), Plus(Plus(a, Times(i(5), b)), Times(i(4), y)))
-    checkSameExpr(coefToSum(linearArithmeticForm(e2, xsOrder), Array(x, y)), e2, xs ++ as)
+    val e2 = Plus(Times(Plus(x, bi(2)), bi(3)), Plus(Plus(aa, Times(bi(5), bb)), Times(bi(4), y)))
+    checkLikelyEq(ctx)(coefToSum(linearArithmeticForm(e2, xsOrder), Array(x, y)), e2)
 
-    val e3 = Minus(Plus(x, i(3)), Plus(y, i(2)))
-    checkSameExpr(coefToSum(linearArithmeticForm(e3, xsOrder), Array(x, y)), e3, xs)
+    val e3 = Minus(Plus(x, bi(3)), Plus(y, bi(2)))
+    checkLikelyEq(ctx)(coefToSum(linearArithmeticForm(e3, xsOrder), Array(x, y)), e3)
 
-    val e4 = Plus(Plus(i(0), i(2)), Times(i(-1), i(3)))
-    assert(linearArithmeticForm(e4, Array()) === Array(i(-1)))
+    val e4 = Plus(Plus(bi(0), bi(2)), Times(bi(-1), bi(3)))
+    assert(linearArithmeticForm(e4, Array()) === Array(bi(-1)))
 
   }
 }
diff --git a/src/test/scala/leon/test/purescala/TreeOpsSuite.scala b/src/test/scala/leon/test/purescala/TreeOpsSuite.scala
deleted file mode 100644
index b73eec580ce50ed4dbde963b3ddeffe6db50d2d7..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/purescala/TreeOpsSuite.scala
+++ /dev/null
@@ -1,152 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.purescala
-
-import leon.test._
-import leon.purescala.Common._
-import leon.purescala.Expressions._
-import leon.purescala.Types._
-import leon.purescala.ExprOps._
-
-class TreeOpsSuite extends LeonTestSuite with WithLikelyEq {
-  
-  test("Path-aware simplifications") {
-    // TODO actually testing something here would be better, sorry
-    // PS
-
-    assert(true)
-  }
-
-  /**
-   * If the formula consist of some top level AND, find a top level
-   * Equals and extract it, return the remaining formula as well
-   */
-  def extractEquals(expr: Expr): (Option[Equals], Expr) = expr match {
-    case And(es) =>
-      // OK now I'm just messing with you.
-      val (r, nes) = es.foldLeft[(Option[Equals],Seq[Expr])]((None, Seq())) {
-        case ((None, nes), eq @ Equals(_,_)) => (Some(eq), nes)
-        case ((o, nes), e) => (o, e +: nes)
-      }
-      (r, And(nes.reverse))
-
-    case e => (None, e)
-  }
-
-
-  def i(x: Int) = InfiniteIntegerLiteral(x)
-
-  val xId = FreshIdentifier("x", IntegerType)
-  val x = Variable(xId)
-  val yId = FreshIdentifier("y", IntegerType)
-  val y = Variable(yId)
-  val xs = Set(xId, yId)
-
-  val aId = FreshIdentifier("a", IntegerType)
-  val a = Variable(aId)
-  val bId = FreshIdentifier("b", IntegerType)
-  val b = Variable(bId)
-  val as = Set(aId, bId)
-
-  def checkSameExpr(e1: Expr, e2: Expr, vs: Set[Identifier]) {
-    assert( //this outer assert should not be needed because of the nested one
-      LikelyEq(e1, e2, vs, BooleanLiteral(true), (e1, e2) => {assert(e1 === e2); true})
-    )
-  }
-
-  test("simplifyArithmetic") {
-    val e1 = Plus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(2))
-    checkSameExpr(e1, simplifyArithmetic(e1), Set())
-    val e2 = Plus(x, Plus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(2)))
-    checkSameExpr(e2, simplifyArithmetic(e2), Set(xId))
-
-    val e3 = Minus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(2))
-    checkSameExpr(e3, simplifyArithmetic(e3), Set())
-    val e4 = Plus(x, Minus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(2)))
-    checkSameExpr(e4, simplifyArithmetic(e4), Set(xId))
-    val e5 = Plus(x, Minus(x, InfiniteIntegerLiteral(2)))
-    checkSameExpr(e5, simplifyArithmetic(e5), Set(xId))
-
-    val e6 = Times(InfiniteIntegerLiteral(9), Plus(Division(x, InfiniteIntegerLiteral(3)), Division(x, InfiniteIntegerLiteral(6))))
-    checkSameExpr(e6, simplifyArithmetic(e6), Set(xId))
-  }
-
-  test("expandAndSimplifyArithmetic") {
-    val e1 = Plus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(2))
-    checkSameExpr(e1, expandAndSimplifyArithmetic(e1), Set())
-    val e2 = Plus(x, Plus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(2)))
-    checkSameExpr(e2, expandAndSimplifyArithmetic(e2), Set(xId))
-
-    val e3 = Minus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(2))
-    checkSameExpr(e3, expandAndSimplifyArithmetic(e3), Set())
-    val e4 = Plus(x, Minus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(2)))
-    checkSameExpr(e4, expandAndSimplifyArithmetic(e4), Set(xId))
-    val e5 = Plus(x, Minus(x, InfiniteIntegerLiteral(2)))
-    checkSameExpr(e5, expandAndSimplifyArithmetic(e5), Set(xId))
-
-    val e6 = Times(InfiniteIntegerLiteral(9), Plus(Division(x, InfiniteIntegerLiteral(3)), Division(x, InfiniteIntegerLiteral(6))))
-    checkSameExpr(e6, expandAndSimplifyArithmetic(e6), Set(xId))
-  }
-
-  test("extractEquals") {
-    val eq = Equals(a, b)
-    val lt1 = LessThan(a, b)
-    val lt2 = LessThan(b, a)
-    val lt3 = LessThan(x, y)
-
-    val f1 = And(Seq(eq, lt1, lt2, lt3))
-    val (eq1, r1) = extractEquals(f1)
-    assert(eq1 != None)
-    assert(eq1.get === eq)
-    assert(extractEquals(r1)._1 === None)
-
-    val f2 = And(Seq(lt1, lt2, eq, lt3))
-    val (eq2, r2) = extractEquals(f2)
-    assert(eq2 != None)
-    assert(eq2.get === eq)
-    assert(extractEquals(r2)._1 === None)
-
-    val f3 = And(Seq(lt1, eq, lt2, lt3, eq))
-    val (eq3, r3) = extractEquals(f3)
-    assert(eq3 != None)
-    assert(eq3.get === eq)
-    val (eq4, r4) = extractEquals(r3)
-    assert(eq4 != None)
-    assert(eq4.get === eq)
-    assert(extractEquals(r4)._1 === None)
-  }
-
-  test("pre and post traversal") {
-    val expr = Plus(InfiniteIntegerLiteral(1), Minus(InfiniteIntegerLiteral(2), InfiniteIntegerLiteral(3)))
-    var res = ""
-    def f(e: Expr): Unit = e match {
-      case InfiniteIntegerLiteral(i) => res += i
-      case _ : Plus      => res += "P"
-      case _ : Minus     => res += "M"
-    }
-
-    preTraversal(f)(expr)
-    assert(res === "P1M23")
-
-    res = ""
-    postTraversal(f)(expr)
-    assert(res === "123MP")
-  }
-
-  test("pre- and postMap") {
-    val expr = Plus(InfiniteIntegerLiteral(1), Minus(InfiniteIntegerLiteral(2), InfiniteIntegerLiteral(3)))
-    def op(e : Expr ) = e match {
-      case Minus(InfiniteIntegerLiteral(two), e2) if two == BigInt(2) => Some(InfiniteIntegerLiteral(2))
-      case InfiniteIntegerLiteral(one) if one == BigInt(1) => Some(InfiniteIntegerLiteral(2))
-      case InfiniteIntegerLiteral(two) if two == BigInt(2) => Some(InfiniteIntegerLiteral(42))
-      case _ => None
-    }
-    
-    assert( preMap(op, false)(expr) == Plus(InfiniteIntegerLiteral(2),  InfiniteIntegerLiteral(2))  )
-    assert( preMap(op, true )(expr) == Plus(InfiniteIntegerLiteral(42), InfiniteIntegerLiteral(42)) )
-    assert( postMap(op, false)(expr) == Plus(InfiniteIntegerLiteral(2),  Minus(InfiniteIntegerLiteral(42), InfiniteIntegerLiteral(3))) )
-    assert( postMap(op, true)(expr)  == Plus(InfiniteIntegerLiteral(42), Minus(InfiniteIntegerLiteral(42), InfiniteIntegerLiteral(3))) )
-    
-  }
-  
-}
diff --git a/src/test/scala/leon/test/purescala/TreeTestsSuite.scala b/src/test/scala/leon/test/purescala/TreeTestsSuite.scala
index 933ba02dc4397850965c14d5dbf22ee8f5fe3f97..0692b3c8bb95cf911748a255e3365989452fe370 100644
--- a/src/test/scala/leon/test/purescala/TreeTestsSuite.scala
+++ b/src/test/scala/leon/test/purescala/TreeTestsSuite.scala
@@ -11,8 +11,8 @@ import leon.purescala.Types._
 
 class TreeTestsSuite extends LeonTestSuite {
 
-  test("And- and Or- simplifications") {
-    val x = Variable(FreshIdentifier("x", BooleanType))
+  test("And- and Or- simplifications") { ctx =>
+    val x = FreshIdentifier("x", BooleanType).toVariable
     val t = BooleanLiteral(true)
     val f = BooleanLiteral(false)
 
diff --git a/src/test/scala/leon/test/purescala/WithLikelyEq.scala b/src/test/scala/leon/test/purescala/WithLikelyEq.scala
deleted file mode 100644
index 19ee997e297e85f4153ae7d8977d6db66917b1f2..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/purescala/WithLikelyEq.scala
+++ /dev/null
@@ -1,87 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.purescala
-
-import leon.test._
-import leon.evaluators._
-import leon.purescala.Common._
-import leon.purescala.Definitions._
-import leon.purescala.ExprOps.replace
-import leon.purescala.Expressions._
-
-/*
- * Determine if two expressions over arithmetic variables are likely to be equal.
- *
- * This is a probabilistic based approach, it does not rely on any external solver and can
- * only prove the non equality of two expressions.
- */
-trait WithLikelyEq {
-  this: LeonTestSuite =>
-
-  object LikelyEq {
-    private val min = -5
-    private val max = 5
-
-    /*
-     * compare e1 and e2, using a list of assignment of integer to the variables in vs.
-     * Pre is a boolean expression precondition over the same variables that must be evaluated to true
-     * before testing equality.
-     * Add a default mapping for some set parameters
-     * Note that the default map could contain a mapping for variables to other parameters
-     * It is thus necessary to first select values for those parameters and then substitute
-     * into the default map !
-     */
-    def apply(e1: Expr, e2: Expr, vs: Set[Identifier], pre: Expr = BooleanLiteral(true),
-              compare: (Expr, Expr) => Boolean = (e1, e2) => e1 == e2, 
-              defaultMap: Map[Identifier, Expr] = Map()): Boolean = {
-      val evaluator = new DefaultEvaluator(testContext, Program.empty)
-      if(vs.isEmpty) {
-        val ndm = defaultMap.map { case (id, expr) => (id, evaluator.eval(expr).asInstanceOf[EvaluationResults.Successful].value) } //TODO: not quite sure why I need to do this...
-        (evaluator.eval(e1, ndm), evaluator.eval(e2, defaultMap)) match {
-          case (EvaluationResults.Successful(v1), EvaluationResults.Successful(v2)) => compare(v1, v2)
-          case (err1, err2) => sys.error("evaluation could not complete, got: (" + err1 + ", " + err2 + ")")
-        }
-      } else {
-        var isEq = true
-        val vsOrder = vs.toArray
-        val counters: Array[Int] = vsOrder.map(_ => min)
-        var i = 0
-
-        while(i < counters.length && isEq) {
-          val m: Map[Expr, Expr] = vsOrder.zip(counters).map{case (v, c) => (Variable(v), InfiniteIntegerLiteral(c))}.toMap
-          val ne1 = replace(m, e1)
-          val ne2 = replace(m, e2)
-          val npre = replace(m, pre)
-          val ndm = defaultMap.map{ case (id, expr) => (id, evaluator.eval(expr, m.map{case (Variable(id), t) => (id, t)}).asInstanceOf[EvaluationResults.Successful].value) }
-          evaluator.eval(npre, ndm) match {
-            case EvaluationResults.Successful(BooleanLiteral(false)) =>
-            case EvaluationResults.Successful(BooleanLiteral(true)) =>
-              val ev1 = evaluator.eval(ne1, ndm)
-              val ev2 = evaluator.eval(ne2, ndm)
-              (ev1, ev2) match {
-                case (EvaluationResults.Successful(v1), EvaluationResults.Successful(v2)) => if(!compare(v1, v2)) isEq = false
-                case (err1, err2) => sys.error("evaluation could not complete, got: (" + err1 + ", " + err2 + ")")
-              }
-            case err => sys.error("evaluation of precondition could not complete, got: " + err)
-          }
-
-          if(counters(i) < max)
-            counters(i) += 1
-          else {
-            while(i < counters.length && counters(i) >= max) {
-              counters(i) = min
-              i += 1
-            }
-            if(i < counters.length) {
-              counters(i) += 1
-              i = 0
-            }
-          }
-        }
-        isEq
-      }
-    }
-
-  }
-
-}
diff --git a/src/test/scala/leon/test/solvers/EnumerationSolverSuite.scala b/src/test/scala/leon/test/solvers/EnumerationSolverSuite.scala
deleted file mode 100644
index cfe8ab17cea7ba0a5311cb3459bd4f514c9e1e35..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/solvers/EnumerationSolverSuite.scala
+++ /dev/null
@@ -1,44 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.solvers
-
-import leon.test._
-import leon.solvers._
-import leon.purescala.Common._
-import leon.purescala.Definitions._
-import leon.purescala.Expressions._
-import leon.purescala.Types._
-
-class EnumerationSolverSuite extends LeonTestSuite {
-  private def check(sf: SolverFactory[Solver], e: Expr): Option[Boolean] = {
-    val s = sf.getNewSolver()
-    s.assertCnstr(e)
-    s.check
-  }
-
-  private def getSolver = {
-    SolverFactory(() => new EnumerationSolver(testContext, Program.empty))
-  }
-
-  test("EnumerationSolver 1 (true)") {
-    val sf = getSolver
-    assert(check(sf, BooleanLiteral(true)) === Some(true))
-    sf.shutdown()
-  }
-
-  test("EnumerationSolver 2 (x == 1)") {
-    val sf = getSolver
-    val x = Variable(FreshIdentifier("x", Int32Type))
-    val o = IntLiteral(1)
-    assert(check(sf, Equals(x, o)) === Some(true))
-    sf.shutdown()
-  }
-
-  test("EnumerationSolver 3 (Limited range for ints)") {
-    val sf = getSolver
-    val x = Variable(FreshIdentifier("x", Int32Type))
-    val o = IntLiteral(42)
-    assert(check(sf, Equals(x, o)) === None)
-    sf.shutdown()
-  }
-}
diff --git a/src/test/scala/leon/test/solvers/UnrollingSolverSuite.scala b/src/test/scala/leon/test/solvers/UnrollingSolverSuite.scala
deleted file mode 100644
index d410aadfa6a1c5eb9222d2450057448808741d80..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/solvers/UnrollingSolverSuite.scala
+++ /dev/null
@@ -1,52 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.solvers
-
-import leon.test._
-import leon.purescala.Expressions._
-import leon.purescala.Types._
-import leon.purescala.Common._
-import leon.purescala.Definitions._
-import leon.solvers._
-import leon.solvers.z3._
-import leon.solvers.combinators._
-
-class UnrollingSolverSuite extends LeonTestSuite {
-
-  private val fx   : Identifier = FreshIdentifier("x", IntegerType)
-  private val fres : Identifier = FreshIdentifier("res", IntegerType)
-  private val fDef : FunDef = new FunDef(FreshIdentifier("f"), Nil, IntegerType, ValDef(fx) :: Nil)
-  fDef.body = Some(IfExpr(GreaterThan(Variable(fx), InfiniteIntegerLiteral(0)),
-    Plus(Variable(fx), FunctionInvocation(fDef.typed, Seq(Minus(Variable(fx), InfiniteIntegerLiteral(1))))),
-    InfiniteIntegerLiteral(1)
-  ))
-  fDef.postcondition = Some(Lambda(Seq(ValDef(fres)), GreaterThan(Variable(fres), InfiniteIntegerLiteral(0))))
-
-  private val program = Program(
-    List(UnitDef(
-      FreshIdentifier("Minimal"),
-      List(ModuleDef(FreshIdentifier("Minimal"), Seq(fDef), false))
-    ))
-  )
-
-  private def check(expr: Expr, expected: Option[Boolean], msg: String) : Unit = {
-    test(msg) {
-      val sf = SolverFactory(() => new UnrollingSolver(testContext, program, new UninterpretedZ3Solver(testContext, program)))
-      val solver = sf.getNewSolver()
-
-      try { 
-        solver.assertCnstr(expr)
-        assert(solver.check == expected)
-      } finally { 
-        solver.free()
-        sf.shutdown()
-      }
-    }
-  }
-
-  check(BooleanLiteral(true), Some(true), "'true' should always be valid")
-  check(BooleanLiteral(false), Some(false), "'false' should never be valid")
-
-  check(Not(GreaterThan(FunctionInvocation(fDef.typed, Seq(Variable(FreshIdentifier("toto", IntegerType)))), InfiniteIntegerLiteral(0))),
-    Some(false), "unrolling should enable recursive definition verification")
-}
diff --git a/src/test/scala/leon/test/solvers/z3/FairZ3SolverTests.scala b/src/test/scala/leon/test/solvers/z3/FairZ3SolverTests.scala
deleted file mode 100644
index 3df66679b640e3d02a7904c91120f9ba8e584b56..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/solvers/z3/FairZ3SolverTests.scala
+++ /dev/null
@@ -1,105 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.solvers.z3
-
-import leon.test._
-import leon.purescala.Common._
-import leon.purescala.Definitions._
-import leon.purescala.Expressions._
-import leon.purescala.Types._
-
-import leon.solvers._
-import leon.solvers.z3._
-
-class FairZ3SolverTests extends LeonTestSuite {
-  private var testCounter : Int = 0
-  private def solverCheck(solver : SimpleSolverAPI, expr : Expr, expected : Option[Boolean], msg : String) = {
-    testCounter += 1
-
-    test("Solver test #" + testCounter) {
-      assert(solver.solveVALID(expr) === expected, msg)
-    }
-  }
-
-  private def assertValid(solver : SimpleSolverAPI, expr : Expr) = solverCheck(
-    solver, expr, Some(true),
-    "Solver should prove the formula " + expr + " valid."
-  )
-
-  private def assertInvalid(solver : SimpleSolverAPI, expr : Expr) = solverCheck(
-    solver, expr, Some(false),
-    "Solver should prove the formula " + expr + " invalid."
-  )
-
-  private def assertUnknown(solver : SimpleSolverAPI, expr : Expr) = solverCheck(
-    solver, expr, None,
-    "Solver should not be able to decide the formula " + expr + "."
-  )
-
-  // def f(fx : Int) : Int = fx + 1
-  private val fx   : Identifier = FreshIdentifier("x", IntegerType)
-  private val fDef : FunDef = new FunDef(FreshIdentifier("f"), Nil, IntegerType, ValDef(fx) :: Nil)
-  fDef.body = Some(Plus(Variable(fx), InfiniteIntegerLiteral(1)))
-
-  private val minimalProgram = Program(
-    List(UnitDef(
-        FreshIdentifier("Minimal"),
-        List(ModuleDef(FreshIdentifier("Minimal"), Seq(fDef), false)
-    )))
-  )
-
-  private val x : Expr = Variable(FreshIdentifier("x", IntegerType))
-  private val y : Expr = Variable(FreshIdentifier("y", IntegerType))
-  private def f(e : Expr) : Expr = FunctionInvocation(fDef.typed, e :: Nil)
-
-  // TODO: refactor this entire suite to support SolverFactory.shutdown
-  private val solver = SimpleSolverAPI(SolverFactory(() => new FairZ3Solver(testContext, minimalProgram)))
-
-  private val tautology1 : Expr = BooleanLiteral(true)
-  assertValid(solver, tautology1)
-
-  private val tautology2 : Expr = Equals(Plus(x, x), Times(InfiniteIntegerLiteral(2), x))
-  assertValid(solver, tautology2)
-
-  // This one contains a function invocation but is valid regardless of its
-  // interpretation, so should be proved anyway.
-  private val tautology3 : Expr = Implies(
-    Not(Equals(f(x), f(y))),
-    Not(Equals(x, y))
-  )
-  assertValid(solver, tautology3)
-
-  private val wrong1 : Expr = BooleanLiteral(false)
-  assertInvalid(solver, wrong1)
-
-  private val wrong2 : Expr = Equals(Plus(x, x), Times(InfiniteIntegerLiteral(3), x))
-  assertInvalid(solver, wrong2)
-
-  // This is true, and FairZ3Solver should know it (by inlining).
-  private val unknown1 : Expr = Equals(f(x), Plus(x, InfiniteIntegerLiteral(1)))
-  assertValid(solver, unknown1)
-
-  test("Check assumptions") {
-    val b1 = Variable(FreshIdentifier("b", BooleanType))
-    val b2 = Variable(FreshIdentifier("b", BooleanType))
-
-    val f = And(b1, Not(b2))
-
-    locally {
-      val (result, _) = solver.solveSAT(f)
-      assert(result === Some(true))
-    }
-
-    locally {
-      val (result, _, core) = solver.solveSATWithCores(f, Set(b1))
-      assert(result === Some(true))
-      assert(core.isEmpty)
-    }
-
-    locally {
-      val (result, _, core) = solver.solveSATWithCores(f, Set(b1, b2))
-      assert(result === Some(false))
-      assert(core === Set(b2))
-    }
-  }
-}
diff --git a/src/test/scala/leon/test/solvers/z3/FairZ3SolverTestsNewAPI.scala b/src/test/scala/leon/test/solvers/z3/FairZ3SolverTestsNewAPI.scala
deleted file mode 100644
index 9a5355348698e4ef030110655505cdf257625bd9..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/solvers/z3/FairZ3SolverTestsNewAPI.scala
+++ /dev/null
@@ -1,133 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.solvers.z3
-
-import leon.test._
-import leon.purescala.Common._
-import leon.purescala.Definitions._
-import leon.purescala.Expressions._
-import leon.purescala.ExprOps._
-import leon.purescala.Types._
-
-import leon.solvers._
-import leon.solvers.z3._
-
-class FairZ3SolverTestsNewAPI extends LeonTestSuite {
-  private var testCounter : Int = 0
-  private def solverCheck(solver : SolverFactory[Solver], expr : Expr, expected : Option[Boolean], msg : String) = {
-    testCounter += 1
-
-    test("Solver test #" + testCounter) {
-      val sub = solver.getNewSolver()
-
-      try {
-        sub.assertCnstr(Not(expr))
-
-        assert(sub.check === expected.map(!_), msg)
-      } finally {
-        sub.free()
-      }
-    }
-  }
-
-  private def assertValid(solver : SolverFactory[Solver], expr : Expr) = solverCheck(
-    solver, expr, Some(true),
-    "Solver should prove the formula " + expr + " valid."
-  )
-
-  private def assertInvalid(solver : SolverFactory[Solver], expr : Expr) = solverCheck(
-    solver, expr, Some(false),
-    "Solver should prove the formula " + expr + " invalid."
-  )
-
-  private def assertUnknown(solver : SolverFactory[Solver], expr : Expr) = solverCheck(
-    solver, expr, None,
-    "Solver should not be able to decide the formula " + expr + "."
-  )
-
-  // def f(fx : Int) : Int = fx + 1
-  private val fx   : Identifier = FreshIdentifier("x", IntegerType)
-  private val fDef : FunDef = new FunDef(FreshIdentifier("f"), Nil, IntegerType, ValDef(fx) :: Nil)
-  fDef.body = Some(Plus(Variable(fx), InfiniteIntegerLiteral(1)))
-
-  private val minimalProgram = Program(
-    List(UnitDef(
-        FreshIdentifier("Minimal"),
-        List(ModuleDef(FreshIdentifier("Minimal"), Seq(fDef), false)
-    )))
-  )
-
-  private val x : Expr = Variable(FreshIdentifier("x", IntegerType))
-  private val y : Expr = Variable(FreshIdentifier("y", IntegerType))
-  private def f(e : Expr) : Expr = FunctionInvocation(fDef.typed, e :: Nil)
-
-  // TODO: refactor this entire suite to support SolverFactory.shutdown
-  private val solver = SolverFactory(() => new FairZ3Solver(testContext, minimalProgram))
-
-  private val tautology1 : Expr = BooleanLiteral(true)
-  assertValid(solver, tautology1)
-
-  private val tautology2 : Expr = Equals(Plus(x, x), Times(InfiniteIntegerLiteral(2), x))
-  assertValid(solver, tautology2)
-
-  // This one contains a function invocation but is valid regardless of its
-  // interpretation, so should be proved anyway.
-  private val tautology3 : Expr = Implies(
-    Not(Equals(f(x), f(y))),
-    Not(Equals(x, y))
-  )
-  assertValid(solver, tautology3)
-
-  private val wrong1 : Expr = BooleanLiteral(false)
-  assertInvalid(solver, wrong1)
-
-  private val wrong2 : Expr = Equals(Plus(x, x), Times(InfiniteIntegerLiteral(3), x))
-  assertInvalid(solver, wrong2)
-
-  // This is true, and FairZ3Solver should know it (by inlining).
-  private val unknown1 : Expr = Equals(f(x), Plus(x, InfiniteIntegerLiteral(1)))
-  assertValid(solver, unknown1)
-
-  test("Check assumptions") {
-    val b1 = Variable(FreshIdentifier("b", BooleanType))
-    val b2 = Variable(FreshIdentifier("b", BooleanType))
-
-    val f = And(b1, Not(b2))
-
-    locally {
-      val sub = solver.getNewSolver
-      try {
-        sub.assertCnstr(f)
-        assert(sub.check === Some(true))
-      } finally {
-        sub.free()
-      }
-    }
-
-    locally {
-      val sub = solver.getNewSolver()
-      try {
-        sub.assertCnstr(f)
-        val result = sub.checkAssumptions(Set(b1))
-
-        assert(result === Some(true))
-        assert(sub.getUnsatCore.isEmpty)
-      } finally {
-        sub.free()
-      }
-    }
-
-    locally {
-      val sub = solver.getNewSolver()
-      try {
-        sub.assertCnstr(f)
-
-        val result = sub.checkAssumptions(Set(b1, b2))
-        assert(result === Some(false))
-        assert(sub.getUnsatCore === Set(b2))
-      } finally {
-        sub.free()
-      }
-    }
-  }
-}
diff --git a/src/test/scala/leon/test/solvers/z3/UninterpretedZ3SolverTests.scala b/src/test/scala/leon/test/solvers/z3/UninterpretedZ3SolverTests.scala
deleted file mode 100644
index 99cd00bc9bd718076597310f9bf07e68a5e8ee4c..0000000000000000000000000000000000000000
--- a/src/test/scala/leon/test/solvers/z3/UninterpretedZ3SolverTests.scala
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.solvers.z3
-
-import leon.test._
-
-import leon.purescala.Common._
-import leon.purescala.Definitions._
-import leon.purescala.Expressions._
-import leon.purescala.ExprOps._
-import leon.purescala.Types._
-
-import leon.solvers._
-import leon.solvers.z3._
-
-class UninterpretedZ3SolverTests extends LeonTestSuite {
-  private var testCounter : Int = 0
-  private def solverCheck(solver : SimpleSolverAPI, expr : Expr, expected : Option[Boolean], msg : String) = {
-    testCounter += 1
-
-    test("Solver test #" + testCounter) {
-      assert(solver.solveVALID(expr) === expected, msg)
-    }
-  }
-
-  private def assertValid(solver : SimpleSolverAPI, expr : Expr) = solverCheck(
-    solver, expr, Some(true),
-    "Solver should prove the formula " + expr + " valid."
-  )
-
-  private def assertInvalid(solver : SimpleSolverAPI, expr : Expr) = solverCheck(
-    solver, expr, Some(false),
-    "Solver should prove the formula " + expr + " invalid."
-  )
-
-  private def assertUnknown(solver : SimpleSolverAPI, expr : Expr) = solverCheck(
-    solver, expr, None,
-    "Solver should not be able to decide the formula " + expr + "."
-  )
-
-  // def f(fx : Int) : Int = fx + 1
-  private val fx   : Identifier = FreshIdentifier("x", IntegerType)
-  private val fDef : FunDef = new FunDef(FreshIdentifier("f"), Nil, IntegerType, ValDef(fx) :: Nil)
-  fDef.body = Some(Plus(Variable(fx), InfiniteIntegerLiteral(1)))
-
-  // g is a function that is not in the program (on purpose)
-  private val gDef : FunDef = new FunDef(FreshIdentifier("g"), Nil, IntegerType, ValDef(fx) :: Nil)
-  gDef.body = Some(Plus(Variable(fx), InfiniteIntegerLiteral(1)))
-
-  private val minimalProgram = Program(
-    List(UnitDef(
-      FreshIdentifier("Minimal"),
-      List(ModuleDef(FreshIdentifier("Minimal"), Seq(fDef), false)
-    )))
-  )
-
-  private val x : Expr = Variable(FreshIdentifier("x", IntegerType))
-  private val y : Expr = Variable(FreshIdentifier("y", IntegerType))
-  private def f(e : Expr) : Expr = FunctionInvocation(fDef.typed, e :: Nil)
-  private def g(e : Expr) : Expr = FunctionInvocation(gDef.typed, e :: Nil)
-
-  // TODO: refactor this entire suite to support SolverFactory.shutdown
-  private val solver = SimpleSolverAPI(SolverFactory(() => new UninterpretedZ3Solver(testContext, minimalProgram)))
-
-  private val tautology1 : Expr = BooleanLiteral(true)
-  assertValid(solver, tautology1)
-
-  private val tautology2 : Expr = Equals(Plus(x, x), Times(InfiniteIntegerLiteral(2), x))
-  assertValid(solver, tautology2)
-
-  // This one contains a function invocation but is valid regardless of its
-  // interpretation, so should be proved anyway.
-  private val tautology3 : Expr = Implies(
-    Not(Equals(f(x), f(y))),
-    Not(Equals(x, y))
-  )
-  assertValid(solver, tautology3)
-
-  private val wrong1 : Expr = BooleanLiteral(false)
-  assertInvalid(solver, wrong1)
-
-  private val wrong2 : Expr = Equals(Plus(x, x), Times(InfiniteIntegerLiteral(3), x))
-  assertInvalid(solver, wrong2)
-
-  // This is true, but that solver shouldn't know it.
-  // However, since the uninterpreted solver is a nice backend for the unrolling solver,
-  // it makes more sense to allow such formulas even if they are not completely known
-  /*
-  private val unknown1 : Expr = Equals(f(x), Plus(x, InfiniteIntegerLiteral(1)))
-  assertUnknown(solver, unknown1)
-  */
-
-  assertValid(solver, Equals(g(x), g(x)))
-}
diff --git a/src/test/scala/leon/test/synthesis/AlgebraSuite.scala b/src/test/scala/leon/test/synthesis/AlgebraSuite.scala
index e60d3bbfcb8127736e9810def5ad493efe1ec7c2..e1d13fc9b488d80bd59a6133329c038c97c04688 100644
--- a/src/test/scala/leon/test/synthesis/AlgebraSuite.scala
+++ b/src/test/scala/leon/test/synthesis/AlgebraSuite.scala
@@ -7,7 +7,7 @@ import leon.synthesis.Algebra._
 
 class AlgebraSuite extends LeonTestSuite {
 
-  test("remainder") {
+  test("remainder") { ctx =>
     assert(remainder(1,1) === 0)
     assert(remainder(2,2) === 0)
     assert(remainder(2,1) === 0)
@@ -36,7 +36,7 @@ class AlgebraSuite extends LeonTestSuite {
     assert(remainder(-25,5) === 0)
   }
 
-  test("divide") {
+  test("divide") { ctx =>
     assert(divide(1,1) === (1, 0))
     assert(divide(2,2) === (1, 0))
     assert(divide(2,1) === (2, 0))
@@ -65,7 +65,7 @@ class AlgebraSuite extends LeonTestSuite {
     assert(divide(-25,5) === (-5, 0))
   }
 
-  test("binary gcd") {
+  test("binary gcd") { ctx =>
     assert(gcd(1,1) === 1)
     assert(gcd(1,3) === 1)
     assert(gcd(3,1) === 1)
@@ -90,7 +90,7 @@ class AlgebraSuite extends LeonTestSuite {
     assert(gcd(-4,-8) === 4)
   }
 
-  test("n-ary gcd") {
+  test("n-ary gcd") { ctx =>
     assert(gcd(1,1,1) === 1)
     assert(gcd(1,3,5) === 1)
     assert(gcd(3,1,2) === 1)
@@ -118,7 +118,7 @@ class AlgebraSuite extends LeonTestSuite {
     assert(gcd(-2,-4,-8,-11,-16,-4) === 1)
   }
 
-  test("seq gcd") {
+  test("seq gcd") { ctx =>
     assert(gcd(Seq(1)) === 1)
     assert(gcd(Seq(4)) === 4)
     assert(gcd(Seq(7)) === 7)
@@ -151,7 +151,7 @@ class AlgebraSuite extends LeonTestSuite {
     assert(gcd(Seq(-2,-4,-8,-11,-16,-4)) === 1)
   }
 
-  test("binary lcm") {
+  test("binary lcm") { ctx =>
     assert(lcm(1,3) === 3)
     assert(lcm(1,1) === 1)
     assert(lcm(0,1) === 0)
@@ -160,12 +160,12 @@ class AlgebraSuite extends LeonTestSuite {
     assert(lcm(4,6) === 12)
     assert(lcm(8,6) === 24)
   }
-  test("n-ary lcm") {
+  test("n-ary lcm") { ctx =>
     assert(lcm(1,2,3) === 6)
     assert(lcm(1,2,3,4) === 12)
     assert(lcm(5,2,3,4) === 60)
   }
-  test("seq lcm") {
+  test("seq lcm") { ctx =>
     assert(lcm(Seq(1,2,3)) === 6)
     assert(lcm(Seq(1,2,3,4)) === 12)
     assert(lcm(Seq(5,2,3,4)) === 60)
@@ -176,7 +176,7 @@ class AlgebraSuite extends LeonTestSuite {
     assert(x*a + y*b === gcd(a, b))
   }
 
-  test("extendedEuclid") {
+  test("extendedEuclid") { ctx =>
     checkExtendedEuclid(1, 1)
     checkExtendedEuclid(3, 1)
     checkExtendedEuclid(1, 2)
diff --git a/src/test/scala/leon/test/synthesis/LinearEquationsSuite.scala b/src/test/scala/leon/test/synthesis/LinearEquationsSuite.scala
index 2c53108a722481e9292a39f291d7013ef1b4238a..62c2ac92309ef75b75af9bfa2ba19fea914002b1 100644
--- a/src/test/scala/leon/test/synthesis/LinearEquationsSuite.scala
+++ b/src/test/scala/leon/test/synthesis/LinearEquationsSuite.scala
@@ -3,45 +3,26 @@
 package leon.test.synthesis
 import leon.test._
 
+import leon.LeonContext
 import leon.purescala.Expressions._
 import leon.purescala.Types._
 import leon.purescala.ExprOps._
 import leon.purescala.Common._
 import leon.purescala.Definitions._
-import leon.test.purescala.WithLikelyEq
 import leon.evaluators._
 
 import leon.synthesis.LinearEquations._
 
-class LinearEquationsSuite extends LeonTestSuite with WithLikelyEq {
-
-  def i(x: Int) = InfiniteIntegerLiteral(x)
-
-  val xId = FreshIdentifier("x", IntegerType)
-  val x = Variable(xId)
-  val yId = FreshIdentifier("y", IntegerType)
-  val y = Variable(yId)
-  val zId = FreshIdentifier("z", IntegerType)
-  val z = Variable(zId)
-
-  val aId = FreshIdentifier("a", IntegerType)
-  val a = Variable(aId)
-  val bId = FreshIdentifier("b", IntegerType)
-  val b = Variable(bId)
-
-  def toSum(es: Seq[Expr]) = es.reduceLeft(Plus)
-  
-  def checkSameExpr(e1: Expr, e2: Expr, vs: Set[Identifier], prec: Expr, defaultMap: Map[Identifier, Expr] = Map()) {
-    assert( //this outer assert should not be needed because of the nested one
-      LikelyEq(e1, e2, vs, prec, (e1, e2) => {assert(e1 === e2); true}, defaultMap)
-    )
-  }
+class LinearEquationsSuite extends LeonTestSuite with helpers.WithLikelyEq with helpers.ExpressionsDSL {
 
+  val aa = FreshIdentifier("aa", IntegerType).toVariable
+  val bb = FreshIdentifier("bb", IntegerType).toVariable
 
   //use some random values to check that any vector in the basis is a valid solution to
   //the equation
   def checkVectorSpace(basis: Array[Array[Int]], equation: Array[Int]): Unit = 
     checkVectorSpace(basis.map(_.map(i => BigInt(i))), equation.map(i => BigInt(i)))
+
   def checkVectorSpace(basis: Array[Array[BigInt]], equation: Array[BigInt]): Unit = {
     require(basis.length == basis(0).length + 1 && basis.length == equation.length)
     val n = basis(0).length
@@ -70,6 +51,10 @@ class LinearEquationsSuite extends LeonTestSuite with WithLikelyEq {
     }
   }
 
+  def checkSameExpr(e1: Expr, e2: Expr, pre: Expr, vs: Map[Identifier, Expr] = Map())(implicit ctx: LeonContext): Unit = {
+    checkLikelyEq(ctx)(e1, e2, Some(pre), vs)
+  }
+
   //val that the sol vector with the term in the equation
   def eval(sol: Array[BigInt], equation: Array[BigInt]): BigInt = {
     require(sol.length == equation.length)
@@ -96,74 +81,74 @@ class LinearEquationsSuite extends LeonTestSuite with WithLikelyEq {
     v1.zip(v2).map(p => p._1 + p._2)
   }
 
-  test("checkVectorSpace") {
+  test("checkVectorSpace") { implicit ctx =>
     checkVectorSpace(Array(Array(1), Array(2)), Array(-2, 1))
     checkVectorSpace(Array(Array(4, 0), Array(-3, 2), Array(0, -1)), Array(3, 4, 8))
   }
 
   
-  test("particularSolution basecase") {
+  test("particularSolution basecase") { implicit ctx =>
     def toExpr(es: Array[Expr]): Expr = {
-      val vars: Array[Expr] = Array[Expr](i(1)) ++ Array[Expr](x, y)
-      es.zip(vars).foldLeft[Expr](i(0))( (acc: Expr, p: (Expr, Expr)) => Plus(acc, Times(p._1, p._2)) )
+      val vars: Array[Expr] = Array[Expr](bi(1)) ++ Array[Expr](x, y)
+      es.zip(vars).foldLeft[Expr](bi(0))( (acc: Expr, p: (Expr, Expr)) => Plus(acc, Times(p._1, p._2)) )
     }
 
-    val t1: Expr = Plus(a, b)
-    val c1: Expr = i(4)
-    val d1: Expr = i(22)
+    val t1: Expr = Plus(aa, bb)
+    val c1: Expr = bi(4)
+    val d1: Expr = bi(22)
     val e1: Array[Expr] = Array(t1, c1, d1)
-    val (pre1, (w1, w2)) = particularSolution(Set(aId, bId), t1, c1, d1)
-    checkSameExpr(toExpr(e1), i(0), Set(aId, bId), pre1, Map(xId -> w1, yId -> w2))
+    val (pre1, (w1, w2)) = particularSolution(Set(aa.id, bb.id), t1, c1, d1)
+    checkSameExpr(toExpr(e1), bi(0), pre1, Map(x.id -> w1, y.id -> w2))
 
-    val t2: Expr = i(-1)
-    val c2: Expr = i(1)
-    val d2: Expr = i(-1)
+    val t2: Expr = bi(-1)
+    val c2: Expr = bi(1)
+    val d2: Expr = bi(-1)
     val e2: Array[Expr] = Array(t2, c2, d2)
     val (pre2, (w3, w4)) = particularSolution(Set(), t2, c2, d2)
-    checkSameExpr(toExpr(e2), i(0), Set(), pre2, Map(xId -> w3, yId -> w4))
+    checkSameExpr(toExpr(e2), bi(0), pre2, Map(x.id -> w3, y.id -> w4))
   }
 
-  test("particularSolution preprocess") {
+  test("particularSolution preprocess") { implicit ctx =>
     def toExpr(es: Array[Expr], vs: Array[Expr]): Expr = {
-      val vars: Array[Expr] = Array[Expr](i(1)) ++ vs
-      es.zip(vars).foldLeft[Expr](i(0))( (acc: Expr, p: (Expr, Expr)) => Plus(acc, Times(p._1, p._2)) )
+      val vars: Array[Expr] = Array[Expr](bi(1)) ++ vs
+      es.zip(vars).foldLeft[Expr](bi(0))( (acc: Expr, p: (Expr, Expr)) => Plus(acc, Times(p._1, p._2)) )
     }
 
-    val t1: Expr = Plus(a, b)
-    val c1: Expr = i(4)
-    val d1: Expr = i(22)
+    val t1: Expr = Plus(aa, bb)
+    val c1: Expr = bi(4)
+    val d1: Expr = bi(22)
     val e1: Array[Expr] = Array(t1, c1, d1)
-    val (pre1, s1) = particularSolution(Set(aId, bId), e1.toList)
-    checkSameExpr(toExpr(e1, Array(x, y)), i(0), Set(aId, bId), pre1, Array(xId, yId).zip(s1).toMap)
+    val (pre1, s1) = particularSolution(Set(aa.id, bb.id), e1.toList)
+    checkSameExpr(toExpr(e1, Array(x, y)), bi(0), pre1, Array(x.id, y.id).zip(s1).toMap)
 
-    val t2: Expr = Plus(a, b)
-    val c2: Expr = i(4)
-    val d2: Expr = i(22)
-    val f2: Expr = i(10)
+    val t2: Expr = Plus(aa, bb)
+    val c2: Expr = bi(4)
+    val d2: Expr = bi(22)
+    val f2: Expr = bi(10)
     val e2: Array[Expr] = Array(t2, c2, d2, f2)
-    val (pre2, s2) = particularSolution(Set(aId, bId), e2.toList)
-    checkSameExpr(toExpr(e2, Array(x, y, z)), i(0), Set(aId, bId), pre2, Array(xId, yId, zId).zip(s2).toMap)
+    val (pre2, s2) = particularSolution(Set(aa.id, bb.id), e2.toList)
+    checkSameExpr(toExpr(e2, Array(x, y, z)), bi(0), pre2, Array(x.id, y.id, z.id).zip(s2).toMap)
 
-    val t3: Expr = Plus(a, Times(i(2), b))
-    val c3: Expr = i(6)
-    val d3: Expr = i(24)
-    val f3: Expr = i(9)
+    val t3: Expr = Plus(aa, Times(bi(2), bb))
+    val c3: Expr = bi(6)
+    val d3: Expr = bi(24)
+    val f3: Expr = bi(9)
     val e3: Array[Expr] = Array(t3, c3, d3, f3)
-    val (pre3, s3) = particularSolution(Set(aId, bId), e3.toList)
-    checkSameExpr(toExpr(e3, Array(x, y, z)), i(0), Set(aId, bId), pre3, Array(xId, yId, zId).zip(s3).toMap)
+    val (pre3, s3) = particularSolution(Set(aa.id, bb.id), e3.toList)
+    checkSameExpr(toExpr(e3, Array(x, y, z)), bi(0), pre3, Array(x.id, y.id, z.id).zip(s3).toMap)
 
-    val t4: Expr = Plus(a, b)
-    val c4: Expr = i(4)
+    val t4: Expr = Plus(aa, bb)
+    val c4: Expr = bi(4)
     val e4: Array[Expr] = Array(t4, c4)
-    val (pre4, s4) = particularSolution(Set(aId, bId), e4.toList)
-    checkSameExpr(toExpr(e4, Array(x)), i(0), Set(aId, bId), pre4, Array(xId).zip(s4).toMap)
+    val (pre4, s4) = particularSolution(Set(aa.id, bb.id), e4.toList)
+    checkSameExpr(toExpr(e4, Array(x)), bi(0), pre4, Array(x.id).zip(s4).toMap)
   }
 
 
-  test("linearSet") {
+  test("linearSet") { implicit ctx =>
     val as = Set[Identifier]()
 
-    val evaluator = new DefaultEvaluator(testContext, Program.empty)
+    val evaluator = new DefaultEvaluator(ctx, Program.empty)
 
     val eq1 = Array[BigInt](3, 4, 8)
     val basis1 = linearSet(evaluator, as, eq1)
@@ -216,43 +201,43 @@ class LinearEquationsSuite extends LeonTestSuite with WithLikelyEq {
   }
 
   //TODO: automatic check result
-  test("elimVariable") {
-    val as = Set[Identifier](aId, bId)
+  test("elimVariable") { implicit ctx =>
+    val as = Set[Identifier](aa.id, bb.id)
 
-    val evaluator = new DefaultEvaluator(testContext, Program.empty)
+    val evaluator = new DefaultEvaluator(ctx, Program.empty)
 
     def check(t: Expr, c: List[Expr], prec: Expr, witnesses: List[Expr], freshVars: List[Identifier]) {
       enumerate(freshVars.size, (vals: Array[Int]) => {
-        val mapping: Map[Expr, Expr] = freshVars.zip(vals.toList).map(t => (Variable(t._1), i(t._2))).toMap
-        val cWithVars: Expr = c.zip(witnesses).foldLeft[Expr](i(0)){ case (acc, (coef, wit)) => Plus(acc, Times(coef, replace(mapping, wit))) }
-        checkSameExpr(Plus(t, cWithVars), i(0), as, prec)
+        val mapping: Map[Expr, Expr] = freshVars.zip(vals.toList).map(t => (Variable(t._1), bi(t._2))).toMap
+        val cWithVars: Expr = c.zip(witnesses).foldLeft[Expr](bi(0)){ case (acc, (coef, wit)) => Plus(acc, Times(coef, replace(mapping, wit))) }
+        checkSameExpr(Plus(t, cWithVars), bi(0), prec)
       })
     }
 
-    val t1 = Minus(Times(i(2), a), b)
-    val c1 = List(i(3), i(4), i(8))
+    val t1 = Minus(Times(bi(2), aa), bb)
+    val c1 = List(bi(3), bi(4), bi(8))
     val (pre1, wit1, f1) = elimVariable(evaluator, as, t1::c1)
     check(t1, c1, pre1, wit1, f1)
 
-    val t2 = Plus(Plus(i(0), i(2)), Times(i(-1), i(3)))
-    val c2 = List(i(1), i(-1))
+    val t2 = Plus(Plus(bi(0), bi(2)), Times(bi(-1), bi(3)))
+    val c2 = List(bi(1), bi(-1))
     val (pre2, wit2, f2) = elimVariable(evaluator, Set(), t2::c2)
     check(t2, c2, pre2, wit2, f2)
 
 
-    val t3 = Minus(Times(i(2), a), i(3))
-    val c3 = List(i(2))
-    val (pre3, wit3, f3) = elimVariable(evaluator, Set(aId), t3::c3)
+    val t3 = Minus(Times(bi(2), aa), bi(3))
+    val c3 = List(bi(2))
+    val (pre3, wit3, f3) = elimVariable(evaluator, Set(aa.id), t3::c3)
     check(t3, c3, pre3, wit3, f3)
 
-    val t4 = Times(i(2), a)
-    val c4 = List(i(2), i(4))
-    val (pre4, wit4, f4) = elimVariable(evaluator, Set(aId), t4::c4)
+    val t4 = Times(bi(2), aa)
+    val c4 = List(bi(2), bi(4))
+    val (pre4, wit4, f4) = elimVariable(evaluator, Set(aa.id), t4::c4)
     check(t4, c4, pre4, wit4, f4)
 
-    val t5 = Minus(a, b)
-    val c5 = List(i(-60), i(-3600))
-    val (pre5, wit5, f5) = elimVariable(evaluator, Set(aId, bId), t5::c5)
+    val t5 = Minus(aa, bb)
+    val c5 = List(bi(-60), bi(-3600))
+    val (pre5, wit5, f5) = elimVariable(evaluator, Set(aa.id, bb.id), t5::c5)
     check(t5, c5, pre5, wit5, f5)
 
   }
diff --git a/src/test/scala/leon/test/utils/StreamsSuite.scala b/src/test/scala/leon/test/utils/StreamsSuite.scala
index ac0ab2e226bddd0f0fd6272783f74845abb94a78..9d3b069bd07eac8374afc133d6dcd362e8b773b7 100644
--- a/src/test/scala/leon/test/utils/StreamsSuite.scala
+++ b/src/test/scala/leon/test/utils/StreamsSuite.scala
@@ -7,7 +7,7 @@ import leon.purescala.Common._
 import leon.utils.StreamUtils._
 
 class StreamsSuite extends LeonTestSuite {
-  test("Cartesian Product 1") {
+  test("Cartesian Product 1") { ctx =>
     val s1 = FreshIdentifier("B", alwaysShowUniqueID = true) #::
              FreshIdentifier("B", alwaysShowUniqueID = true) #::
              FreshIdentifier("B", alwaysShowUniqueID = true) #::
@@ -25,7 +25,7 @@ class StreamsSuite extends LeonTestSuite {
 
   }
 
-  test("Cartesian Product 2") {
+  test("Cartesian Product 2") { ctx =>
     val s1 = FreshIdentifier("B", alwaysShowUniqueID = true) #::
              FreshIdentifier("B", alwaysShowUniqueID = true) #::
              FreshIdentifier("B", alwaysShowUniqueID = true) #::
@@ -45,7 +45,7 @@ class StreamsSuite extends LeonTestSuite {
   }
 
 
-  test("Cartesian Product 3") {
+  test("Cartesian Product 3") { ctx =>
     val s1 = 1 #::
              2 #::
              3 #::
diff --git a/src/unit-test/scala/leon/utils/UtilsPackageSuite.scala b/src/test/scala/leon/test/utils/UtilsSuite.scala
similarity index 78%
rename from src/unit-test/scala/leon/utils/UtilsPackageSuite.scala
rename to src/test/scala/leon/test/utils/UtilsSuite.scala
index 186e1ddd8f216fa486a2026758fb0068f499a88e..55f798ec8b76c355395632747a9a0c26b07fba71 100644
--- a/src/unit-test/scala/leon/utils/UtilsPackageSuite.scala
+++ b/src/test/scala/leon/test/utils/UtilsSuite.scala
@@ -1,29 +1,30 @@
 /* Copyright 2009-2015 EPFL, Lausanne */
 
-package leon
-package utils
+package leon.test
 
-class UtilsPackageSuite extends LeonTestSuite {
+import leon.utils._
 
-  test("fixpoint computes correct fixpoint of function that increments up to a max") {
+class UtilsSuite extends LeonTestSuite {
+
+  test("fixpoint computes correct fixpoint of function that increments up to a max") { ctx =>
     def f(x: Int): Int = if(x < 10) x + 1 else 10
     assert(f(10) === 10)
     assert(fixpoint(f)(1) === 10)
   }
 
-  test("fixpoint computes correct fixpoint with a large limit") {
+  test("fixpoint computes correct fixpoint with a large limit") { ctx =>
     def f(x: Int): Int = if(x < 100) x + 1 else 100
     assert(f(100) === 100)
     assert(fixpoint(f)(-1) === 100)
   }
 
-  test("fixpoint finds the fixpoint in small number of iteration") {
+  test("fixpoint finds the fixpoint in small number of iteration") { ctx =>
     def f(x: Int): Int = if(x < 10) x + 1 else 10
     assert(f(10) === 10)
     assert(fixpoint(f, 15)(1) === 10)
   }
 
-  test("fixpoint of id is the starting expression") {
+  test("fixpoint of id is the starting expression") { ctx =>
     def id(x: Int): Int = x
     assert(fixpoint(id)(1) === 1)
     assert(fixpoint(id)(42) === 42)
diff --git a/src/unit-test/scala/leon/LeonTestSuite.scala b/src/unit-test/scala/leon/LeonTestSuite.scala
deleted file mode 100644
index 050ddf976980986b46084e681f3da06ae8a84d84..0000000000000000000000000000000000000000
--- a/src/unit-test/scala/leon/LeonTestSuite.scala
+++ /dev/null
@@ -1,105 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon
-
-import utils._
-
-import org.scalatest._
-import org.scalatest.exceptions.TestFailedException
-
-trait LeonTestSuite extends FunSuite {
-
-  def createLeonContext(opts: String*): LeonContext = {
-    val reporter = new TestSilentReporter
-
-    Main.processOptions(opts.toList).copy(reporter = reporter, interruptManager = new InterruptManager(reporter))
-  }
-
-  //var testContext: LeonContext = null
-
-  //override def beforeEach() = {
-  //  testContext = createLeonContext()
-  //  super.beforeEach()
-  //}
-
-  //def testIdentifier(name: String): String = {
-  //  def sanitize(s: String) = s.replaceAll("[^0-9a-zA-Z-]", "")
-
-  //  sanitize(this.getClass.getName)+"/"+sanitize(name)
-  //}
-
-  //def bookKeepingFile(id: String) = {
-  //  import java.io.File
-
-  //  val f = new File(System.getProperty("user.dir")+"/.test-history/"+id+".log")
-
-  //  f.getParentFile.mkdirs()
-
-  //  f
-  //}
-
-  //def getStats(id: String): Statistics = {
-  //  val f = bookKeepingFile(id)
-
-  //  if (f.canRead) {
-  //    Statistics(Source.fromFile(f).getLines().flatMap{ line =>
-  //      val l = line.trim
-  //      if (l.length > 0) {
-  //        Some(line.toLong)
-  //      } else {
-  //        None
-  //      }
-  //    }.toList)
-  //  } else {
-  //    Statistics(Nil)
-  //  }
-  //}
-
-  //def storeStats(id: String, stats: Statistics) {
-  //  import java.io.FileWriter
-
-  //  val f = bookKeepingFile(id)
-
-  //  val fw = new FileWriter(f, true)
-  //  fw.write(stats.values.head+"\n")
-  //  fw.close()
-  //}
-
-  //override implicit val defaultInterruptor = new Interruptor {
-  //  def apply(t: Thread) {
-  //    testContext.interruptManager.interrupt()
-  //  }
-  //}
-
-  //def testWithTimeout(name: String, timeout: Span)(body: => Unit) {
-  //  super.test(name) {
-  //    val id = testIdentifier(name)
-
-  //    val ts = now()
-
-  //    failAfter(timeout) {
-  //      try {
-  //        body
-  //      } catch {
-  //        case fe: LeonFatalError =>
-  //          testContext.reporter match {
-  //            case sr: TestSilentReporter =>
-  //              sr.lastErrors ++= fe.msg
-  //              throw new TestFailedException(sr.lastErrors.mkString("\n"), fe, 5)
-  //          }
-  //      }
-  //    }
-
-  //    val total = now()-ts
-
-  //    val stats = getStats(id)
-
-  //    if (!stats.accountsFor(total)) {
-  //      info(Console.YELLOW+"[warning] Test took too long to run: "+total+"ms (avg: "+stats.avg+", stddev: "+stats.stddev+")")
-  //    }
-
-  //    storeStats(id, stats.withValue(total))
-  //  }
-  //}
-
-}
diff --git a/src/unit-test/scala/leon/evaluators/DefaultEvaluatorSuite.scala b/src/unit-test/scala/leon/evaluators/DefaultEvaluatorSuite.scala
deleted file mode 100644
index 8ac29542fc1a2ee0f78a2bae5bdb9e5eedc47022..0000000000000000000000000000000000000000
--- a/src/unit-test/scala/leon/evaluators/DefaultEvaluatorSuite.scala
+++ /dev/null
@@ -1,359 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon
-package evaluators
-
-import leon._
-import leon.evaluators._
-import leon.purescala.Common._
-import leon.purescala.Definitions._
-import leon.purescala.Expressions._
-import leon.purescala.Types._
-import leon.purescala.Constructors._
-
-class DefaultEvaluatorSuite extends leon.test.LeonTestSuite {
-
-  private implicit lazy val leonContext: LeonContext = createLeonContext()
-  private val emptyProgram = Program.empty
-
-  private val defaultEvaluator = new DefaultEvaluator(leonContext, emptyProgram)
-
-  def expectSuccessful(res: EvaluationResults.Result, expected: Expr): Unit = {
-    res match {
-      case EvaluationResults.Successful(value) => assert(value === expected)
-      case _ => assert(false)
-    }
-  }
-
-  test("eval correctly evaluates literals") {
-    expectSuccessful(defaultEvaluator.eval(BooleanLiteral(true)), BooleanLiteral(true))
-    expectSuccessful(defaultEvaluator.eval(BooleanLiteral(false)), BooleanLiteral(false))
-    expectSuccessful(defaultEvaluator.eval(IntLiteral(0)), IntLiteral(0))
-    expectSuccessful(defaultEvaluator.eval(IntLiteral(42)), IntLiteral(42))
-    expectSuccessful(defaultEvaluator.eval(UnitLiteral()), UnitLiteral())
-    expectSuccessful(defaultEvaluator.eval(InfiniteIntegerLiteral(0)), InfiniteIntegerLiteral(0))
-    expectSuccessful(defaultEvaluator.eval(InfiniteIntegerLiteral(42)), InfiniteIntegerLiteral(42))
-    expectSuccessful(defaultEvaluator.eval(RealLiteral(0)), RealLiteral(0))
-    expectSuccessful(defaultEvaluator.eval(RealLiteral(42)), RealLiteral(42))
-    expectSuccessful(defaultEvaluator.eval(RealLiteral(13.255)), RealLiteral(13.255))
-  }
-
-  test("eval of simple bit vector arithmetic expressions") {
-    expectSuccessful(defaultEvaluator.eval(BVPlus(IntLiteral(3), IntLiteral(5))), IntLiteral(8))
-    expectSuccessful(defaultEvaluator.eval(BVPlus(IntLiteral(0), IntLiteral(5))), IntLiteral(5))
-    expectSuccessful(defaultEvaluator.eval(BVTimes(IntLiteral(3), IntLiteral(3))), IntLiteral(9))
-  }
-
-  test("eval bitwise operations") {
-    expectSuccessful(defaultEvaluator.eval(BVAnd(IntLiteral(3), IntLiteral(1))), IntLiteral(1))
-    expectSuccessful(defaultEvaluator.eval(BVAnd(IntLiteral(3), IntLiteral(3))), IntLiteral(3))
-    expectSuccessful(defaultEvaluator.eval(BVAnd(IntLiteral(5), IntLiteral(3))), IntLiteral(1))
-    expectSuccessful(defaultEvaluator.eval(BVAnd(IntLiteral(5), IntLiteral(4))), IntLiteral(4))
-    expectSuccessful(defaultEvaluator.eval(BVAnd(IntLiteral(5), IntLiteral(2))), IntLiteral(0))
-
-    expectSuccessful(defaultEvaluator.eval(BVOr(IntLiteral(3), IntLiteral(1))), IntLiteral(3))
-    expectSuccessful(defaultEvaluator.eval(BVOr(IntLiteral(3), IntLiteral(3))), IntLiteral(3))
-    expectSuccessful(defaultEvaluator.eval(BVOr(IntLiteral(5), IntLiteral(3))), IntLiteral(7))
-    expectSuccessful(defaultEvaluator.eval(BVOr(IntLiteral(5), IntLiteral(4))), IntLiteral(5))
-    expectSuccessful(defaultEvaluator.eval(BVOr(IntLiteral(5), IntLiteral(2))), IntLiteral(7))
-
-    expectSuccessful(defaultEvaluator.eval(BVXOr(IntLiteral(3), IntLiteral(1))), IntLiteral(2))
-    expectSuccessful(defaultEvaluator.eval(BVXOr(IntLiteral(3), IntLiteral(3))), IntLiteral(0))
-
-    expectSuccessful(defaultEvaluator.eval(BVNot(IntLiteral(1))), IntLiteral(-2))
-
-    expectSuccessful(defaultEvaluator.eval(BVShiftLeft(IntLiteral(3), IntLiteral(1))), IntLiteral(6))
-    expectSuccessful(defaultEvaluator.eval(BVShiftLeft(IntLiteral(4), IntLiteral(2))), IntLiteral(16))
-
-    expectSuccessful(defaultEvaluator.eval(BVLShiftRight(IntLiteral(8), IntLiteral(1))), IntLiteral(4))
-    expectSuccessful(defaultEvaluator.eval(BVAShiftRight(IntLiteral(8), IntLiteral(1))), IntLiteral(4))
-  }
-
-  test("eval of simple arithmetic expressions") {
-    expectSuccessful(
-      defaultEvaluator.eval(Plus(InfiniteIntegerLiteral(3), InfiniteIntegerLiteral(5))), 
-      InfiniteIntegerLiteral(8))
-    expectSuccessful(
-      defaultEvaluator.eval(Minus(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(2))), 
-      InfiniteIntegerLiteral(5))
-    expectSuccessful(
-      defaultEvaluator.eval(UMinus(InfiniteIntegerLiteral(7))),
-      InfiniteIntegerLiteral(-7))
-    expectSuccessful(
-      defaultEvaluator.eval(Times(InfiniteIntegerLiteral(2), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(6))
-  }
-
-  test("Eval of division, remainder and modulo semantics for BigInt") {
-    expectSuccessful(
-      defaultEvaluator.eval(Division(InfiniteIntegerLiteral(10), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(3))
-    expectSuccessful(
-      defaultEvaluator.eval(Remainder(InfiniteIntegerLiteral(10), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(1))
-    expectSuccessful(
-      defaultEvaluator.eval(Modulo(InfiniteIntegerLiteral(10), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(1))
-
-    expectSuccessful(
-      defaultEvaluator.eval(Division(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(Remainder(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(-1))
-    expectSuccessful(
-      defaultEvaluator.eval(Modulo(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(3))), 
-      InfiniteIntegerLiteral(2))
-
-    expectSuccessful(
-      defaultEvaluator.eval(Division(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(Remainder(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(-1))
-    expectSuccessful(
-      defaultEvaluator.eval(Modulo(InfiniteIntegerLiteral(-1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(2))
-
-    expectSuccessful(
-      defaultEvaluator.eval(Division(InfiniteIntegerLiteral(1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(Remainder(InfiniteIntegerLiteral(1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(1))
-    expectSuccessful(
-      defaultEvaluator.eval(Modulo(InfiniteIntegerLiteral(1), InfiniteIntegerLiteral(-3))), 
-      InfiniteIntegerLiteral(1))
-  }
-
-  test("eval of simple arithmetic comparisons over integers") {
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7))), BooleanLiteral(false)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7))), BooleanLiteral(false)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7))), BooleanLiteral(true)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(4))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(InfiniteIntegerLiteral(7), InfiniteIntegerLiteral(7))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(InfiniteIntegerLiteral(4), InfiniteIntegerLiteral(7))), BooleanLiteral(true)
-    )
-  }
-
-
-  test("Eval of division and remainder semantics for bit vectors") {
-    expectSuccessful(
-      defaultEvaluator.eval(BVDivision(IntLiteral(10), IntLiteral(3))), 
-      IntLiteral(3))
-    expectSuccessful(
-      defaultEvaluator.eval(BVRemainder(IntLiteral(10), IntLiteral(3))), 
-      IntLiteral(1))
-
-    expectSuccessful(
-      defaultEvaluator.eval(BVDivision(IntLiteral(-1), IntLiteral(3))), 
-      IntLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(BVRemainder(IntLiteral(-1), IntLiteral(3))), 
-      IntLiteral(-1))
-
-    expectSuccessful(
-      defaultEvaluator.eval(BVDivision(IntLiteral(-1), IntLiteral(-3))), 
-      IntLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(BVRemainder(IntLiteral(-1), IntLiteral(-3))), 
-      IntLiteral(-1))
-
-    expectSuccessful(
-      defaultEvaluator.eval(BVDivision(IntLiteral(1), IntLiteral(-3))), 
-      IntLiteral(0))
-    expectSuccessful(
-      defaultEvaluator.eval(BVRemainder(IntLiteral(1), IntLiteral(-3))), 
-      IntLiteral(1))
-  }
-
-  test("Eval of simple boolean operations") {
-    expectSuccessful(
-      defaultEvaluator.eval(And(BooleanLiteral(true), BooleanLiteral(true))),
-      BooleanLiteral(true))
-    expectSuccessful(
-      defaultEvaluator.eval(And(BooleanLiteral(true), BooleanLiteral(false))),
-      BooleanLiteral(false))
-    expectSuccessful(
-      defaultEvaluator.eval(And(BooleanLiteral(false), BooleanLiteral(false))),
-      BooleanLiteral(false))
-    expectSuccessful(
-      defaultEvaluator.eval(And(BooleanLiteral(false), BooleanLiteral(true))),
-      BooleanLiteral(false))
-    expectSuccessful(
-      defaultEvaluator.eval(Or(BooleanLiteral(true), BooleanLiteral(true))),
-      BooleanLiteral(true))
-    expectSuccessful(
-      defaultEvaluator.eval(Or(BooleanLiteral(true), BooleanLiteral(false))),
-      BooleanLiteral(true))
-    expectSuccessful(
-      defaultEvaluator.eval(Or(BooleanLiteral(false), BooleanLiteral(false))),
-      BooleanLiteral(false))
-    expectSuccessful(
-      defaultEvaluator.eval(Or(BooleanLiteral(false), BooleanLiteral(true))),
-      BooleanLiteral(true))
-    expectSuccessful(
-      defaultEvaluator.eval(Not(BooleanLiteral(false))),
-      BooleanLiteral(true))
-    expectSuccessful(
-      defaultEvaluator.eval(Not(BooleanLiteral(true))),
-      BooleanLiteral(false))
-  }
-
-  test("eval of simple arithmetic expressions over real") {
-    expectSuccessful(
-      defaultEvaluator.eval(RealPlus(RealLiteral(3), RealLiteral(5))), 
-      RealLiteral(8))
-    expectSuccessful(
-      defaultEvaluator.eval(RealMinus(RealLiteral(7), RealLiteral(2))), 
-      RealLiteral(5))
-    expectSuccessful(
-      defaultEvaluator.eval(RealUMinus(RealLiteral(7))),
-      RealLiteral(-7))
-    expectSuccessful(
-      defaultEvaluator.eval(RealTimes(RealLiteral(2), RealLiteral(3))), 
-      RealLiteral(6))
-
-    expectSuccessful(
-      defaultEvaluator.eval(RealPlus(RealLiteral(2.5), RealLiteral(3.5))), 
-      RealLiteral(6))
-  }
-
-  test("eval of simple arithmetic comparisons over real") {
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(RealLiteral(7), RealLiteral(4))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(RealLiteral(7), RealLiteral(7))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterEquals(RealLiteral(4), RealLiteral(7))), BooleanLiteral(false)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(RealLiteral(7), RealLiteral(4))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(RealLiteral(7), RealLiteral(7))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(GreaterThan(RealLiteral(4), RealLiteral(7))), BooleanLiteral(false)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(RealLiteral(7), RealLiteral(4))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(RealLiteral(7), RealLiteral(7))), BooleanLiteral(true)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessEquals(RealLiteral(4), RealLiteral(7))), BooleanLiteral(true)
-    )
-
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(RealLiteral(7), RealLiteral(4))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(RealLiteral(7), RealLiteral(7))), BooleanLiteral(false)
-    )
-    expectSuccessful(
-      defaultEvaluator.eval(LessThan(RealLiteral(4), RealLiteral(7))), BooleanLiteral(true)
-    )
-  }
-
-  test("eval simple variable") {
-    val id = FreshIdentifier("id", Int32Type)
-    expectSuccessful(
-      defaultEvaluator.eval(Variable(id), Map(id -> IntLiteral(23))),
-      IntLiteral(23))
-  }
-
-  test("eval with unbound variable should return EvaluatorError") {
-    val id = FreshIdentifier("id", Int32Type)
-    val foo = FreshIdentifier("foo", Int32Type)
-    val res = defaultEvaluator.eval(Variable(id), Map(foo -> IntLiteral(23)))
-    assert(res.isInstanceOf[EvaluationResults.EvaluatorError])
-  }
-
-  test("eval let expression") {
-    val id = FreshIdentifier("id")
-    expectSuccessful(
-      defaultEvaluator.eval(Let(id, IntLiteral(42), Variable(id))),
-      IntLiteral(42))
-  }
-
-
-  test("eval literal array ops") {
-    expectSuccessful(
-      defaultEvaluator.eval(finiteArray(Map[Int,Expr](), Some(IntLiteral(12), IntLiteral(7)), Int32Type)),
-      finiteArray(Map[Int,Expr](), Some(IntLiteral(12), IntLiteral(7)), Int32Type))
-    expectSuccessful(
-      defaultEvaluator.eval(
-        ArrayLength(finiteArray(Map[Int,Expr](), Some(IntLiteral(12), IntLiteral(7)), Int32Type))),
-      IntLiteral(7))
-    expectSuccessful(
-      defaultEvaluator.eval(ArraySelect(
-        finiteArray(Seq(IntLiteral(2), IntLiteral(4), IntLiteral(7))),
-        IntLiteral(1))),
-      IntLiteral(4))
-    expectSuccessful(
-      defaultEvaluator.eval(
-        ArrayUpdated(
-          finiteArray(Seq(IntLiteral(2), IntLiteral(4), IntLiteral(7))),
-          IntLiteral(1),
-          IntLiteral(42))),
-      finiteArray(Seq(IntLiteral(2), IntLiteral(42), IntLiteral(7))))
-  }
-
-  test("eval variable length of array") {
-    val id = FreshIdentifier("id", Int32Type)
-    expectSuccessful(
-      defaultEvaluator.eval(
-        ArrayLength(
-          finiteArray(Map[Int, Expr](), Some(IntLiteral(12), Variable(id)), Int32Type)),
-        Map(id -> IntLiteral(27))),
-      IntLiteral(27))
-  }
-
-  test("eval variable default value of array") {
-    val id = FreshIdentifier("id", Int32Type)
-    expectSuccessful(
-      defaultEvaluator.eval(
-        finiteArray(Map[Int, Expr](), Some(Variable(id), IntLiteral(7)), Int32Type),
-        Map(id -> IntLiteral(27))),
-      finiteArray(Map[Int, Expr](), Some(IntLiteral(27), IntLiteral(7)), Int32Type))
-  }
-
-}
diff --git a/src/unit-test/scala/leon/purescala/ExpressionsBuilder.scala b/src/unit-test/scala/leon/purescala/ExpressionsBuilder.scala
deleted file mode 100644
index c49636697589aff9ecaee6f9af8f779ccac1522b..0000000000000000000000000000000000000000
--- a/src/unit-test/scala/leon/purescala/ExpressionsBuilder.scala
+++ /dev/null
@@ -1,45 +0,0 @@
-package leon
-package purescala
-
-
-import Expressions._
-import Types._
-import Common._
-
-trait ExpressionsBuilder {
-
-  protected def i(i: Int) = InfiniteIntegerLiteral(i)
-  protected def r(x: Double) = RealLiteral(BigDecimal(x))
-  protected def v(name: String, tpe: TypeTree = IntegerType) = Variable(FreshIdentifier(name, tpe))
-
-  protected val xId = FreshIdentifier("x", RealType)
-  protected val x = Variable(xId)
-  protected val yId = FreshIdentifier("y", RealType)
-  protected val y = Variable(yId)
-  protected val zId = FreshIdentifier("z", RealType)
-  protected val z = Variable(zId)
-
-
-  protected val aId = FreshIdentifier("a", IntegerType)
-  protected val a = Variable(aId)
-  protected val bId = FreshIdentifier("b", IntegerType)
-  protected val b = Variable(bId)
-  protected val cId = FreshIdentifier("c", IntegerType)
-  protected val c = Variable(cId)
-
-  protected val mId = FreshIdentifier("m", IntegerType)
-  protected val m = Variable(mId)
-  protected val nId = FreshIdentifier("n", IntegerType)
-  protected val n = Variable(nId)
-  protected val kId = FreshIdentifier("k", IntegerType)
-  protected val k = Variable(kId)
-
-
-  protected val pId = FreshIdentifier("p", BooleanType)
-  protected val p = Variable(pId)
-  protected val qId = FreshIdentifier("q", BooleanType)
-  protected val q = Variable(qId)
-  protected val rId = FreshIdentifier("r", BooleanType)
-  protected val r = Variable(rId)
-
-}
diff --git a/src/unit-test/scala/leon/purescala/LikelyEqSuite.scala b/src/unit-test/scala/leon/purescala/LikelyEqSuite.scala
deleted file mode 100644
index 71115fac6993239883da8773f95ba1c09979c7bc..0000000000000000000000000000000000000000
--- a/src/unit-test/scala/leon/purescala/LikelyEqSuite.scala
+++ /dev/null
@@ -1,48 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.purescala
-
-import leon.test._
-import leon.purescala.Common._
-import leon.purescala.Expressions._
-import leon.purescala.Types._
-
-class LikelyEqSuite extends LeonTestSuite with WithLikelyEq {
-  def i(x: Int) = InfiniteIntegerLiteral(x)
-
-  val xId = FreshIdentifier("x", IntegerType)
-  val x = Variable(xId)
-  val yId = FreshIdentifier("y", IntegerType)
-  val y = Variable(yId)
-  val zId = FreshIdentifier("z", IntegerType)
-  val z = Variable(zId)
-
-  test("apply") {
-    assert(LikelyEq(Plus(x, x), Times(i(2), x), Set(xId)))
-    assert(LikelyEq(Plus(x, x), Times(x, i(2)), Set(xId)))
-
-    assert(LikelyEq(Plus(x, y), Plus(y, x), Set(xId, yId)))
-    assert(LikelyEq(Plus(Plus(x, y), y), Plus(x, Times(i(2), y)), Set(xId, yId)))
-
-    def defaultCompare(e1: Expr, e2: Expr) = e1 == e2
-
-    assert(LikelyEq(
-      Plus(i(2), Plus(x, y)), 
-      Plus(i(3), Plus(x, z)), 
-      Set(xId), 
-      BooleanLiteral(true),
-      defaultCompare, 
-      Map(yId -> i(2), zId -> i(1)))
-    )
-
-
-    assert(LikelyEq(
-      Plus(x, Times(i(2), Division(y, i(2))))
-      , Plus(x, y)
-      , Set(xId, yId)
-      , Equals(Modulo(y, i(2)), i(0))
-    ))
-
-  }
-  
-}
diff --git a/src/unit-test/scala/leon/purescala/TreeNormalizationsSuite.scala b/src/unit-test/scala/leon/purescala/TreeNormalizationsSuite.scala
deleted file mode 100644
index fc11c8a0911d937e3c81195bbca99490eb31ee39..0000000000000000000000000000000000000000
--- a/src/unit-test/scala/leon/purescala/TreeNormalizationsSuite.scala
+++ /dev/null
@@ -1,84 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.purescala
-
-import leon.test._
-
-import leon.purescala.Common._
-import leon.purescala.Types._
-import leon.purescala.Expressions._
-import leon.purescala.TreeNormalizations._
-
-class TreeNormalizationsSuite extends LeonTestSuite with WithLikelyEq {
-  def i(x: Int) = InfiniteIntegerLiteral(x)
-
-  val xId = FreshIdentifier("x", IntegerType)
-  val x = Variable(xId)
-  val yId = FreshIdentifier("y", IntegerType)
-  val y = Variable(yId)
-  val xs = Set(xId, yId)
-
-  val aId = FreshIdentifier("a", IntegerType)
-  val a = Variable(aId)
-  val bId = FreshIdentifier("b", IntegerType)
-  val b = Variable(bId)
-  val as = Set(aId, bId)
-  
-
-  def checkSameExpr(e1: Expr, e2: Expr, vs: Set[Identifier]) {
-    assert( //this outer assert should not be needed because of the nested one
-      LikelyEq(e1, e2, vs, BooleanLiteral(true), (e1, e2) => {assert(e1 === e2); true})
-    )
-  }
-
-  def toSum(es: Seq[Expr]) = es.reduceLeft(Plus)
-  def coefToSum(es: Array[Expr], vs: Array[Expr]) = es.zip(Array[Expr](InfiniteIntegerLiteral(1)) ++ vs).foldLeft[Expr](InfiniteIntegerLiteral(0))((acc, p) => Plus(acc, Times(p._1, p._2)))
-  
-  test("checkSameExpr") {
-    checkSameExpr(Plus(x, y), Plus(y, x), xs)
-    checkSameExpr(Plus(x, x), Times(x, i(2)), xs)
-    checkSameExpr(Plus(x, Plus(x, x)), Times(x, i(3)), xs)
-  }
-
-  test("multiply") {
-    val lhs = Seq(x, i(2))
-    val rhs = Seq(y, i(1))
-    checkSameExpr(Times(toSum(lhs), toSum(rhs)), toSum(multiply(lhs, rhs)), xs)
-    checkSameExpr(Times(toSum(rhs), toSum(lhs)), toSum(multiply(rhs, lhs)), xs)
-
-    val lhs2 = Seq(x, y, i(2))
-    val rhs2 = Seq(y, i(1), Times(i(2), x))
-    checkSameExpr(Times(toSum(lhs2), toSum(rhs2)), toSum(multiply(lhs2, rhs2)), xs)
-  }
-
-  test("expandedForm") {
-    val e1 = Times(Plus(x, i(2)), Plus(y, i(1)))
-    checkSameExpr(toSum(expandedForm(e1)), e1, xs)
-
-    val e2 = Times(Plus(x, Times(i(2), y)), Plus(Plus(x, y), i(1)))
-    checkSameExpr(toSum(expandedForm(e2)), e2, xs)
-
-    val e3 = Minus(Plus(x, Times(i(2), y)), Plus(Plus(x, y), i(1)))
-    checkSameExpr(toSum(expandedForm(e3)), e3, xs)
-
-    val e4 = UMinus(Plus(x, Times(i(2), y)))
-    checkSameExpr(toSum(expandedForm(e4)), e4, xs)
-  }
-
-  test("linearArithmeticForm") {
-    val xsOrder = Array(xId, yId)
-
-    val e1 = Plus(Times(Plus(x, i(2)), i(3)), Times(i(4), y))
-    checkSameExpr(coefToSum(linearArithmeticForm(e1, xsOrder), Array(x, y)), e1, xs)
-
-    val e2 = Plus(Times(Plus(x, i(2)), i(3)), Plus(Plus(a, Times(i(5), b)), Times(i(4), y)))
-    checkSameExpr(coefToSum(linearArithmeticForm(e2, xsOrder), Array(x, y)), e2, xs ++ as)
-
-    val e3 = Minus(Plus(x, i(3)), Plus(y, i(2)))
-    checkSameExpr(coefToSum(linearArithmeticForm(e3, xsOrder), Array(x, y)), e3, xs)
-
-    val e4 = Plus(Plus(i(0), i(2)), Times(i(-1), i(3)))
-    assert(linearArithmeticForm(e4, Array()) === Array(i(-1)))
-
-  }
-}
diff --git a/src/unit-test/scala/leon/purescala/TreeTestsSuite.scala b/src/unit-test/scala/leon/purescala/TreeTestsSuite.scala
deleted file mode 100644
index 933ba02dc4397850965c14d5dbf22ee8f5fe3f97..0000000000000000000000000000000000000000
--- a/src/unit-test/scala/leon/purescala/TreeTestsSuite.scala
+++ /dev/null
@@ -1,38 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon.test.purescala
-
-import leon.test._
-
-import leon.purescala.Common._
-import leon.purescala.Constructors._
-import leon.purescala.Expressions._
-import leon.purescala.Types._
-
-class TreeTestsSuite extends LeonTestSuite {
-
-  test("And- and Or- simplifications") {
-    val x = Variable(FreshIdentifier("x", BooleanType))
-    val t = BooleanLiteral(true)
-    val f = BooleanLiteral(false)
-
-    def and(es : Expr*) : Expr = andJoin(es)
-    def or(es : Expr*) : Expr = orJoin(es)
-
-    assert(and(x, and(x, x), x) === and(x, x, x, x))
-    assert(and(x, t, x, t) === and(x, x))
-    assert(and(x, t, f, x) === and(x, f))
-    assert(and(x) === x)
-    assert(and() === t)
-    assert(and(t, t) === t)
-    assert(and(f) === f)
-
-    assert(or(x, or(x, x), x) === or(x, x, x, x))
-    assert(or(x, f, x, f) === or(x, x))
-    assert(or(x, f, t, x) === or(x, t))
-    assert(or(x) === x)
-    assert(or() === f)
-    assert(or(f, f) === f)
-    assert(or(t) === t)
-  }
-}
diff --git a/src/unit-test/scala/leon/purescala/WithLikelyEq.scala b/src/unit-test/scala/leon/purescala/WithLikelyEq.scala
deleted file mode 100644
index 705f2ba403fd60ac500641d9d5c13559788d2354..0000000000000000000000000000000000000000
--- a/src/unit-test/scala/leon/purescala/WithLikelyEq.scala
+++ /dev/null
@@ -1,87 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon
-package purescala
-
-import leon.evaluators._
-import leon.purescala.Common._
-import leon.purescala.Definitions._
-import leon.purescala.ExprOps.replace
-import leon.purescala.Expressions._
-
-/*
- * Determine if two expressions over arithmetic variables are likely to be equal.
- *
- * This is a probabilistic based approach, it does not rely on any external solver and can
- * only prove the non equality of two expressions.
- */
-trait WithLikelyEq {
-  this: LeonTestSuite =>
-
-  object LikelyEq {
-    private val min = -5
-    private val max = 5
-
-    /*
-     * compare e1 and e2, using a list of assignment of integer to the variables in vs.
-     * Pre is a boolean expression precondition over the same variables that must be evaluated to true
-     * before testing equality.
-     * Add a default mapping for some set parameters
-     * Note that the default map could contain a mapping for variables to other parameters
-     * It is thus necessary to first select values for those parameters and then substitute
-     * into the default map !
-     */
-    def apply(e1: Expr, e2: Expr, vs: Set[Identifier], pre: Expr = BooleanLiteral(true),
-              compare: (Expr, Expr) => Boolean = (e1, e2) => e1 == e2, 
-              defaultMap: Map[Identifier, Expr] = Map()): Boolean = {
-      val evaluator = new DefaultEvaluator(createLeonContext(), Program.empty)
-      if(vs.isEmpty) {
-        val ndm = defaultMap.map { case (id, expr) => (id, evaluator.eval(expr).asInstanceOf[EvaluationResults.Successful].value) } //TODO: not quite sure why I need to do this...
-        (evaluator.eval(e1, ndm), evaluator.eval(e2, defaultMap)) match {
-          case (EvaluationResults.Successful(v1), EvaluationResults.Successful(v2)) => compare(v1, v2)
-          case (err1, err2) => sys.error("evaluation could not complete, got: (" + err1 + ", " + err2 + ")")
-        }
-      } else {
-        var isEq = true
-        val vsOrder = vs.toArray
-        val counters: Array[Int] = vsOrder.map(_ => min)
-        var i = 0
-
-        while(i < counters.length && isEq) {
-          val m: Map[Expr, Expr] = vsOrder.zip(counters).map{case (v, c) => (Variable(v), InfiniteIntegerLiteral(c))}.toMap
-          val ne1 = replace(m, e1)
-          val ne2 = replace(m, e2)
-          val npre = replace(m, pre)
-          val ndm = defaultMap.map{ case (id, expr) => (id, evaluator.eval(expr, m.map{case (Variable(id), t) => (id, t)}).asInstanceOf[EvaluationResults.Successful].value) }
-          evaluator.eval(npre, ndm) match {
-            case EvaluationResults.Successful(BooleanLiteral(false)) =>
-            case EvaluationResults.Successful(BooleanLiteral(true)) =>
-              val ev1 = evaluator.eval(ne1, ndm)
-              val ev2 = evaluator.eval(ne2, ndm)
-              (ev1, ev2) match {
-                case (EvaluationResults.Successful(v1), EvaluationResults.Successful(v2)) => if(!compare(v1, v2)) isEq = false
-                case (err1, err2) => sys.error("evaluation could not complete, got: (" + err1 + ", " + err2 + ")")
-              }
-            case err => sys.error("evaluation of precondition could not complete, got: " + err)
-          }
-
-          if(counters(i) < max)
-            counters(i) += 1
-          else {
-            while(i < counters.length && counters(i) >= max) {
-              counters(i) = min
-              i += 1
-            }
-            if(i < counters.length) {
-              counters(i) += 1
-              i = 0
-            }
-          }
-        }
-        isEq
-      }
-    }
-
-  }
-
-}
diff --git a/src/unit-test/scala/leon/synthesis/AlgebraSuite.scala b/src/unit-test/scala/leon/synthesis/AlgebraSuite.scala
deleted file mode 100644
index cb0eed3dd924512507e89bcfee95c4e00c64539f..0000000000000000000000000000000000000000
--- a/src/unit-test/scala/leon/synthesis/AlgebraSuite.scala
+++ /dev/null
@@ -1,204 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon
-package synthesis
-
-import Algebra._
-
-class AlgebraSuite extends LeonTestSuite {
-
-  test("remainder") {
-    assert(remainder(1,1) === 0)
-    assert(remainder(2,2) === 0)
-    assert(remainder(2,1) === 0)
-    assert(remainder(0,1) === 0)
-    assert(remainder(0,4) === 0)
-    assert(remainder(1,3) === 1)
-    assert(remainder(1,8) === 1)
-    assert(remainder(4,2) === 0)
-    assert(remainder(17,3) === 2)
-    assert(remainder(25,5) === 0)
-    assert(remainder(26,5) === 1)
-    assert(remainder(29,5) === 4)
-
-    assert(remainder(1,-1) === 0)
-    assert(remainder(-1,1) === 0)
-    assert(remainder(2,-2) === 0)
-    assert(remainder(-2,-2) === 0)
-    assert(remainder(-2,1) === 0)
-    assert(remainder(0,-1) === 0)
-    assert(remainder(1,-2) === 1)
-    assert(remainder(-1,2) === 1)
-    assert(remainder(-1,3) === 2)
-    assert(remainder(-1,-3) === 2)
-    assert(remainder(1,-3) === 1)
-    assert(remainder(17,-3) === 2)
-    assert(remainder(-25,5) === 0)
-  }
-
-  test("divide") {
-    assert(divide(1,1) === (1, 0))
-    assert(divide(2,2) === (1, 0))
-    assert(divide(2,1) === (2, 0))
-    assert(divide(0,1) === (0, 0))
-    assert(divide(0,4) === (0, 0))
-    assert(divide(1,3) === (0, 1))
-    assert(divide(1,8) === (0, 1))
-    assert(divide(4,2) === (2, 0))
-    assert(divide(17,3) === (5, 2))
-    assert(divide(25,5) === (5, 0))
-    assert(divide(26,5) === (5, 1))
-    assert(divide(29,5) === (5, 4))
-
-    assert(divide(1,-1) === (-1, 0))
-    assert(divide(-1,1) === (-1, 0))
-    assert(divide(2,-2) === (-1, 0))
-    assert(divide(-2,-2) === (1, 0))
-    assert(divide(-2,1) === (-2, 0))
-    assert(divide(0,-1) === (0, 0))
-    assert(divide(1,-2) === (0, 1))
-    assert(divide(-1,2) === (-1, 1))
-    assert(divide(-1,3) === (-1, 2))
-    assert(divide(-1,-3) === (1, 2))
-    assert(divide(1,-3) === (0, 1))
-    assert(divide(17,-3) === (-5, 2))
-    assert(divide(-25,5) === (-5, 0))
-  }
-
-  test("binary gcd") {
-    assert(gcd(1,1) === 1)
-    assert(gcd(1,3) === 1)
-    assert(gcd(3,1) === 1)
-    assert(gcd(3,3) === 3)
-    assert(gcd(4,3) === 1)
-    assert(gcd(5,3) === 1)
-    assert(gcd(6,3) === 3)
-    assert(gcd(2,12) === 2)
-    assert(gcd(4,10) === 2)
-    assert(gcd(10,4) === 2)
-    assert(gcd(12,8) === 4)
-    assert(gcd(23,41) === 1)
-    assert(gcd(0,41) === 41)
-    assert(gcd(4,0) === 4)
-
-    assert(gcd(-4,0) === 4)
-    assert(gcd(-23,41) === 1)
-    assert(gcd(23,-41) === 1)
-    assert(gcd(-23,-41) === 1)
-    assert(gcd(2,-12) === 2)
-    assert(gcd(-4,10) === 2)
-    assert(gcd(-4,-8) === 4)
-  }
-
-  test("n-ary gcd") {
-    assert(gcd(1,1,1) === 1)
-    assert(gcd(1,3,5) === 1)
-    assert(gcd(3,1,2) === 1)
-    assert(gcd(3,3,3) === 3)
-    assert(gcd(4,3,8,6) === 1)
-    assert(gcd(5,3,2) === 1)
-    assert(gcd(6,3,9) === 3)
-    assert(gcd(6,3,8) === 1)
-    assert(gcd(2,12,16,4) === 2)
-    assert(gcd(4,10,8,22) === 2)
-    assert(gcd(10,4,20) === 2)
-    assert(gcd(12,8,4) === 4)
-    assert(gcd(12,8,2) === 2)
-    assert(gcd(12,8,6) === 2)
-    assert(gcd(23,41,11) === 1)
-    assert(gcd(2,4,8,12,16,4) === 2)
-    assert(gcd(2,4,8,11,16,4) === 1)
-    assert(gcd(6,3,8, 0) === 1)
-    assert(gcd(2,12, 0,16,4) === 2)
-
-    assert(gcd(-12,8,6) === 2)
-    assert(gcd(23,-41,11) === 1)
-    assert(gcd(23,-41, 0,11) === 1)
-    assert(gcd(2,4,-8,-12,16,4) === 2)
-    assert(gcd(-2,-4,-8,-11,-16,-4) === 1)
-  }
-
-  test("seq gcd") {
-    assert(gcd(Seq(1)) === 1)
-    assert(gcd(Seq(4)) === 4)
-    assert(gcd(Seq(7)) === 7)
-    assert(gcd(Seq(1,1,1)) === 1)
-    assert(gcd(Seq(1,3,5)) === 1)
-    assert(gcd(Seq(3,1,2)) === 1)
-    assert(gcd(Seq(3,3,3)) === 3)
-    assert(gcd(Seq(4,3,8,6)) === 1)
-    assert(gcd(Seq(5,3,2)) === 1)
-    assert(gcd(Seq(6,3,9)) === 3)
-    assert(gcd(Seq(6,3,8)) === 1)
-    assert(gcd(Seq(2,12,16,4)) === 2)
-    assert(gcd(Seq(4,10,8,22)) === 2)
-    assert(gcd(Seq(10,4,20)) === 2)
-    assert(gcd(Seq(12,8,4)) === 4)
-    assert(gcd(Seq(12,8,2)) === 2)
-    assert(gcd(Seq(12,8,6)) === 2)
-    assert(gcd(Seq(23,41,11)) === 1)
-    assert(gcd(Seq(2,4,8,12,16,4)) === 2)
-    assert(gcd(Seq(2,4,8,11,16,4)) === 1)
-    assert(gcd(Seq(6,3,8, 0)) === 1)
-    assert(gcd(Seq(2,12, 0,16,4)) === 2)
-
-    assert(gcd(Seq(-1)) === 1)
-    assert(gcd(Seq(-7)) === 7)
-    assert(gcd(Seq(-12,8,6)) === 2)
-    assert(gcd(Seq(23,-41,11)) === 1)
-    assert(gcd(Seq(23,-41, 0,11)) === 1)
-    assert(gcd(Seq(2,4,-8,-12,16,4)) === 2)
-    assert(gcd(Seq(-2,-4,-8,-11,-16,-4)) === 1)
-  }
-
-  test("binary lcm") {
-    assert(lcm(1,3) === 3)
-    assert(lcm(1,1) === 1)
-    assert(lcm(0,1) === 0)
-    assert(lcm(2,3) === 6)
-    assert(lcm(4,3) === 12)
-    assert(lcm(4,6) === 12)
-    assert(lcm(8,6) === 24)
-  }
-  test("n-ary lcm") {
-    assert(lcm(1,2,3) === 6)
-    assert(lcm(1,2,3,4) === 12)
-    assert(lcm(5,2,3,4) === 60)
-  }
-  test("seq lcm") {
-    assert(lcm(Seq(1,2,3)) === 6)
-    assert(lcm(Seq(1,2,3,4)) === 12)
-    assert(lcm(Seq(5,2,3,4)) === 60)
-  }
-
-  def checkExtendedEuclid(a: Int, b: Int) {
-    val (x, y) = extendedEuclid(a, b)
-    assert(x*a + y*b === gcd(a, b))
-  }
-
-  test("extendedEuclid") {
-    checkExtendedEuclid(1, 1)
-    checkExtendedEuclid(3, 1)
-    checkExtendedEuclid(1, 2)
-    checkExtendedEuclid(1, 15)
-    checkExtendedEuclid(4, 1)
-    checkExtendedEuclid(4, 3)
-    checkExtendedEuclid(12, 23)
-    checkExtendedEuclid(11, 10)
-    checkExtendedEuclid(10, 15)
-
-    checkExtendedEuclid(-1, 1)
-    checkExtendedEuclid(-1, -1)
-    checkExtendedEuclid(3, -1)
-    checkExtendedEuclid(-3, -1)
-    checkExtendedEuclid(-3, 1)
-    checkExtendedEuclid(1, -2)
-    checkExtendedEuclid(-1, 2)
-    checkExtendedEuclid(-1, -2)
-    checkExtendedEuclid(12, -23)
-    checkExtendedEuclid(-11, 10)
-    checkExtendedEuclid(10, -15)
-  }
-}
-
-// vim: set ts=4 sw=4 et:
diff --git a/src/unit-test/scala/leon/synthesis/LinearEquationsSuite.scala b/src/unit-test/scala/leon/synthesis/LinearEquationsSuite.scala
deleted file mode 100644
index 9506b271326f35c33c0ff53b36178b0c74ad47d0..0000000000000000000000000000000000000000
--- a/src/unit-test/scala/leon/synthesis/LinearEquationsSuite.scala
+++ /dev/null
@@ -1,260 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon
-package synthesis
-
-import leon.purescala.WithLikelyEq
-import leon.purescala.Expressions._
-import leon.purescala.Types._
-import leon.purescala.ExprOps._
-import leon.purescala.Common._
-import leon.purescala.Definitions._
-import leon.evaluators._
-
-import leon.synthesis.LinearEquations._
-
-class LinearEquationsSuite extends LeonTestSuite with WithLikelyEq {
-
-  def i(x: Int) = InfiniteIntegerLiteral(x)
-
-  val xId = FreshIdentifier("x", IntegerType)
-  val x = Variable(xId)
-  val yId = FreshIdentifier("y", IntegerType)
-  val y = Variable(yId)
-  val zId = FreshIdentifier("z", IntegerType)
-  val z = Variable(zId)
-
-  val aId = FreshIdentifier("a", IntegerType)
-  val a = Variable(aId)
-  val bId = FreshIdentifier("b", IntegerType)
-  val b = Variable(bId)
-
-  def toSum(es: Seq[Expr]) = es.reduceLeft(Plus)
-  
-  def checkSameExpr(e1: Expr, e2: Expr, vs: Set[Identifier], prec: Expr, defaultMap: Map[Identifier, Expr] = Map()) {
-    assert( //this outer assert should not be needed because of the nested one
-      LikelyEq(e1, e2, vs, prec, (e1, e2) => {assert(e1 === e2); true}, defaultMap)
-    )
-  }
-
-
-  //use some random values to check that any vector in the basis is a valid solution to
-  //the equation
-  def checkVectorSpace(basis: Array[Array[Int]], equation: Array[Int]): Unit = 
-    checkVectorSpace(basis.map(_.map(i => BigInt(i))), equation.map(i => BigInt(i)))
-  def checkVectorSpace(basis: Array[Array[BigInt]], equation: Array[BigInt]): Unit = {
-    require(basis.length == basis(0).length + 1 && basis.length == equation.length)
-    val n = basis(0).length
-    val min: BigInt = -5
-    val max: BigInt = 5
-    val components = Array.fill(n)(min)
-    var counter = 0
-
-    while(counter < n) {
-      val sol = mult(basis, components) //one linear combination of the basis
-      assert(eval(sol, equation) === 0)
-
-      //next components
-      if(components(counter) < max)
-        components(counter) += 1
-      else {
-        while(counter < n && components(counter) >= max) {
-          components(counter) = min
-          counter += 1
-        }
-        if(counter < n) {
-          components(counter) += 1
-          counter = 0
-        }
-      }
-    }
-  }
-
-  //val that the sol vector with the term in the equation
-  def eval(sol: Array[BigInt], equation: Array[BigInt]): BigInt = {
-    require(sol.length == equation.length)
-    sol.zip(equation).foldLeft(BigInt(0))((acc, p) => acc + p._1 * p._2)
-  }
-
-  //multiply the matrix by the vector: [M1 M2 .. Mn] * [v1 .. vn] = v1*M1 + ... + vn*Mn]
-  def mult(matrix: Array[Array[BigInt]], vector: Array[BigInt]): Array[BigInt] = {
-    require(vector.length == matrix(0).length && vector.length > 0)
-    val tmat = matrix.transpose
-    var tmp: Array[BigInt] = null
-    tmp = mult(vector(0), tmat(0))
-    var i = 1
-    while(i < vector.length) {
-      tmp = add(tmp, mult(vector(i), tmat(i)))
-      i += 1
-    }
-    tmp
-  }
-
-  def mult(c: BigInt, v: Array[BigInt]): Array[BigInt] = v.map(_ * c)
-  def add(v1: Array[BigInt], v2: Array[BigInt]): Array[BigInt] = {
-    require(v1.length == v2.length)
-    v1.zip(v2).map(p => p._1 + p._2)
-  }
-
-  test("checkVectorSpace") {
-    checkVectorSpace(Array(Array(1), Array(2)), Array(-2, 1))
-    checkVectorSpace(Array(Array(4, 0), Array(-3, 2), Array(0, -1)), Array(3, 4, 8))
-  }
-
-  
-  test("particularSolution basecase") {
-    def toExpr(es: Array[Expr]): Expr = {
-      val vars: Array[Expr] = Array[Expr](i(1)) ++ Array[Expr](x, y)
-      es.zip(vars).foldLeft[Expr](i(0))( (acc: Expr, p: (Expr, Expr)) => Plus(acc, Times(p._1, p._2)) )
-    }
-
-    val t1: Expr = Plus(a, b)
-    val c1: Expr = i(4)
-    val d1: Expr = i(22)
-    val e1: Array[Expr] = Array(t1, c1, d1)
-    val (pre1, (w1, w2)) = particularSolution(Set(aId, bId), t1, c1, d1)
-    checkSameExpr(toExpr(e1), i(0), Set(aId, bId), pre1, Map(xId -> w1, yId -> w2))
-
-    val t2: Expr = i(-1)
-    val c2: Expr = i(1)
-    val d2: Expr = i(-1)
-    val e2: Array[Expr] = Array(t2, c2, d2)
-    val (pre2, (w3, w4)) = particularSolution(Set(), t2, c2, d2)
-    checkSameExpr(toExpr(e2), i(0), Set(), pre2, Map(xId -> w3, yId -> w4))
-  }
-
-  test("particularSolution preprocess") {
-    def toExpr(es: Array[Expr], vs: Array[Expr]): Expr = {
-      val vars: Array[Expr] = Array[Expr](i(1)) ++ vs
-      es.zip(vars).foldLeft[Expr](i(0))( (acc: Expr, p: (Expr, Expr)) => Plus(acc, Times(p._1, p._2)) )
-    }
-
-    val t1: Expr = Plus(a, b)
-    val c1: Expr = i(4)
-    val d1: Expr = i(22)
-    val e1: Array[Expr] = Array(t1, c1, d1)
-    val (pre1, s1) = particularSolution(Set(aId, bId), e1.toList)
-    checkSameExpr(toExpr(e1, Array(x, y)), i(0), Set(aId, bId), pre1, Array(xId, yId).zip(s1).toMap)
-
-    val t2: Expr = Plus(a, b)
-    val c2: Expr = i(4)
-    val d2: Expr = i(22)
-    val f2: Expr = i(10)
-    val e2: Array[Expr] = Array(t2, c2, d2, f2)
-    val (pre2, s2) = particularSolution(Set(aId, bId), e2.toList)
-    checkSameExpr(toExpr(e2, Array(x, y, z)), i(0), Set(aId, bId), pre2, Array(xId, yId, zId).zip(s2).toMap)
-
-    val t3: Expr = Plus(a, Times(i(2), b))
-    val c3: Expr = i(6)
-    val d3: Expr = i(24)
-    val f3: Expr = i(9)
-    val e3: Array[Expr] = Array(t3, c3, d3, f3)
-    val (pre3, s3) = particularSolution(Set(aId, bId), e3.toList)
-    checkSameExpr(toExpr(e3, Array(x, y, z)), i(0), Set(aId, bId), pre3, Array(xId, yId, zId).zip(s3).toMap)
-
-    val t4: Expr = Plus(a, b)
-    val c4: Expr = i(4)
-    val e4: Array[Expr] = Array(t4, c4)
-    val (pre4, s4) = particularSolution(Set(aId, bId), e4.toList)
-    checkSameExpr(toExpr(e4, Array(x)), i(0), Set(aId, bId), pre4, Array(xId).zip(s4).toMap)
-  }
-
-
-  test("linearSet") {
-    val as = Set[Identifier]()
-
-    val evaluator = new DefaultEvaluator(createLeonContext(), Program.empty)
-
-    val eq1 = Array[BigInt](3, 4, 8)
-    val basis1 = linearSet(evaluator, as, eq1)
-    checkVectorSpace(basis1, eq1)
-
-    val eq2 = Array[BigInt](1, 2, 3)
-    val basis2 = linearSet(evaluator, as, eq2)
-    checkVectorSpace(basis2, eq2)
-
-    val eq3 = Array[BigInt](1, 1)
-    val basis3 = linearSet(evaluator, as, eq3)
-    checkVectorSpace(basis3, eq3)
-
-    val eq4 = Array[BigInt](1, 1, 2, 7)
-    val basis4 = linearSet(evaluator, as, eq4)
-    checkVectorSpace(basis4, eq4)
-
-    val eq5 = Array[BigInt](1, -1)
-    val basis5 = linearSet(evaluator, as, eq5)
-    checkVectorSpace(basis5, eq5)
-
-    val eq6 = Array[BigInt](1, -6, 3)
-    val basis6 = linearSet(evaluator, as, eq6)
-    checkVectorSpace(basis6, eq6)
-  }
-
-
-  def enumerate(nbValues: Int, app: (Array[Int] => Unit)) {
-    val min = -5
-    val max = 5
-    val counters: Array[Int] = (1 to nbValues).map(_ => min).toArray
-    var i = 0
-
-    while(i < counters.length) {
-      app(counters)
-      if(counters(i) < max)
-        counters(i) += 1
-      else {
-        while(i < counters.length && counters(i) >= max) {
-          counters(i) = min
-          i += 1
-        }
-        if(i < counters.length) {
-          counters(i) += 1
-          i = 0
-        }
-      }
-    }
-
-  }
-
-  //TODO: automatic check result
-  test("elimVariable") {
-    val as = Set[Identifier](aId, bId)
-
-    val evaluator = new DefaultEvaluator(createLeonContext(), Program.empty)
-
-    def check(t: Expr, c: List[Expr], prec: Expr, witnesses: List[Expr], freshVars: List[Identifier]) {
-      enumerate(freshVars.size, (vals: Array[Int]) => {
-        val mapping: Map[Expr, Expr] = freshVars.zip(vals.toList).map(t => (Variable(t._1), i(t._2))).toMap
-        val cWithVars: Expr = c.zip(witnesses).foldLeft[Expr](i(0)){ case (acc, (coef, wit)) => Plus(acc, Times(coef, replace(mapping, wit))) }
-        checkSameExpr(Plus(t, cWithVars), i(0), as, prec)
-      })
-    }
-
-    val t1 = Minus(Times(i(2), a), b)
-    val c1 = List(i(3), i(4), i(8))
-    val (pre1, wit1, f1) = elimVariable(evaluator, as, t1::c1)
-    check(t1, c1, pre1, wit1, f1)
-
-    val t2 = Plus(Plus(i(0), i(2)), Times(i(-1), i(3)))
-    val c2 = List(i(1), i(-1))
-    val (pre2, wit2, f2) = elimVariable(evaluator, Set(), t2::c2)
-    check(t2, c2, pre2, wit2, f2)
-
-
-    val t3 = Minus(Times(i(2), a), i(3))
-    val c3 = List(i(2))
-    val (pre3, wit3, f3) = elimVariable(evaluator, Set(aId), t3::c3)
-    check(t3, c3, pre3, wit3, f3)
-
-    val t4 = Times(i(2), a)
-    val c4 = List(i(2), i(4))
-    val (pre4, wit4, f4) = elimVariable(evaluator, Set(aId), t4::c4)
-    check(t4, c4, pre4, wit4, f4)
-
-    val t5 = Minus(a, b)
-    val c5 = List(i(-60), i(-3600))
-    val (pre5, wit5, f5) = elimVariable(evaluator, Set(aId, bId), t5::c5)
-    check(t5, c5, pre5, wit5, f5)
-
-  }
-
-}
diff --git a/src/unit-test/scala/leon/utils/StreamsSuite.scala b/src/unit-test/scala/leon/utils/StreamsSuite.scala
deleted file mode 100644
index ee87d8ea3eb4b711114ed788193a35d376ba6e11..0000000000000000000000000000000000000000
--- a/src/unit-test/scala/leon/utils/StreamsSuite.scala
+++ /dev/null
@@ -1,66 +0,0 @@
-/* Copyright 2009-2015 EPFL, Lausanne */
-
-package leon
-package utils
-
-import purescala.Common._
-import utils.StreamUtils._
-
-class StreamsSuite extends LeonTestSuite {
-  test("Cartesian Product 1") {
-    val s1 = FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #:: Stream.empty
-
-    val s2 = FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #:: Stream.empty
-
-    val ss = cartesianProduct(List(s1, s2))
-
-    assert(ss.size === s1.size * s2.size)
-
-
-  }
-
-  test("Cartesian Product 2") {
-    val s1 = FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #:: Stream.empty
-
-    val s2 = FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #::
-             FreshIdentifier("B", alwaysShowUniqueID = true) #:: Stream.empty
-
-    val tmp1 = s1.mkString
-    val tmp2 = s2.mkString
-
-    val ss = cartesianProduct(List(s1, s2))
-
-    assert(ss.size === s1.size * s2.size)
-  }
-
-
-  test("Cartesian Product 3") {
-    val s1 = 1 #::
-             2 #::
-             3 #::
-             4 #:: Stream.empty
-
-    val s2 = 5 #::
-             6 #::
-             7 #::
-             8 #:: Stream.empty
-
-    val tmp1 = s1.mkString
-    val tmp2 = s2.mkString
-
-    val ss = cartesianProduct(List(s1, s2))
-
-    assert(ss.size === s1.size * s2.size)
-  }
-}