Remove unused ad-hoc test files

regression/valid/Array3.scala

-import leon.Utils._
-
-object Array3 {
-
-  def foo(): Int = {
-    val a = Array.fill(5)(3)
-    var i = 0
-    var sum = 0
-    (while(i < a.length) {
-      sum = sum + a(i)
-      i = i + 1
-    }) invariant(i >= 0)
-    sum
-  } ensuring(_ == 15)
-
-}

regression/valid/Array4.scala

-import leon.Utils._
-
-object Array4 {
-
-  def foo(a: Array[Int]): Int = {
-    var i = 0
-    var sum = 0
-    (while(i < a.length) {
-      sum = sum + a(i)
-      i = i + 1
-    }) invariant(i >= 0)
-    sum
-  }
-
-}

regression/valid/Array5.scala

-import leon.Utils._
-
-object Array5 {
-
-  def foo(a: Array[Int]): Int = {
-    var i = 0
-    var sum = 0
-    (while(i < a.length) {
-      sum = sum + a(i)
-      i = i + 1
-    }) invariant(i >= 0)
-    sum
-  }
-
-  def bar(): Int = {
-    val a = Array.fill(5)(5)
-    foo(a)
-  }
-
-}

regression/valid/Array6.scala

-import leon.Utils._
-
-object Array6 {
-
-  def foo(a: Array[Int]): Int = {
-    require(a.length > 2 && a(2) == 5)
-    a(2)
-  } ensuring(_ == 5)
-
-  def bar(): Int = {
-    val a = Array.fill(5)(5)
-    foo(a)
-  }
-
-}

regression/valid/Array7.scala

-import leon.Utils._
-
-object Array7 {
-
-  def foo(a: Array[Int]): Array[Int] = {
-    require(a.length > 0)
-    val a2 = Array.fill(a.length)(0)
-    var i = 0
-    (while(i < a.length) {
-      a2(i) = a(i)
-      i = i + 1
-    }) invariant(a.length == a2.length && i >= 0 && (if(i > 0) a2(0) == a(0) else true))
-    a2
-  } ensuring(_(0) == a(0))
-
-
-}

regression/valid/Array8.scala

-object Array8 {
-
-  def foo(a: Array[Int]): Array[Int] = {
-    require(a.length >= 2)
-    a.updated(1, 3)
-  } ensuring(res => res.length == a.length && res(1) == 3)
-
-}

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

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

regression/valid/Epsilon1.scala

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

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

regression/valid/Epsilon3.scala

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

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

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

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

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

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

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

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

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

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