info/labs/lab05/test/resources/execution/passing/Arithmetic.grading.amy

+object Arithmetic
+  def pow(b: Int(32), e: Int(32)): Int(32) = {
+    if (e == 0) { 1 }
+    else {
+      if (e % 2 == 0) {
+        val rec: Int(32) = pow(b, e/2);
+        rec * rec
+      } else {
+        b * pow(b, e - 1)
+      }
+    }
+  }
+
+  def gcd(a: Int(32), b: Int(32)): Int(32) = {
+    if (a == 0 || b == 0) {
+      a + b
+    } else {
+      if (a < b) {
+        gcd(a, b % a)
+      } else {
+        gcd(a % b, b)
+      }
+    }
+  }
+
+  Std.printInt(pow(0, 10));
+  Std.printInt(pow(1, 5));
+  Std.printInt(pow(2, 10));
+  Std.printInt(pow(3, 3));
+  Std.printInt(gcd(0, 10));
+  Std.printInt(gcd(17, 99)); // 1
+  Std.printInt(gcd(16, 46)); // 2
+  Std.printInt(gcd(222, 888)) // 222
+end Arithmetic
\ No newline at end of file

info/labs/lab05/test/resources/execution/passing/BasicArithmetic.grading.amy

+object BasicArithmetic
+
+	def plus(a: Int(32), b: Int(32)): Int(32) = {
+		a + b
+	}
+
+	def minus(a: Int(32), b: Int(32)): Int(32) = {
+		a - b
+	}
+
+	def mul(a: Int(32), b: Int(32)): Int(32) = {
+		a * b
+	}
+
+	def mod(a: Int(32), b: Int(32)): Int(32) = {
+		a % b
+	}
+
+	def div(a: Int(32), b: Int(32)): Int(32) = {
+		a / b
+	}
+
+	val a: Int(32) = 1;
+	val b: Int(32) = 2;
+
+	Std.printString(Std.intToString(plus(a, b)));
+	Std.printString(Std.intToString(mul(plus(a, b), b)));
+	Std.printString(Std.intToString(minus(mul(plus(a, b), b), b)));
+	Std.printString(Std.intToString(mul(minus(mul(plus(a, b), b), b), b)));
+
+	Std.printString(Std.intToString(div(4, 2)));
+	Std.printString(Std.intToString(div(3, 2)));
+	Std.printString(Std.intToString(div(1, 2)));
+	Std.printString(Std.intToString(div(-1, 2)));
+	Std.printString(Std.intToString(div(-2, 2)));
+	Std.printString(Std.intToString(div(-3, 2)));
+
+	Std.printString(Std.intToString(mod(5, 2)));
+	Std.printString(Std.intToString(mod(-5, 2)));
+
+	Std.printString("test finished")
+end BasicArithmetic

info/labs/lab05/test/resources/execution/passing/BasicBranching.grading.amy

+object BasicBranching
+
+	def less(a: Int(32), b: Int(32)): Boolean = {
+		a < b
+	}
+
+	def lessOrEqual(a: Int(32), b: Int(32)): Boolean = {
+		a <= b
+	}
+
+	def test1(): Unit = {
+		val a: Int(32) = 1;
+		val b: Int(32) = a + 1;
+		if(less(a, b)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		}
+	}
+
+	def test2(): Unit = {
+		val a: Int(32) = 1;
+		val b: Int(32) = a + 1;
+		if(less(a, 1)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		}
+	}
+
+	def test3(): Unit = {
+		val a: Int(32) = 1;
+		val b: Int(32) = a + 1;
+		if(less(b, a)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		}
+	}
+
+	def test4(): Unit = {
+		val a: Int(32) = 1;
+		val b: Int(32) = a + 1;		
+		if(lessOrEqual(a, a)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		}		
+	}
+
+	def test(): Unit = {
+		val a: Int(32) = 1;
+		val b: Int(32) = a + 1;
+		if(less(a, b)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		};
+
+		if(less(a, 1)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		};
+
+		if(less(b, a)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		};
+
+		if(lessOrEqual(a, a)) {
+			Std.printString("correct")
+		} else {
+			Std.printString("not correct")
+		}
+	}
+
+	test();
+
+	Std.printString("test finished")
+end BasicBranching

info/labs/lab05/test/resources/execution/passing/BasicConditions.grading.amy

+object BasicConditions
+
+	def neverTrigger(): Boolean = {
+		Std.printString("should not happen");
+		true
+	}
+
+	val c1: Boolean = true || neverTrigger();
+	val c2: Boolean = false && neverTrigger();
+
+	Std.printString("test finished")
+end BasicConditions
\ No newline at end of file

info/labs/lab05/test/resources/execution/passing/BasicPatternMatching.grading.amy

+object BasicPatternMatching
+  abstract class Letter
+  case class A() extends Letter
+  case class APrim(i: Int(32)) extends Letter
+  case class B() extends Letter
+  case class BPrim(i: Int(32)) extends Letter
+ 
+  def isRegularLetter(l: Letter): Boolean = { 
+  	l match {
+		case A() => true
+		case B() => true
+		case APrim(_) => false 
+		case BPrim(_) => false
+	}
+  }
+
+  def getPrimNumber(l: Letter): Int(32) = {
+  	!isRegularLetter(l) match {
+  		case false => 42
+  		case true => l match {
+  			case APrim(i) => i
+  			case BPrim(i) => i
+  		}
+  	}
+  }
+
+  def isPrimLetter(l: Letter): String = {
+    getPrimNumber(l) match {
+      case 42 => "not prim"
+      case _ => "prim"
+    }
+  }
+
+
+  val a: Letter = A();
+  val ap: Letter = APrim(2);
+  val b: Letter = B();
+  val bp: Letter = BPrim(3);
+  
+  Std.printString(Std.intToString(getPrimNumber(a)));
+  Std.printString(Std.intToString(getPrimNumber(b)));
+  Std.printString(Std.intToString(getPrimNumber(ap)));
+  Std.printString(Std.intToString(getPrimNumber(bp)));
+
+  Std.printString(isPrimLetter(ap));
+  Std.printString(isPrimLetter(bp));
+  Std.printString(isPrimLetter(a));
+  Std.printString(isPrimLetter(b));
+
+  Std.printString("test finished")
+end BasicPatternMatching
\ No newline at end of file

info/labs/lab05/test/resources/execution/passing/EmptyObject.amy

+object EmptyObject
+
+end EmptyObject
\ No newline at end of file

info/labs/lab05/test/resources/execution/passing/Equality.grading.amy

+object Equality
+  abstract class Foo
+  case class Foo1() extends Foo
+  case class Foo2() extends Foo
+
+  Std.printString(Std.booleanToString(0 == 0));
+  Std.printString(Std.booleanToString(0 == 1));
+  Std.printString(Std.booleanToString(true == true));
+  Std.printString(Std.booleanToString(true == false));
+  Std.printString(Std.booleanToString(() == ()));
+  Std.printString(Std.booleanToString("hello" == "hello"));
+  Std.printString(Std.booleanToString("hello" == "hel" ++ "lo"));
+  Std.printString(Std.booleanToString(val h: String = "hello"; h == h));
+  Std.printString(Std.booleanToString(Foo1() == Foo1()));
+  Std.printString(Std.booleanToString(Foo1() == Foo2()));
+  Std.printString(Std.booleanToString(val f: Foo = Foo1(); f == f));
+  Std.printString(Std.booleanToString(val f: Foo = Foo1(); val g: Foo = f; f == g))
+end Equality

info/labs/lab05/test/resources/execution/passing/Factorial.grading.amy

+object Factorial
+  def fact(i: Int(32)): Int(32) = {
+    if (i < 2) { 1 }
+    else { i * fact(i-1) }
+  }
+
+  Std.printString("5! = "  ++ Std.intToString(fact(5)));
+  Std.printString("10! = " ++ Std.intToString(fact(10)))
+end Factorial

info/labs/lab05/test/resources/execution/passing/FunCallEnv.grading.amy

+object FunCallEnv
+  def printRec(i: Int(32), j: Int(32)): Unit = {
+    if (i <= 0) { () } else {
+      Std.printInt(i);
+      Std.printInt(j);
+      printRec(i - 1, j / 2)
+    }
+  }
+
+  printRec(3, 8)
+
+end FunCallEnv

info/labs/lab05/test/resources/execution/passing/IntInputToOutput.grading.amy

+object IntInputToOutput
+  val intInput: Int(32) = Std.readInt();
+  Std.printString(Std.intToString(intInput))
+end IntInputToOutput
\ No newline at end of file

info/labs/lab05/test/resources/execution/passing/List.amy

+object L
+  abstract class List
+  case class Nil() extends List
+  case class Cons(h: Int(32), t: List) extends List
+ 
+  def isEmpty(l : List): Boolean = { l match {
+    case Nil() => true
+    case _ => false 
+  }}
+
+  def length(l: List): Int(32) = { l match {
+    case Nil() => 0
+    case Cons(_, t) => 1 + length(t)
+  }}
+
+  def head(l: List): Int(32) = {
+    l match {
+      case Cons(h, _) => h
+      case Nil() => error("head(Nil)")
+    }
+  }
+
+  def headOption(l: List): O.Option = {
+    l match {
+      case Cons(h, _) => O.Some(h)
+      case Nil() => O.None()
+    }
+  }
+
+  def reverse(l: List): List = {
+    reverseAcc(l, Nil())
+  }
+
+  def reverseAcc(l: List, acc: List): List = {
+    l match {
+      case Nil() => acc
+      case Cons(h, t) => reverseAcc(t, Cons(h, acc))
+    }
+  }
+
+  def indexOf(l: List, i: Int(32)): Int(32) = {
+    l match {
+      case Nil() => -1
+      case Cons(h, t) =>
+        if (h == i) { 0 }
+        else {
+          val rec: Int(32) = indexOf(t, i);
+          if (0 <= rec) { rec + 1 }
+          else { -1 }
+        }
+    }
+  }
+
+  def range(from: Int(32), to: Int(32)): List = {
+    if (to < from) { Nil() }
+    else {
+      Cons(from, range(from + 1, to))
+    }
+  }
+
+  def sum(l: List): Int(32) = { l match {
+    case Nil() => 0
+    case Cons(h, t) => h + sum(t)
+  }}
+
+  def concat(l1: List, l2: List): List = {
+    l1 match {
+      case Nil() => l2
+      case Cons(h, t) => Cons(h, concat(l1, l2))
+    }
+  }
+
+  def contains(l: List, elem: Int(32)): Boolean = { l match {
+    case Nil() =>
+      false
+    case Cons(h, t) =>
+      h == elem || contains(t, elem)
+  }}
+
+  abstract class LPair
+  case class LP(l1: List, l2: List) extends LPair
+
+  def merge(l1: List, l2: List): List = {
+    l1 match {
+      case Nil() => l2
+      case Cons(h1, t1) =>
+        l2 match {
+          case Nil() => l1
+          case Cons(h2, t2) =>
+            if (h1 <= h2) {
+              Cons(h1, merge(t1, l2))
+            } else {
+              Cons(h2, merge(l1, t2))
+            }
+        }
+    }
+  }
+
+  def split(l: List): LPair = {
+    l match {
+      case Cons(h1, Cons(h2, t)) =>
+        val rec: LPair = split(t);
+        rec match {
+          case LP(rec1, rec2) =>
+            LP(Cons(h1, rec1), Cons(h2, rec2))
+        }
+      case _ =>
+        LP(l, Nil())
+    }
+  }
+  def mergeSort(l: List): List = {
+    l match {
+      case Nil() => l
+      case Cons(h, Nil()) => l
+      case l =>
+        split(l) match {
+          case LP(l1, l2) =>
+            merge(mergeSort(l1), mergeSort(l2))
+        }
+    }
+  }
+  
+  def toString(l: List): String = { l match {
+    case Nil() => "List()"
+    case more => "List(" ++ toString1(more) ++ ")"
+  }}
+
+  def toString1(l : List): String = { l match {
+    case Cons(h, Nil()) => Std.intToString(h)
+    case Cons(h, t) => Std.intToString(h) ++ ", " ++ toString1(t)
+  }}
+
+  def take(l: List, n: Int(32)): List = {
+    if (n <= 0) { Nil() }
+    else { 
+      l match {
+        case Nil() => Nil()
+        case Cons(h, t) =>
+          Cons(h, take(t, n-1))
+      }
+    }
+  }
+    
+end L

info/labs/lab05/test/resources/execution/passing/Locals.grading.amy

+object Locals
+  def foo(i: Int(32)): Int(32) = {
+    val i: Int(32) = 0;
+    if (i == 1) { error("") }
+    else { 0 }
+  }
+
+  foo(1)
+end Locals

info/labs/lab05/test/resources/execution/passing/Match1.grading.amy

+object MatchError
+  abstract class Foo
+  case class Bar(i: Int(32)) extends Foo
+  case class Baz(f1: Foo, f2: Foo) extends Foo
+
+  Baz(Baz(Baz(Bar(1), Bar(2)), Bar(3)), Bar(4)) match {
+    case Baz(Baz(Baz(Bar(1), Bar(2)), Bar(3)), Bar(4)) =>
+      ()
+  }
+end MatchError

info/labs/lab05/test/resources/execution/passing/Match2.grading.amy

+object MatchError
+  abstract class Foo
+  case class Bar(i: Int(32), b: Boolean, u: Unit) extends Foo
+
+  Bar(10, true, ()) match { case Bar(10, true, ()) => () }
+end MatchError

info/labs/lab05/test/resources/execution/passing/Match3.grading.amy

+object MatchError
+  abstract class Foo
+  case class Bar(i: Int(32)) extends Foo
+  case class Baz(f1: Foo, f2: Foo) extends Foo
+
+  Baz(Baz(Bar(1), Bar(2)), Baz(Bar(3), Bar(4))) match {
+    case Baz(Baz(_, Bar(_)), _) => ()
+  }
+end MatchError

info/labs/lab05/test/resources/execution/passing/Match4.grading.amy

+object Match4
+  def sideEffect(): Int(32) = {
+    Std.printString("This side effect should only happen once!");
+    10
+  }
+
+  sideEffect() match {
+    case 1  => Std.printString("no"); false
+    case 2  => Std.printString("no"); false
+    case 10 => Std.printString("yes"); true
+  }
+end Match4

info/labs/lab05/test/resources/execution/passing/MixStdAndNonStd.grading.amy

+object MixStdAndNonStd
+  def printString(str: String): Unit = {
+    Std.printString(str);
+    Std.printString(str)
+  }
+
+  val intInput: Int(32) = Std.readInt();
+  printString(Std.intToString(intInput))
+end MixStdAndNonStd
\ No newline at end of file

info/labs/lab05/test/resources/execution/passing/Option.amy

+object O
+  abstract class Option
+  case class None() extends Option
+  case class Some(v: Int(32)) extends Option
+
+  def isDefined(o: Option): Boolean = {
+    o match {
+      case None() => false
+      case _ => true
+    }
+  }
+
+  def get(o: Option): Int(32) = {
+    o match {
+      case Some(i) => i
+      case None() => error("get(None)")
+    }
+  }
+
+  def getOrElse(o: Option, i: Int(32)): Int(32) = {
+    o match {
+      case None() => i
+      case Some(oo) => oo
+    }
+  }
+
+  def orElse(o1: Option, o2: Option): Option = {
+    o1 match {
+      case Some(_) => o1
+      case None() => o2
+    }
+  }
+
+  def toList(o: Option): L.List = {
+    o match {
+      case Some(i) => L.Cons(i, L.Nil())
+      case None() => L.Nil()
+    }
+  }
+end O

info/labs/lab05/test/resources/execution/passing/ShortCircuit.grading.amy

+object ShortCircuit
+  true || error("");
+  false && error("")
+end ShortCircuit

info/labs/lab05/test/resources/execution/passing/SideEffect.grading.amy

+object SideEffect
+
+  def firstI(): Int(32) = {
+    Std.printInt(1);
+    1
+  }
+
+  def secondI(): Int(32) = {
+    Std.printInt(2);
+    2
+  }
+
+  def stringLeft(): String = {
+    Std.printString("SLeft");
+    "a"
+  }
+
+  def stringRight(): String = {
+    Std.printString("SRight");
+    "a"
+  }
+
+  def caseLeft(): L.List = {
+    Std.printString("CLeft");
+    L.Nil()
+  }
+
+  def caseRight(): L.List = {
+    Std.printString("CRight");
+    L.Nil()
+  }
+
+  // Make sure that operands to binary operations are interpreted only once
+  // and in the right order
+  firstI() + secondI();
+  firstI() - secondI();
+  firstI() * secondI();
+  firstI() / secondI();
+  firstI() % secondI();
+
+  firstI() < secondI();
+  firstI() <= secondI();
+
+  // Make sure that the rhs of comparisons to Unit (which always succeed)
+  // are interpreted.
+  Std.printString("Left") == Std.printString("Right");
+
+  // Make sure that string comparisons evaluate their arguments once
+  // and in the correct order
+  stringLeft() == stringRight();
+
+  // Make sure that case class comparisons evaluate their arguments once
+  // and in the correct order
+  caseLeft() == caseRight();
+  ()
+
+end SideEffect
\ No newline at end of file