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) - } -}