regression is now at the top level

testcases/regression/valid/Array9.scala

-object Array9 {
-
-  def foo(i: Int): Array[Int] = {
-    require(i > 0)
-    val a = Array.fill(i)(0)
-    a
-  } ensuring(res => res.length == i)
-
-  def bar(i: Int): Int = {
-    require(i > 0)
-    val b = foo(i)
-    b(0)
-  }
-
-}

testcases/regression/valid/Assign1.scala

-object Assign1 {
-
-  def foo(): Int = {
-    var a = 0
-    val tmp = a + 1
-    a = a + 2
-    a = a + tmp
-    a = a + 4
-    a
-  } ensuring(_ == 7)
-
-}

testcases/regression/valid/Epsilon1.scala

-import leon.Utils._
-
-object Epsilon1 {
-
-  def greater(x: Int): Int = {
-    epsilon((y: Int) => y > x)
-  } ensuring(_ >= x)
-
-}

testcases/regression/valid/Epsilon2.scala

-import leon.Utils._
-
-object Epsilon1 {
-
-  def rand(): Int = epsilon((x: Int) => true)
-
-  //this should hold, that is the expected semantic of our epsilon
-  def property1(): Boolean = {
-    rand() == rand() 
-  } holds
-
-
-}

testcases/regression/valid/Epsilon3.scala

-import leon.Utils._
-
-object Epsilon3 {
-
-  def pos(): Int = {
-    epsilon((y: Int) => y > 0)
-  } ensuring(_ >= 0)
-
-}

testcases/regression/valid/Epsilon4.scala

-import leon.Utils._
-
-object Epsilon4 {
-
-  sealed abstract class MyList
-  case class MyCons(head: Int, tail: MyList) extends MyList
-  case class MyNil() extends MyList
-
-  def size(lst: MyList): Int = (lst match {
-    case MyNil() => 0
-    case MyCons(_, xs) => 1 + size(xs)
-  })
-
-  def toSet(lst: MyList): Set[Int] = lst match {
-    case MyCons(x, xs) => toSet(xs) ++ Set(x)
-    case MyNil() => Set[Int]()
-  }
-
-  def toList(set: Set[Int]): MyList = if(set == Set.empty[Int]) MyNil() else {
-    val elem = epsilon((x : Int) => set contains x)
-    MyCons(elem, toList(set -- Set[Int](elem)))
-  }
-
-  //timeout, but this probably means that it is valid as expected
-  //def property(lst: MyList): Boolean = (size(toList(toSet(lst))) <= size(lst)) holds
-
-  def propertyBase(lst: MyList): Boolean = ({
-    require(lst match { case MyNil() => true case _ => false})
-    size(toList(toSet(lst))) <= size(lst) 
-  }) holds
-
-}

testcases/regression/valid/Epsilon5.scala

-import leon.Utils._
-
-object Epsilon5 {
-
-  def foo(x: Int, y: Int): Int = {
-    epsilon((z: Int) => z > x && z < y)
-  } ensuring(_ >= x)
-
-}

testcases/regression/valid/Field1.scala

-object Field1 {
-
-  abstract sealed class A
-  case class B(size: Int) extends A
-
-  def foo(): Int = {
-    val b = B(3)
-    b.size
-  } ensuring(_ == 3)
-
-}

testcases/regression/valid/Field2.scala

-object Field2 {
-
-  abstract sealed class A
-  case class B(length: Int) extends A
-
-  def foo(): Int = {
-    val b = B(3)
-    b.length
-  } ensuring(_ == 3)
-
-}

testcases/regression/valid/IfExpr1.scala

-object IfExpr1 {
-
-  def foo(): Int = {
-    var a = 1
-    var b = 2
-    if({a = a + 1; a != b})
-      a = a + 3
-    else
-      b = a + b
-    a
-  } ensuring(_ == 2)
-
-}

testcases/regression/valid/IfExpr2.scala

-object IfExpr2 {
-
-  def foo(): Int = {
-    var a = 1
-    var b = 2
-    if(a < b) {
-      a = a + 3
-      b = b + 2
-      a = a + b
-    }
-    a
-  } ensuring(_ == 8)
-
-}

testcases/regression/valid/IfExpr3.scala

-object IfExpr1 {
-
-  def foo(a: Int): Int = {
-
-    if(a > 0) {
-      var a = 1
-      var b = 2
-      a = 3
-      a + b
-    } else {
-      5
-      //var a = 3
-      //var b = 1
-      //b = b + 1
-      //a + b
-    }
-  } ensuring(_ == 5)
-
-}

testcases/regression/valid/IfExpr4.scala

-object IfExpr4 {
-
-  def foo(a: Int): Int = {
-
-    if(a > 0) {
-      var a = 1
-      var b = 2
-      a = 3
-      a + b
-    } else {
-      var a = 3
-      var b = 1
-      b = b + 1
-      a + b
-    }
-  } ensuring(_ == 5)
-
-}

testcases/regression/valid/InstanceOf1.scala

-object InstanceOf1 {
-
-  abstract class A
-  case class B(i: Int) extends A
-  case class C(i: Int) extends A
-
-  def foo(): Int = {
-    require(C(3).isInstanceOf[C])
-    val b: A = B(2)
-    if(b.isInstanceOf[B])
-      0
-    else
-      -1
-  } ensuring(_ == 0)
-
-  def bar(): Int = foo()
-
-}

testcases/regression/valid/MyTuple1.scala

-object MyTuple1 {
-
-  def foo(): Int = {
-    val t = (1, true, 3)
-    val a1 = t._1
-    val a2 = t._2
-    val a3 = t._3
-    a3
-  } ensuring( _ == 3)
-
-}

testcases/regression/valid/MyTuple2.scala

-object MyTuple2 {
-
-  abstract class A
-  case class B(i: Int) extends A
-  case class C(a: A) extends A
-
-  def foo(): Int = {
-    val t = (B(2), C(B(3)))
-    t match {
-      case (B(x), C(y)) => x
-    }
-  } ensuring(_ == 2)
-
-}

testcases/regression/valid/MyTuple3.scala

-object MyTuple3 {
-
-  def foo(): Int = {
-    val t = ((2, 3), true)
-    t._1._2
-  } ensuring( _ == 3)
-
-}

testcases/regression/valid/MyTuple4.scala

-
-object MyTuple4 {
-
-  abstract class A
-  case class B(i: Int) extends A
-  case class C(a: A) extends A
-
-  def foo(): Int = {
-    val t = (1, (C(B(4)), 2), 3)
-    val (a1, (C(B(x)), a2), a3) = t
-    x
-  } ensuring( _ == 4)
-
-}

testcases/regression/valid/MyTuple5.scala

-object MyTuple1 {
-
-  abstract class A
-  case class B(t: (Int, Int)) extends A
-  case class C(a: A) extends A
-
-  def foo(): Int = {
-    val t: (Int, (A, Int), Int) = (1, (C(B((4, 5))), 2), 3)
-    t match {
-      case (_, (B((x, y)), _), _) => x
-      case (_, (C(B((_, x))), _), y) => x
-      case (_, _, x) => x
-    }
-  } ensuring( _ == 5)
-
-}

testcases/regression/valid/MyTuple6.scala

-object MyTuple6 {
-
-  def foo(t: (Int, Int)): (Int, Int) = {
-    require(t._1 > 0 && t._2 > 1)
-    t
-  } ensuring(res => res._1 > 0 && res._2 > 1)
-
-}