Homework 2

javali_tests/HW1/Multiplication.javali

@@ -0,0 +1,18 @@
+class Main {
+   void main() {
+      int r1;
+      int i0,  i1;
+		
+      i0 = 5;
+      i1 = 2;
+		
+      r1 = i1 * 3;
+      write(r1); writeln();
+
+      r1 = i0 * i1;
+      write(r1); writeln();
+	
+      r1 = r1 * i0 * i1 * 3;
+      write(r1); writeln();
+   }
+}

javali_tests/HW1/ReadWrite.javali

@@ -0,0 +1,15 @@
+/* Test read/write native functions */
+class Main {
+	void main() {
+		int r1, r2;
+		int i0,  i1,  i2;
+		
+		i0 = 5;
+		i1 = read();
+		
+		r1 = i0 + i1;
+		write(r1); writeln();
+		
+		write(r1 - 3); writeln();
+	}
+}

javali_tests/HW1/ReadWrite.javali.in

@@ -0,0 +1 @@
+22

javali_tests/HW1_nop90/Overflow.javali

@@ -14,7 +14,7 @@ class Main {
 		write(x); writeln();
 		
 		/* performe some operation that should generate an int overflow */
-		x = 2147483640;
+		x = 21474836400;
 		y = 60000;
 		write( x + y); writeln();
 		z = 20000000;

javali_tests/HW2/ErrWhileMissingBrace.javali

@@ -0,0 +1,10 @@
+class Main {
+   void main() {
+      int i;
+    
+      // Note: In Javali, while() loops must have braces ({}) after them,
+      // so this is an expected syntax error.
+      while(true)
+         i = 1;
+  }
+}

javali_tests/HW2/OkInheritance.javali

@@ -0,0 +1,12 @@
+class Base {
+}
+
+class Extends extends Base {
+}
+
+class Main {
+   void main() {
+      write(0);
+      writeln();
+   }
+}

javali_tests/HW2/OkSimpleObject.javali

@@ -0,0 +1,22 @@
+class Main {
+
+   int field;
+  
+   void method() { 
+      write(this.field);
+      writeln();
+   }
+  
+   void method(int withArg) {
+      write(withArg);
+      writeln();
+   }
+  
+   void main() {
+      this.field = 3;
+      method(field);
+      method(3);
+      method(this.field);
+      method();
+   }
+}

javali_tests/HW2/OkSimpleReturn.javali

@@ -0,0 +1,22 @@
+class Main {
+
+   int m() {
+      return 0;
+   }
+	
+	void main() {
+	
+	   int res;
+	   res = -1;
+
+      res = m();
+      write(res);
+      writeln();
+      
+      res = this.m();
+      write(res);
+      writeln();
+      
+	}
+	
+}

javali_tests/HW2/OkSimpleReturnWithExpression.javali

@@ -0,0 +1,27 @@
+class Main {
+
+   int m(int a, int b) {
+      return a + b + 1;
+   }
+	
+	void main() {
+	
+	   int res;
+	   res = -1;
+
+      res = m(1, 2);
+      write(res);
+      writeln();
+      
+      res = this.m(1, 2);
+      write(res);
+      writeln();
+	   
+      write(m(1, 2));
+      writeln();
+      
+      write(this.m(1, 2));
+      writeln();
+	
+	}
+}

javali_tests/HW2_nop90/Arrays.javali

@@ -0,0 +1,24 @@
+/* testing arrays with primitive types as well as new objects
+the if/else statements shows that the array is boolean array is initialized with false
+ */
+class Main {
+    void main() {
+    	int [] testArray;
+    	boolean [] boolarray;
+    	
+    	boolarray = new boolean [3];
+    	testArray = new int [10];
+    	
+    	testArray[5] = 3;
+    	boolarray[1] = true;
+    	
+    	if (boolarray[0]){
+    		write(1);}
+    	else{
+    	write(5);}
+    	writeln();
+    	if (boolarray[1]){
+    		write(1);}
+
+    }
+}

javali_tests/HW2_nop90/Assignments.javali

@@ -0,0 +1,12 @@
+/* testing assign statements*/
+class Main {
+    void main() {
+        a = read();
+        b = methodCall();
+        c = methodCall(param1, param2);
+        d = object.access;
+        e = new Ast();
+        d = new int[size];
+        f = new Object[size];
+    }
+}

javali_tests/HW2_nop90/Casts.javali

@@ -0,0 +1,16 @@
+/* testing casting as well as creating new Objects*/
+class Main
+{
+    void main()
+    {
+        int a;
+        int b;
+        Object c;
+        Object d;
+
+        c = null;
+        d = new Object();
+        a = 10;
+        c = (Object) d;
+    }
+}

javali_tests/HW2_nop90/Division.javali

@@ -0,0 +1,21 @@
+class Main {
+    void main() {
+        int a, b, c, d, e;
+
+        a = 10;
+        b = -1;
+        c = 0;
+        d = 100;
+        e = 2;
+
+        write(a / b); writeln();
+        write(d / e); writeln();
+        write(c / d); writeln();
+        write(b / a + c); writeln();
+        write(d / e * a / b * c); writeln();
+        write(d / e * a / b); writeln();
+        write(d / e + a / b); writeln();
+        write(d / e * a * b * c); writeln();
+        write(d / e * a - b + c); writeln();
+    }
+}

javali_tests/HW2_nop90/DoubleInheritance.javali

@@ -0,0 +1,6 @@
+/* testing basic inheritance*/
+class C1 {}
+class C2 extends C1 {}
+class C3 extends C2 {}
+class C4 extends C2 {}
+class C5 extends C3 {}

javali_tests/HW2_nop90/EightVariablesWrite.javali

@@ -0,0 +1,20 @@
+/* Test expression evaluation with 8 variables */
+class Main {
+	void main() {
+		int r1, r2, r3;
+		int i0,  i1,  i2,  i3,  i4,  i5, i6, i7;
+		
+		i0 = 0;
+		i1 = 1;
+		i2 = 2;
+		i3 = 3;
+		i4 = 4;
+		i5 = 5;
+		i6 = 6;
+		i7 = 7;
+		
+		write(i0 + (i1 + ( i2 + ( i3 + ( i4 + (i5 + (i6 + i7))))))); writeln();
+		write(((((((i0 + i1) + i2) +  i3) +  i4) +  i5) + i6) + i7); writeln();
+		write(((i0 + i1) + (i2 + i3)) + ((i4 + i5) + (i6 + i7))); writeln();
+	}
+}

javali_tests/HW2_nop90/Expressions.javali

@@ -0,0 +1,22 @@
+/* testing different expressions
+compiler should recognize Type error: Return statement of method with void return type should not have arguments
+ */
+class Main {
+    void main() {
+        return;
+        return true;
+        return false;
+        return 0x10;
+        return 10;
+        return variable;
+        return array[index];
+        return methodAccess();
+        return object.field;
+        return object.call();
+        return op + op2;
+        return op / asd * asd && a == true;
+        return this.run();
+        return this;
+        return this.field;
+    }
+}

javali_tests/HW2_nop90/Multiplication.javali

@@ -0,0 +1,31 @@
+class Main {
+   void main() {
+      int r1;
+      int i0,  i1;
+      int x,y,z;
+		
+      i0 = 5;
+      i1 = 2;
+		
+      r1 = i1 * 3;
+      write(r1); writeln();
+
+      r1 = i0 * i1;
+      write(r1); writeln();
+	
+      r1 = r1 * i0 * i1 * 3;
+      write(r1); writeln();
+      
+      y = 5;
+      z = 10;
+      x = (-y * z);
+      write(x); writeln();
+      
+      y = 0;
+      z = - 10;
+      x = (y * z);
+      write(x); writeln();
+      write(y * z); writeln();
+      write(0 * -10); writeln();
+   }
+}

javali_tests/HW2_nop90/NULLTest.javali

@@ -0,0 +1,20 @@
+/* testing null references: 
+assigning null to an int or a boolean results in an error
+write(null) results in a parser failure
+ */
+class Main {
+    void main() {
+    	int a;
+    	boolean b;
+    	Object c;
+    	
+    	a = null;
+    	b = null;
+    	c = null;
+    	
+    	write(a);
+    	writeln();
+    	//write(null)
+
+    }
+}

javali_tests/HW2_nop90/OrderOfDeclarations.javali

@@ -0,0 +1,8 @@
+/*Check the order of the declarations in the generated parser
+* Do the variables come always first or in their place? */
+class ClassName {
+    void a() {}
+    int a;
+    void a() {}
+    void tests(boolean d, nulle a) {}
+}

javali_tests/HW2_nop90/Overflow.javali

@@ -0,0 +1,25 @@
+/* Test what happens for Integers that are to big for 32bits 
+2147483647 (=0x7FFFFFFF) is the biggest integer in 32bits (IntMAX)
+*/
+class Main {
+	void main() {
+		int x,y,z;
+		x = 2147483647;
+		write( x ); writeln();
+		/* add 1 to IntMax and output it */
+		write( x + 1); writeln();
+		
+		/* read an int bigger than IntMAX */
+        x = read();
+		write(x); writeln();
+		
+		/* performe some operation that should generate an int overflow */
+		x = 21474836400;
+		y = 60000;
+		write( x + y); writeln();
+		z = 20000000;
+		write( y * z); writeln();
+		write( (y * z) ); writeln();
+		
+	}
+}

javali_tests/HW2_nop90/Overflow.javali.in

@@ -0,0 +1 @@
+2147483647

javali_tests/HW2_nop90/ParamLists.javali

@@ -0,0 +1,15 @@
+/*Testing all related to methods (declaration and execution)*/
+class Main {
+    void main() {
+        callWithParams(a, b, c, 0, false);
+        object.call(a, b, d);
+    }
+
+    int method(int a, String b, int[] c) {
+
+    }
+
+    int[] method2() {}
+    Object method3() {}
+    Model[] method4() {}
+}

javali_tests/HW2_nop90/ReadWrite.javali

@@ -0,0 +1,26 @@
+/* Test read/write native functions */
+class Main {
+	void main() {
+		int r1, r2, readvar, a1;
+		
+		r1 = 6;
+		/* r2 = 22 */
+		r2 = read();
+		
+		write(r1); writeln(); // 6
+		
+		/* test expressions inside write() */
+		write(r1 - 3); writeln(); // 3
+		write(r1 - 6); writeln(); // 0
+		write(r1 - 7); writeln(); // -1
+		/* should output 111 */
+        readvar = read(); // 1
+		write( (r1 + (r2 * 5)) + readvar); // 117
+		write(- r1); // -6
+		writeln();
+		/* should output 15 */
+        a1 = read(); // -15
+		write(- a1); // 15
+		
+	}
+}

javali_tests/HW2_nop90/ReadWrite.javali.in

@@ -0,0 +1,6 @@
+     22
+
+
+    1
+
+-15

javali_tests/HW2_nop90/Statements.javali

@@ -0,0 +1,34 @@
+/* testing different statements
+'condition' is not initialized
+ */
+class Main {
+    void main() {
+        if (condition) {
+            instructions();
+            asd.b = c;
+            if (cond2) {
+
+            } else {
+                nonEmptyBlock = a;
+            }
+        } else {
+
+        }
+        // Whiles
+        while (condition) {
+            while (anotherLoop == false) {
+                nestedLoops();
+            }
+        }
+        while (false) {} // emptyloop
+        // Returns
+        return; // empty
+        return expr; // with expressions (expressions already tested)
+        return array[index];
+        // Writes
+        write(a);
+        write(9 + 10);
+        writeln();
+        write(call());
+    }
+}

javali_tests/HW2_nop90/UnaryOperators.javali

@@ -0,0 +1,15 @@
+class Main {
+    void main() {
+        int a, b;
+
+        a = 1;
+        b = 2;
+
+        write(+a); writeln();
+        write(-a); writeln();
+        write(+a --b); writeln();
+        write(-a--b); writeln();
+        write(-----a-----5--b); writeln();
+        write(-----a*---------b);writeln();
+    }
+}

javali_tests/HW2_nop90/conditionExpressions.javali

@@ -0,0 +1,24 @@
+/* testing conditions*/
+class Main {
+    void main() {
+    	boolean a;
+        int b,c, d, e;
+    	b = 10;
+    	c = 3;
+    	d = 40;
+    	e = 1;
+        
+        while ( b > c ) {
+       		write(b);
+       		b = b-1;
+         }
+		a = c < (b+4-5/2);
+		if (a){
+			write(13);}
+		if (100/2>d*e){
+			while(e<d){
+				d = d/2;}}
+		
+}
+
+}

javali_tests/HW2_nop90/invalidCasts.javali

@@ -0,0 +1,12 @@
+/* testing invalid casts */
+class Main
+{
+    void main()
+    {
+        int a;
+        Object d;
+        d = new Object();
+        a = (Object) d;
+        a = (boolean[]) a;
+    }
+}

javali_tests/HW2_nop90/newTest.javali

@@ -0,0 +1,14 @@
+class Main {
+    void main() {
+    	boolean b;
+        int a,c,n;
+    	a = 10;
+        //b = true;
+        
+        while ( a>0 ) {
+       		a = a-1;
+         }
+
+
+
+}

javali_tests/HW2_nop90/noParentheses.javali

@@ -0,0 +1,24 @@
+/* test	what happens if there are no parentheses */
+
+class Main {
+   void main() {
+      int x;
+      int y;
+      int z;
+
+      x = 5;
+      y = 10;
+      z = 100;
+      
+      write( x + y + z); writeln();
+      /*  */
+      write( - x + y - z); writeln();
+      
+      /* should output 205 */
+      write( x + 2 * z); writeln();
+
+      write( x + 2 * z / x + 1); writeln();
+      write(+x); writeln();
+      
+   }
+}