add regression to the top level and adapt run-tests script

regression/valid/Nested12.scala

+object Nested12 {
+
+  abstract class A
+  case class B(b: Int) extends A
+
+  def foo(i: Int): Int = {
+    val b: A = B(3)
+    def rec1(a: A, j: Int, j2: Int) = a match {
+      case B(b) => i + j + j2 + b
+    }
+    def rec2(a: A, k: Int) = a match {
+      case B(b) => rec1(a, b, k)
+    }
+    rec2(b, 2)
+  } ensuring(i + 8 == _)
+
+}

regression/valid/Nested13.scala

+object Nested13 {
+
+  abstract class D
+  case class E(e: Int) extends D
+  case class F(d: D, f: Int) extends D
+
+  def foo(a : Int): Int = {
+
+    def rec1(d: D, j: Int): Int = d match {
+      case E(e) => j + e + a
+      case F(dNext, f) => f + rec1(dNext, j)
+    }
+
+    def rec2(d: D, i : Int) : Int = d match {
+      case E(e) => e
+      case F(dNext, f) => rec1(d, i)
+    }
+
+    rec2(F(E(2), 3), 0)
+  } ensuring(a + 5 == _)
+}

regression/valid/Nested14.scala

+object Nested14 {
+
+  def foo(i: Int): Int = {
+    def rec1(j: Int): Int = {
+      def rec2(k: Int): Int = if(k == 0) 0 else rec1(j-1)
+      rec2(j)
+    }
+    rec1(3)
+  } ensuring(0 == _)
+
+}

regression/valid/Nested2.scala

+object Nested2 {
+
+  def foo(a: Int): Int = {
+    require(a >= 0)
+    val b = a + 2
+    def rec1(c: Int): Int = {
+      require(c >= 0)
+      b + c
+    }
+    rec1(2)
+  } ensuring(_ > 0)
+
+}

regression/valid/Nested3.scala

+object Nested3 {
+
+  def foo(a: Int): Int = {
+    require(a >= 0 && a <= 50)
+    val b = a + 2
+    val c = a + b
+    def rec1(d: Int): Int = {
+      require(d >= 0 && d <= 50)
+      val e = d + b + c
+      e
+    }
+    rec1(2)
+  } ensuring(_ > 0)
+
+}

regression/valid/Nested4.scala

+object Nested4 {
+
+  def foo(a: Int, a2: Int): Int = {
+    require(a >= 0 && a <= 50)
+    val b = a + 2
+    val c = a + b
+    if(a2 > a) {
+      def rec1(d: Int): Int = {
+        require(d >= 0 && d <= 50)
+        val e = d + b + c + a2
+        e
+      } ensuring(_ > 0)
+      rec1(2)
+    } else {
+      5
+    }
+  } ensuring(_ > 0)
+
+}

regression/valid/Nested5.scala

+object Nested5 {
+
+  def foo(a: Int): Int = {
+    require(a >= 0)
+    def bar(b: Int): Int = {
+      require(b > 0)
+      b + 3
+    } ensuring(a >= 0 && _ == b + 3)
+    bar(2)
+  } ensuring(a >= 0 && _ == 5)
+
+}

regression/valid/Nested6.scala

+object Nested5 {
+
+  def foo(a: Int): Int = {
+    require(a >= 0)
+    def bar(b: Int): Int = {
+      require(b > 0)
+      b + 3
+    } ensuring(prop(a, b) && a >= 0 && _ == b + 3)
+    bar(2)
+  } ensuring(a >= 0 && _ == 5)
+
+  def prop(x: Int, y: Int): Boolean = x + y > 0
+
+}

regression/valid/Nested7.scala

+object Nested2 {
+
+  def foo(a: Int): Int = {
+    require(a >= 0)
+    val b = a + 2
+    def rec1(c: Int): Int = {
+      require(c >= 0)
+      b + c + bar(a) + bar(b) + bar(c)
+    }
+    rec1(2) + bar(a)
+  } ensuring(_ > 0)
+
+
+  def bar(x: Int): Int = {
+    require(x >= 0)
+    x
+  } ensuring(_ >= 0)
+
+}

regression/valid/Nested8.scala

+import leon.Utils._
+
+object Nested8 {
+
+  def foo(a: Int): Int = {
+    require(a > 0)
+
+    def bar(b: Int): Int = {
+      if(a < b) {
+        def rec(c: Int): Int = {
+          require(c > 0)
+          c + b
+        } ensuring(_ > 0)
+        rec(2)
+      } else 3
+    }
+    bar(1)
+  } ensuring(_ > 0)
+
+  /*
+  def partitioned(a: Map[Int, Int], size: Int, l1: Int, u1: Int, l2: Int, u2: Int): Boolean = {
+    require(l1 >= 0 && u1 < l2 && u2 < size)
+    if(l2 > u2 || l1 > u1)
+      true
+    else {
+      var i = l1
+      var j = l2
+      var isPartitionned = true
+      (while(i <= u1) {
+        j = l2
+        (while(j <= u2) {
+          if(a(i) > a(j))
+            isPartitionned = false
+          j = j + 1
+        }) invariant(j >= l2 && i <= u1)
+        i = i + 1
+      }) invariant(i >= l1)
+      isPartitionned
+    }
+  }
+  */
+
+}

regression/valid/Nested9.scala

+object Nested4 {
+
+  def foo(a: Int, a2: Int): Int = {
+    require(a >= 0 && a <= 50)
+    val b = a + 2
+    val c = a + b
+    if(a2 > a) {
+      def rec1(d: Int): Int = {
+        require(d >= 0 && d <= 50)
+        val e = d + b + c + a2
+        def rec2(f: Int): Int = {
+          require(f >= c)
+          f + e
+        } ensuring(_ > 0)
+        rec2(c+1)
+      } ensuring(_ > 0)
+      rec1(2)
+    } else {
+      5
+    }
+  } ensuring(_ > 0)
+
+}

regression/valid/NestedVar.scala

+object NestedVar {
+
+  def foo(): Int = {
+    val a = 3
+    def rec(x: Int): Int = {
+      var b = 3
+      var c = 3
+      if(x > 0)
+        b = 2
+      else
+        c = 2
+      c+b
+    }
+    rec(a)
+  } ensuring(_ == 5)
+
+}

regression/valid/Unit1.scala

+object Unit1 {
+
+  def foo(): Unit = ({
+    ()
+  }) ensuring(_ == ())
+
+}

regression/valid/Unit2.scala

+object Unit2 {
+
+  def foo(u: Unit): Unit = {
+    u
+  } ensuring(_ == ())
+
+}

regression/valid/While1.scala

+object While1 {
+
+  def foo(): Int = {
+    var a = 0
+    var i = 0
+    while(i < 10) {
+      a = a + 1
+      i = i + 1
+    }
+    a
+  } ensuring(_ == 10)
+
+}

regression/valid/While2.scala

+object While1 {
+
+  def foo(): Int = {
+    var a = 0
+    var i = 0
+    while(i < 10) {
+      a = a + i
+      i = i + 1
+    }
+    a
+  } ensuring(_ == 45)
+
+}

regression/valid/While3.scala

+object While3 {
+
+  def foo(): Int = {
+    var a = 0
+    var i = 0
+    while({i = i+2; i <= 10}) {
+      a = a + i
+      i = i - 1
+    }
+    a
+  } ensuring(_ == 54)
+
+}

run-tests.sh

 #!/bin/bash
 
-nbtests=$(ls -l testcases/regression/{valid,invalid,error}/*.scala | wc -l)
+base=./regression
+nbtests=$(ls -l $base/{valid,invalid,error}/*.scala | wc -l)
 nbsuccess=0
 failedtests=""
 
-for f in testcases/regression/valid/*.scala; do
+for f in $base/valid/*.scala; do
   echo -n "Running $f, expecting VALID, got: "
   res=`./leon --noLuckyTests --timeout=10 --oneline "$f"`
   echo $res | tr [a-z] [A-Z]
-  if [ "$res" = valid ]; then
+  if [ $res = valid ]; then
     nbsuccess=$((nbsuccess + 1))
   else
     failedtests="$failedtests $f"
   fi
 done
 
-for f in testcases/regression/invalid/*.scala; do
+for f in $base/invalid/*.scala; do
   echo -n "Running $f, expecting INVALID, got: "
   res=`./leon --noLuckyTests --timeout=10 --oneline "$f"`
   echo $res | tr [a-z] [A-Z]
-  if [ "$res" = invalid ]; then
+  if [ $res = invalid ]; then
     nbsuccess=$((nbsuccess + 1))
   else
     failedtests="$failedtests $f"
   fi
 done
 
-for f in testcases/regression/error/*.scala; do
+for f in $base/error/*.scala; do
   echo -n "Running $f, expecting ERROR, got: "
   res=`./leon --noLuckyTests --timeout=10 --oneline "$f"`
   echo $res | tr [a-z] [A-Z]
-  if [ "$res" = error ]; then
+  if [ $res = error ]; then
     nbsuccess=$((nbsuccess + 1))
   else
     failedtests="$failedtests $f"