Java und jav files

bin/mycompiler/test/blocks/TestForStmt.jav

@@ -0,0 +1,32 @@
+
+public class TestForStmt {
+
+	public void m1() {
+	
+		i;
+		for (i=0;i<5;i++) {
+			
+		}
+	}
+	
+	public void m2() {
+		i;
+		for (i=0;i<5;i++) {
+			j;
+			j="abc";
+		}
+		j;
+		j=3;
+	}
+	
+	public m3() {
+		i;
+		for (i=0;i<5;i++) {
+			j;
+			for (j=0;j<5;j++) {
+				return i==j;
+			}
+		}
+	}
+
+}

bin/mycompiler/test/blocks/TestIfStmt.jav

@@ -0,0 +1,27 @@
+import java.util.Vector;
+
+public class TestIfStmt {
+
+	public m1() {
+		a;
+		if (a) {
+			return a;
+		}	
+		else
+			return false;
+	}
+	
+	public m2() {
+		a;
+		c;
+		a = new Vector<Integer>();
+		if (a.isEmpty()) {
+			c="empty";
+		}
+		else if (a.size()==1) {
+			c="almost empty";
+		}
+		else
+			return a;
+	}
+}

bin/mycompiler/test/blocks/TestInferenceAcrossBlocks.jav

@@ -0,0 +1,12 @@
+public class TestInferenceAcrossBlocks{
+	
+	public m(a){
+		if(a==true){
+			return 3;
+		}
+		else {
+			x;
+			return x;
+		}
+	}
+}

bin/mycompiler/test/blocks/TestSimpleBlocks.jav

@@ -0,0 +1,18 @@
+public class TestSimpleBlocks{
+	
+	public m(a){
+		{
+			d;
+			d = 'a';
+			{
+				c;
+				c = d;
+			}
+			{
+				c;
+				c = d==a;
+			}
+		}
+		return a;
+	}
+}

bin/mycompiler/test/blocks/TestSimpleVariable.jav

@@ -0,0 +1,7 @@
+public class TestSimpleVariable {
+
+	public m() {
+		c;
+	}
+
+}

bin/mycompiler/test/blocks/TestSwitchStmt.jav

@@ -0,0 +1,11 @@
+public class TestSwitchStmt {
+
+	public m(a) {
+		switch (a) {
+			case 1: return a++; break;
+			case 2: return a--; break;
+			default: return a;
+	}
+
+
+}

bin/mycompiler/test/blocks/TestTryCatchBlock.jav

@@ -0,0 +1,14 @@
+public class TestTryCatchBlock {
+	
+	public m() {
+		
+		try {
+			return new TestTryCatchBlock();
+		}
+		catch (e) {
+			return null;
+		}
+		
+	}
+
+}

bin/mycompiler/test/blocks/TestUndeterminedReturnNegative.jav

@@ -0,0 +1,12 @@
+
+public class TestUndeterminedReturnNegative {
+
+	public m1(a) {
+		if (a) {
+			a=false;
+		}	
+		else
+			return false;
+	}
+	
+}

bin/mycompiler/test/blocks/TestUninitializedVariable.jav

@@ -0,0 +1,11 @@
+public class TestUninitializedVariable {
+
+	public void m1() {
+		a;
+		a++;
+	}
+	
+	<T extends java.lang.Number> void m2(T a) {
+	}
+
+}

bin/mycompiler/test/blocks/TestWhileStmt.jav

@@ -0,0 +1,9 @@
+public class TestWhileStmt {
+
+	public m1() {
+		i;
+		while (true)
+			i++;
+	}
+
+}

bin/mycompiler/test/complexTypes/TestOwnClassMember.jav

@@ -0,0 +1,9 @@
+public class TestOwnClassMember { 
+
+  Integer a; 
+
+  public void m1(b) { 
+    b += a; 
+  } 
+  
+} 

bin/mycompiler/test/complexTypes/TestOwnClassMethod.jav

@@ -0,0 +1,12 @@
+public class TestOwnClassMethod { 
+
+  Integer a; 
+
+  public void m1(b) { 
+    a += b; 
+  } 
+
+  public void m2(c, d) { 
+    c.m1(d);
+  }
+ }

bin/mycompiler/test/complexTypes/TestStandardLibInheritanceInference.jav

@@ -0,0 +1,12 @@
+import java.io.OutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.BufferedOutputStream;
+import java.sql.Connection;
+
+
+class TestStandardLibInheritanceInference{
+	foo(x){
+		x.close();
+	}
+}

bin/mycompiler/test/complexTypes/TestStandardLibMember.jav

@@ -0,0 +1,11 @@
+import java.lang.System;
+import java.io.PrintStream;
+
+public class TestStandardLibMember {
+
+	public m1() {
+		a;
+		a=System.out;
+		a.println();
+	}
+}

bin/mycompiler/test/complexTypes/TestStandardLibMethod.jav

@@ -0,0 +1,20 @@
+import java.util.HashMap;
+import java.util.Vector;
+
+public class TestStandardLibMethod {
+	
+	public m1() {
+		a;
+		a = new HashMap<String,Integer>();
+		a.put("2",-1);
+	}
+	
+	public m2(Vector<Vector<Integer>> m){
+		k;
+		k = 0;
+		ret;
+		ret = m.elementAt(k).elementAt(k).intValue();
+		return ret;
+	}
+
+}

bin/mycompiler/test/generics/TestAssignmentTwoGenericTypesNegative.jav

@@ -0,0 +1,12 @@
+import java.util.ArrayList;
+
+public class TestAssignmentTwoGenericTypesNegative {
+
+	public void m() {
+	
+		ArrayList<String> ls;
+		ls = new ArrayList<String>();
+		ArrayList<Object> lo;
+		lo = ls; /*<-- compile error*/
+	}
+}

bin/mycompiler/test/generics/TestClassesWithBoundedGenericsOfTwoTypes.jav

@@ -0,0 +1,17 @@
+interface I1 {}
+
+interface I2 {}
+
+class Implementation implements I1 {}
+
+class Implementation2 implements I2 {}
+
+class A<T extends I1> {}
+
+class B<T extends I1 & I2>{}
+
+class C<T extends I1 & Implementation>{}
+
+class D<T extends I2 & Implementation>{}
+
+class E<T extends Implementation & Implementation2>{}

bin/mycompiler/test/generics/TestClassesWithBoundedGenericsUsedInMethods.jav

@@ -0,0 +1,21 @@
+interface I1 {
+	public m1();
+}
+
+class Implementation implements I1 {
+	public m1() {
+	}
+}
+
+class TestClassesWithBoundedGenericsUsedInMethods<T extends I1> {
+	
+	/*since S is at least of Type I1, call m1() should work*/
+	public <S extends I1> void m3 (S x) {
+		x.m1();
+	}
+	
+	/*T is bounded by class generics, thus always at least of type I1*/
+	public m2(T x) {
+		x.m1();
+	}
+}

bin/mycompiler/test/generics/TestExtendedClassesWithBoundedGenerics.jav

@@ -0,0 +1,34 @@
+interface I1 {
+	public m1();
+}
+
+interface I2 {
+	public m2();
+}
+
+class Implementation implements I1, I2 {
+	public m1() {}
+	
+	public m2() {}
+}
+
+class Tester<T extends I1 & I2> {
+	
+	public m3(T x) {
+		x.m1();
+		x.m2();
+	}
+}
+
+public class TestExtendedClassesWithBoundedGenerics {
+
+	public m() {
+		x;
+		/*can only be of Type Implementation*/
+		x= new Implementation();
+		y;
+		/*could be of Type: Tester<Implementation>, Tester<? super Implementation>*/
+		y= new Tester<Implementation>();
+		y.m3(x);
+	}
+}

bin/mycompiler/test/generics/TestNestedGenerics.jav

@@ -0,0 +1,14 @@
+class A<T>{
+ 
+}
+
+public class TestNestedGenerics{
+ <T extends A<C>,C> void foo(T a,C b){}
+ 
+ void m(){
+  TestNestedGenerics t = new TestNestedGenerics();
+  String str = new String();
+  A<String> a = new A<String>();
+  t.foo(a,str);
+ }
+}

bin/mycompiler/test/generics/TestNestedGenericsNonExistingType.jav

@@ -0,0 +1,6 @@
+
+public class TestNestedGenerics{
+ 
+ <T extends A<C>,C> void foo(T a,C b){}
+ 
+}

bin/mycompiler/test/generics/TestSimpleClassesWithBoundedGenerics.jav

@@ -0,0 +1,30 @@
+import java.util.Vector;
+import java.util.HashMap;
+
+public class TestSimpleClassesWithBoundedGenerics<T extends java.lang.Number> {
+
+	public ma(T x) {
+		return x;
+	}
+}
+
+class A {
+
+	public m1() {
+		x;
+		x= new TestSimpleClassesWithBoundedGenerics<Integer>();
+		return x.ma(3);
+	}
+	
+	public m2() {
+		x;
+		x = new TestSimpleClassesWithBoundedGenerics<Double>();
+	}
+/*
+	public m2() {
+		x;
+		x= new TestSimpleClassesWithBoundedGenerics<Double>();
+		return x.m(new Double(3.));
+	}
+*/
+}

bin/mycompiler/test/generics/TestSimpleClassesWithBoundedGenericsNegative.jav

@@ -0,0 +1,17 @@
+
+public class TestSimpleClassesWithBoundedGenericsNegative<T extends java.lang.Number> {
+
+	public m(T x) {
+		return x;
+	}
+
+}
+
+class A {
+	public m1() {
+		x;
+		x = new TestSimpleClassesWithBoundedGenericsNegative<String>();
+		return x.m("abc");
+	
+	}
+}

bin/mycompiler/test/generics/TestSimpleClassesWithGenerics.jav

@@ -0,0 +1,17 @@
+public class TestSimpleClassesWithGenerics<T> {
+	
+	public m(T x) {
+		return x;
+	}
+
+}
+
+class A {
+
+	public method() {
+		x;
+		x= new TestSimpleClassesWithGenerics<Integer>();
+		return x.m(3);
+	}
+
+}

bin/mycompiler/test/generics/TestSimpleClassesWithGenericsNegative.jav

@@ -0,0 +1,17 @@
+public class TestSimpleClassesWithGenericsNegative<T> {
+	
+	public m(T x) {
+		return x;
+	}
+
+}
+
+class A {
+
+	public method() {
+		x;
+		x= new TestSimpleClassesWithGenerics<Integer>();
+		return x.m("abc");
+	}
+
+}

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceOwnTypeByMember.jav

@@ -0,0 +1,16 @@
+public class TestInferenceOwnTypeByMember { 
+
+  Float a; 
+
+  public void m1(b) { 
+    a += b; 
+  }
+  
+  public void m2(a) {
+  	this.a=a;
+  }
+  
+  public m3() {
+  	return a;
+  }
+} 

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceOwnTypeByMemberAcrossClasses.jav

@@ -0,0 +1,14 @@
+class A {
+
+	public Character c;
+
+}
+
+public class TestInferenceOwnTypeByMemberAcrossClasses {
+	
+	public m1(a) {
+		x;
+		x = new A();
+		a=x.c;
+	}
+}

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceOwnTypeByMethodCall.jav

@@ -0,0 +1,32 @@
+public class TestInferenceOwnTypeByMethodCall{ 
+
+  public m1(a) { 
+    return a; 
+  } 
+  
+  public Integer m2(a) {
+  	return a;
+  }
+  
+  public m3(a) {
+  	return a;
+  }
+
+
+
+  public void m01(d) { 
+  	e;
+    e=m1(d);
+  }
+  
+  public void m02(d) {
+  	e;
+  	e=m2(d);
+  }
+  
+  public void m03(c,Character d) {
+  	e;
+  	e=c.m3(d);
+  }
+  
+ }

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceOwnTypeByMethodCallAcrossClasses.jav

@@ -0,0 +1,18 @@
+class A{
+	public mA(x){
+		return(x);
+	}
+}
+
+class TestInferenceOwnTypeByMethodCallAcrossClasses{
+	
+	public m(Integer a, String b){
+		x;
+		x=new A();
+		c;
+		c=x.mA(a);
+		d;
+		d=x.mA(b);
+		
+	}
+}

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceOwnTypeByMethodParameter.jav

@@ -0,0 +1,19 @@
+class A {
+	static void m() {}
+}
+
+public class TestInferenceOwnTypeByMethodParameter {
+
+	m1(a,b) {
+		return a+b;		
+	}
+	
+	m2(java.lang.String a) {
+		return a;
+	}
+	
+	m3(a) {
+		return a.m();
+	}
+
+}

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceOwnTypeByMethodReturnTypeMixed1.jav

@@ -0,0 +1,20 @@
+class A1{
+		void foo(java.lang.String x){}
+}
+class A2{
+		void foo(java.lang.Integer y){}
+}
+class B1{
+		java.lang.String bar(){return("");}
+}
+class B2{
+		java.lang.Integer bar(){return(1);}
+}
+public class TestInferenceOwnTypeByMethodReturnTypeMixed1{
+		method1(a,b){	
+			a.foo(b.bar());
+		}
+		method2(a,B2 b) {
+			a.foo(b.bar());
+		}
+}	

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceOwnTypeByReturnType.jav

@@ -0,0 +1,18 @@
+public class TestInferenceOwnTypeByReturnType {
+
+	public java.lang.Integer m1(a) {
+		return a;
+	}
+	
+	public String m2() {
+		return "abc";
+	}
+	
+	public void m3(a) {
+		a=m2();
+	}
+	
+	public java.lang.Integer m4(a,b) {
+		return a+b;
+	}
+}

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceOwnTypeByReturnTypeAcrossClasses.jav

@@ -0,0 +1,23 @@
+class  A{
+	public String m() {
+		return "abc";
+	}
+}
+
+class B{
+	public Integer m() {
+		return 1;
+	}
+}
+
+public class TestInferenceOwnTypeByReturnTypeAcrossClasses {
+
+	public main1(java.lang.Integer i, x){
+		i=x.m();
+	}
+	
+	public main2(i,x) {
+		i=x.m();
+	}
+
+}

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceStdTypeByMember.jav

@@ -0,0 +1,9 @@
+import java.lang.System;
+
+public class TestInferenceStdTypeByMember {
+
+	public m1(a) {
+		a=System.out;
+	}
+
+}

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceStdTypeByOperation.jav

@@ -0,0 +1,13 @@
+import java.util.HashMap;
+import java.lang.Object;
+
+public class TestInferenceStdTypeByOperation {
+
+	public m1(a) {
+		a.put("1","1");
+	}
+	
+	public m2(b) {
+		b.toString();
+	}
+}

bin/mycompiler/test/inferenceByCharacteristic/TestInferenceStdTypeByReturnType.jav

@@ -0,0 +1,18 @@
+import java.util.Vector;
+import java.util.ArrayList;
+
+public class TestInferenceStdTypeByReturnType {
+	
+	public void m1(a) {
+		b;
+		b= new Vector<String>();
+		a = b.size();
+	}
+	
+	public void m2(a) {
+		b;
+		b= new ArrayList<String>();
+		a = b.get(0);
+	
+	}
+}

bin/mycompiler/test/javaConcepts/inheritance/TestInheritanceAcrossLevel.jav

@@ -0,0 +1,56 @@
+/*
+			A
+	B				C
+D		E
+
+*/
+
+class A {
+	fooA() {}
+}
+
+class B extends A {
+	fooB() {}
+}
+
+class C extends A {
+	fooC(){}
+}
+
+class D extends B {
+	fooD() {}
+}
+
+class E extends B {
+	fooE() {}
+}
+
+
+
+public class TestInheritanceAcrossLevel {
+
+	public m1(x) {
+		x.fooA();
+		return x;
+	}
+	
+	public m2(x) {
+		x.fooB();
+		/*return x;*/
+	}
+	
+	public m3(x) {
+		x.fooC();
+		/*return x;*/
+	}
+	
+	public m4(x) {
+		x.fooD();
+		/*return x;*/
+	}
+	
+	public m5(B x) {
+		x.fooA();
+		return x;
+	}
+}

bin/mycompiler/test/javaConcepts/inheritance/TestInheritanceCircle.jav

@@ -0,0 +1,41 @@
+/*
+
+		<i>A
+	<i>B	<i>C
+		 D
+*/
+
+interface A{
+	fooA();
+}
+
+interface B extends A{
+	fooB();
+}
+
+interface C extends A{}
+
+class D implements B,C {
+	fooA() {
+	}
+	fooB() {
+	}
+}
+
+public class TestInheritanceCircle{
+
+	public m1(x) {
+		x.fooA();
+		/*return x;*/
+	}
+	
+	public m2(x) {
+		x.fooB();
+		/*return x;*/
+	}
+	public m3(D x) {
+		x.fooA();
+		return x;
+	}
+
+}

bin/mycompiler/test/javaConcepts/inheritance/TestInheritanceConstructor.jav

@@ -0,0 +1,27 @@
+class A {
+	public Integer memberInteger;
+	
+	public A(i) {
+		member=i;
+	}
+
+}
+
+class B extends A {
+	public String memberString;
+	public B(i,s) {
+		super(i);
+		memberString=s;	
+	}
+}
+
+public class TestInheritanceConstructor {
+	
+	public static main() {
+		x;
+		x=new B(3,"abc");
+		y;
+		y=x.memberInteger;
+	}
+
+}

bin/mycompiler/test/javaConcepts/inheritance/TestInheritanceMultiple.jav

@@ -0,0 +1,22 @@
+interface A{
+}
+interface B{}
+
+class Tester implements A,B{
+	m(){
+	}
+}
+
+public class TestInheritanceMultiple{	
+
+	/*should return either of Type Intf1, Intf2, or Tester*/
+	public m1(x){
+		x.m();
+		return(x);
+	}
+	
+	public m2(Tester x){
+		x.m();
+		return x;
+	}
+}

bin/mycompiler/test/javaConcepts/inheritance/TestInheritanceMultipleClasses.jav

@@ -0,0 +1,8 @@
+
+class A {}
+
+class B {}
+
+public class TestInheritanceMultipleClasses extends A, B {
+
+}

bin/mycompiler/test/javaConcepts/inheritance/TestInheritanceOverriding.jav

@@ -0,0 +1,27 @@
+class A{
+	public m() {
+		return new A();
+	}
+}
+
+class B extends A{
+
+	public m() {
+		return new B();
+	}
+	public m(java.lang.Integer a) {
+		return a;
+	}
+}
+
+public class TestInheritanceOverriding {
+	
+	public main1(x,A y) {
+		y = new B();
+		x = y.m();
+	}
+	/*public main2(x) {
+		y;
+		y=x.m(2);
+	}*/
+}

bin/mycompiler/test/javaConcepts/inheritance/TestInheritanceTwoHierarchies.jav

@@ -0,0 +1,37 @@
+
+/*
+
+			A			<i>I
+	B				C			D
+E						F
+
+*/
+interface I{
+	void fooA();
+}
+class A{
+	void fooA() {}
+}
+class B extends A{}
+
+class C extends A implements I{}
+
+class D implements I{
+	fooD() {}
+}
+class E extends B {}
+
+class F extends C{}
+
+public class TestInheritanceTwoHierarchies {
+
+	public m1(x) {
+		x.fooA();
+		return x;
+	}
+	
+	public m2(x) {
+		x.fooD();
+		return x;
+	}
+}

bin/mycompiler/test/javaConcepts/inheritance/TestSimpleInheritance.jav

@@ -0,0 +1,13 @@
+
+class A {
+
+	public m1() {
+	}
+}
+
+public class TestSimpleInheritance extends A {
+
+	public m(x) {
+		x.m1();
+	}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingDifferentNumberOfParameters.jav

@@ -0,0 +1,6 @@
+class OverloadingDifferentNumberOfParameters{
+	void foo(){}
+	void foo(Integer a){}
+	void foo(Integer a, Double b){}
+	void foo(Integer a, Double b, Long c){}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingDifferentNumberOfParametersAndDifferentTypes.jav

@@ -0,0 +1,9 @@
+class OverloadingDifferentNumberOfParametersAndDifferentTypes{
+	void foo(){}
+	void foo(Integer a){}
+	void foo(Integer a, Double b){}
+	void foo(Integer a, Double b, Long c){}
+	void foo(String a){}
+	void foo(String a, Integer b){}
+	void foo(String a, Integer b, Long c){}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingGenericNotSameHierarchy.jav

@@ -0,0 +1,13 @@
+/*
+Diese Klasse ueberlaed eine Methoden bei total Typverschiedenen generischen parametern (nicht gleiche Vererbungshierarchie
+*/
+class OverloadingGenericNotSameHierarchy{
+	
+	void foo(){}
+	<T extends Number> void foo(T n){}
+	<T extends java.util.Vector> void foo(T v){}
+	
+/*
+	<T extends Vector> void foo(T n){}
+	*/
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingGenericSameHierarchy.jav

@@ -0,0 +1,8 @@
+/*
+Diese Klasse ueberlaedt eine Methoden bei verschiedenen generischen Typen von Parametern welche in der gleichen Vererbungshierarchie liegen*/
+
+class OverloadingGenericSameHierarchy {
+	<T extends Object> void foo(T o){}
+	<T extends Number> void foo(T n){}
+	<T extends Integer> void foo(T i){}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingGenericTypeInferenceNotSameHierarchy.jav

@@ -0,0 +1,19 @@
+/*
+Diese Klasse ueberlaedt eine Methode durch Typinferenz erkannte generische typverschiedenen Tarametern (nicht gleiche Vererbungshierarchie)
+*/
+
+import java.util.Vector;
+
+class A<T> {
+
+}
+
+class OverloadingGenericTypeInferenceNotSameHierarchy<T>{
+	foo(){}
+	foo(i){
+		i = new A<Double>();
+	}
+	foo(s){
+		s = new Vector<Integer>();
+	}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingGenericTypeInferenceSameHierarchy.jav

@@ -0,0 +1,20 @@
+/*
+Diese Klasse ueberlaedt eine Methoden durch typeinferenz erkannte generische Typverschiedenen parametern welche in der selben Typhierarchie sind*/
+class B<T>{
+}
+class C<T> extends B<T>{
+}
+class D<T> extends C<T>{
+}
+class OverloadingGenericTypeInferenceSameHierarchy{
+	foo(i){
+		i = new B<Integer>();
+	}
+	foo(n){
+		n = new C<Integer>();
+	}
+	
+	foo(o){
+		o = new D<Integer>();
+	}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingNotSameHierarchy.jav

@@ -0,0 +1,8 @@
+/*
+Diese Klasse ueberlaed eine Methoden bei total Typverschiedenen parametern (nicht gleiche Vererbungshierarchie
+*/
+class OverloadingNotSameHierarchy{
+	void foo(){}
+	void foo(String s){}
+	void foo(Integer i){}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingSameHierarchy.jav

@@ -0,0 +1,7 @@
+/*
+Diese Klasse ueberlaedt eine Methoden bei verschiedenen Typen von Parametern welche in der gleichen Vererbungshierarchie liegen*/
+class OverloadingSameHierarchy{
+	void foo(java.lang.Number n){}
+	void foo(java.lang.Integer i){}
+	void foo(java.lang.Object o){}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingSameSignature.jav

@@ -0,0 +1,6 @@
+class OverloadingSameSignature{
+	void foo(){
+	}
+	void foo(){
+	}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingSameSignatureDifferentReturnTypes.jav

@@ -0,0 +1,7 @@
+class OverloadingSameSignatureDifferentReturnTypes{
+	void foo(){
+	}
+	String foo(){
+		return "abcd";
+	}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingSameSignatureGenerics.jav

@@ -0,0 +1,8 @@
+class OverloadingSameSignatureGenerics{
+	<T> T foo(T a){
+		return a;
+	}
+	<T> void foo(T a){
+	}
+		
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingTypeInferenceNotSameHierarchy.jav

@@ -0,0 +1,12 @@
+/*
+Diese Klasse ueberlaed eine Methoden durch typeinferenz erkannte Typverschiedenen parametern (nicht gleiche Vererbungshierarchie
+*/
+class OverloadingTypeInferenceNotSameHierarchy{
+	foo(){}
+	foo(i){
+		i = new java.lang.Integer();
+	}
+	foo(s){
+		s = "String";
+	}
+}

bin/mycompiler/test/javaConcepts/overloading/OverloadingTypeInferenceSameHierarchy.jav

@@ -0,0 +1,16 @@
+/*
+Diese Klasse ueberlaed eine Methoden durch typeinferenz erkannte Typverschiedenen parametern welche in der selben Typhierarchie sind*/
+class OverloadingTypeInferenceSameHierarchy{
+	/*i = Integer*/
+		foo(i){
+		i = new java.lang.Integer();
+	}
+	/*n = Number*/
+	foo(n){
+		n = new java.lang.Number();
+	}
+	/*o = Object*/
+	foo(o){
+		o = new java.lang.Object();
+	}
+}

bin/mycompiler/test/javaConcepts/staticAccess/TestNonStaticAccess.jav

@@ -0,0 +1,19 @@
+public class Access{
+
+	public String nonStaticMember="abc";
+	
+	public nonStaticMethod() {
+		return "def";
+	}
+
+}
+
+class TestNonStaticAccess {
+
+	public method1(a,b) {
+		x;
+		x = new Access();
+		a=x.nonStaticMember;
+		b=x.nonStaticMethod();
+	}
+}

bin/mycompiler/test/javaConcepts/staticAccess/TestStaticAccess.jav

@@ -0,0 +1,18 @@
+public class Access{
+	
+	public static String staticMember="def";
+	
+	public static staticMethod() {
+		return "abc";
+	}
+
+}
+
+class TestStaticAccess {
+
+	public method1(a,b) {
+		x;
+		a=x.staticMember;
+		b=x.staticMethod();
+	}
+}

bin/mycompiler/test/javaConcepts/staticAccess/TestStaticAccessError.jav

@@ -0,0 +1,17 @@
+public class Access{
+	public String nonStaticMember="abc";
+	
+	public nonStaticMethod() {
+		return "def";
+	}
+
+}
+
+class TestStaticAccessError {
+
+	public methodError1(a,b) {
+		x;
+		a=x.nonStaticMember;
+		b=x.nonStaticMethod();
+	}	
+}

bin/mycompiler/test/lambda/BasicAssumptions.jav

@@ -0,0 +1,10 @@
+class BasicAssumptionsTest{
+
+varString;
+var = 2;
+
+void methode(){
+	var = 1;
+	varString = varString.toString();
+}
+}

bin/mycompiler/test/lambda/ConstructorTestFile1.jav

@@ -0,0 +1,8 @@
+class ConstructorTest1{
+
+ConstructorTest1(){
+var;
+var = 1;
+}
+
+}

bin/mycompiler/test/lambda/ConstructorTestFile2.jav

@@ -0,0 +1,7 @@
+class ConstructorTest2{
+var;
+	void method(){
+		var = new ConstructorTest1();
+	}
+
+}

bin/mycompiler/test/lambda/GenericVarTest.jav

@@ -0,0 +1,7 @@
+class GenericVarTest{
+	test;
+	method(){
+		test = test;
+		return 1;
+	}
+}

bin/mycompiler/test/lambda/LambdaTest1.jav

@@ -0,0 +1,7 @@
+class LambdaTest1{
+        var = "test";
+
+        method(String toAppend){
+                return (String text) -> { return text;};
+        }
+}

bin/mycompiler/test/lambda/OverloadingTest.jav

@@ -0,0 +1,21 @@
+class OverloadingTest{
+
+	var;
+
+	public Object clone(){
+		return this;
+	}
+
+	public testMethode(){
+		return var.clone();
+	}
+
+}
+
+class OverloadingTest2{
+
+	public Object clone(){
+		return this;
+	}
+
+}

bin/mycompiler/test/lambda/TestAssign.jav

@@ -0,0 +1,3 @@
+class Assign{
+stringVar = "String";
+}

bin/mycompiler/test/lambda/TestFunN.jav

@@ -0,0 +1,2 @@
+class Matrix extends Vector<Vector<Integer>> {
+op = (m) -> (f) -> f.apply(this, m); }

bin/mycompiler/test/lambda/TestIfStmt.jav

@@ -0,0 +1,13 @@
+class TestIfStmt {
+
+methode(){
+	var;
+	if(true){
+	var=this;
+	}else{
+	var=this;
+	}
+	return 1;
+}
+
+}

bin/mycompiler/test/lambda/TestLambda.jav

@@ -0,0 +1,3 @@
+class TestLambda{
+op = (test) ->  test = "string";
+}

bin/mycompiler/test/lambda/TestMethodCall.jav

@@ -0,0 +1,17 @@
+class TestMethodCall {
+
+var;
+
+getSomething(){
+	return this;
+}
+
+getSomethingMore(){
+	return getSomething();
+}
+
+void setVar(){
+	var = getSomethingMore();
+}
+
+}

bin/mycompiler/test/lambda/TestWhile.jav

@@ -0,0 +1,10 @@
+class WhileTest{
+
+	public method(){
+	var;
+	while(true){
+		var = "String";
+	}
+	}
+
+}

bin/mycompiler/test/lambda/ThisTest.jav

@@ -0,0 +1,5 @@
+class ThisTest{
+
+thisVar = this;
+
+}

bin/mycompiler/test/lambda/parseMultipleFilesFile1.jav

@@ -0,0 +1,10 @@
+class Klasse2 {
+
+var1;
+
+testMethode(){
+	var1 = new Klasse1();
+	return var1.getVar1();
+}
+
+}

bin/mycompiler/test/lambda/parseMultipleFilesFile2.jav

@@ -0,0 +1,7 @@
+class Klasse1 {
+	var1;
+	
+	int getVar1(){
+		return var1;
+	}
+}

bin/mycompiler/test/notUsedAnymore/TestAbstractInferenceTest.jav

@@ -0,0 +1,20 @@
+
+class TestAbstractInferenceTest<A> {
+
+	public foo(a, b) {
+		c;
+		d;
+		d = a+ b;
+		{
+		i;
+		i=5;
+		}
+		{
+		i;
+		i="abc";
+		}
+		c = new TestAbstractInferenceTest<String>();
+		return a+b;
+	}
+	
+}

bin/mycompiler/test/notUsedAnymore/TestAbstractInferenceTest2.jav

@@ -0,0 +1,21 @@
+
+public class TestAbstractInferenceTest2 {
+	
+	method(Integer a, String s) {
+	}
+}
+
+class TestAbstractInferenceTest3 extends TestAbstractInferenceTest2 {
+/*
+	method(Integer a) {
+		c;
+	}*/
+	method2(String s) {
+		c;
+		c = new TestAbstractInferenceTest2();
+		c.method(2,"abc");	
+		method(3,"abc");
+	}
+	
+
+}

bin/mycompiler/test/notUsedAnymore/TestClassMemberWithoutType.jav

@@ -0,0 +1,5 @@
+
+public class TestClassMemberWithoutType {
+
+	member;
+}

bin/mycompiler/test/notUsedAnymore/TestConstantsWithoutType.jav

@@ -0,0 +1,6 @@
+public class TestConstantsWithoutType {
+	public final static B = true;
+	public final static I = 1;
+	public final static C = 'A';
+	public final static S = "Hello World!";
+}

bin/mycompiler/test/notUsedAnymore/TestGenerics.jav

@@ -0,0 +1,8 @@
+
+
+public class TestGenerics {
+
+	<T extends Vector<Integer>> void foo(T n) {}
+	<T extends Number> void foo(T i) {}
+
+}

bin/mycompiler/test/notUsedAnymore/TestInheritanceCheckValidImplementationFromInterface.jav

@@ -0,0 +1,7 @@
+interface A{
+	public m();
+}
+class TestInheritanceCheckValidImplementationFromInterface implements A{
+
+	public void m(){}
+}

bin/mycompiler/test/notUsedAnymore/TestInheritanceCheckValidImplementationFromInterfaceNegative.jav

@@ -0,0 +1,7 @@
+interface A{
+	public m();
+}
+class TestInheritanceCheckValidImplementationFromInterfaceNegative implements A{
+
+	public void m1(){}
+}

bin/mycompiler/test/notUsedAnymore/TestInheritanceCheckValidImplementationFromInterfaceNegative2.jav

@@ -0,0 +1,14 @@
+interface TestInheritanceCheckValidImplementationFromInterfaceNegative2{
+	public m();
+}
+class A implements TestInheritanceCheckValidImplementationFromInterfaceNegative2{
+
+	public void m(){}
+}
+
+class B implements TestInheritanceCheckValidImplementationFromInterfaceNegative2 {
+
+	public m() {
+		return 1;
+	}
+}

bin/mycompiler/test/notUsedAnymore/TestMethodReturnType.jav

@@ -0,0 +1,21 @@
+
+public class TestMethodReturnType {
+
+/*	methodReturnType1(a) {
+		return a;
+	}
+	*/
+	methodReturnType2(a,b) {
+		return a+b;		
+	}
+	
+	methodReturnType3(String a) {
+		return a;
+	}
+	
+	Integer methodReturnType4(a) {
+		return a;
+	}
+	
+
+}

bin/mycompiler/test/notUsedAnymore/TestMethodReturnTypeGeneric.jav

@@ -0,0 +1,15 @@
+
+public class TestMethodReturnTypeGeneric<A> {
+
+	testMethodReturnTypeGeneric() {
+		return new TestMethodReturnTypeGeneric<Double>();
+	}
+	
+	testMethodReturnTypeGeneric2(T<?extends Number> a) {
+		return a;
+	}
+	
+	
+	
+
+}

bin/mycompiler/test/notUsedAnymore/TestMethodReturnTypeNegative.jav

@@ -0,0 +1,8 @@
+
+public class TestMethodReturnTypeNegative {
+	
+	/*returned String, but must be Integer*/
+	Integer m1(String a) {
+		return a;
+	}
+}

bin/mycompiler/test/notUsedAnymore/TestMethodReturnTypeNegative2.jav

@@ -0,0 +1,11 @@
+
+public class TestMethodReturnTypeNegative2 {
+	
+	/*not always boolean returned*/
+	public m1() {
+		a;
+		if (a) {
+			return a;
+		}
+	}
+}

bin/mycompiler/test/operators/TestOperatorArithmetic.jav

@@ -0,0 +1,40 @@
+public class TestOperatorArithmetic {
+
+	public m1(i,j) {
+		return i+j;
+	}
+	
+	public m2(i,java.lang.Double j) {	
+		return i-j;
+	}
+	
+	public m3(java.lang.Integer i,j) {	
+		return i*j;
+	}
+	
+	public java.lang.Double m4(i,j) {	
+		return i/j;
+	}
+	
+	public m5(i,j) {	
+		return i%j;
+	}
+	
+	public m6(i) {
+		return -i;
+	}
+	
+	public m7 (i,j) {
+		i+=j;
+		return i;
+	}
+	
+	public m8(i, java.lang.Float j) {	
+		return i/j;
+	}
+	
+	/*public java.lang.Long m9(i, j) {
+		return i+j;
+	}*/
+	
+}

bin/mycompiler/test/operators/TestOperatorBitwise.jav

@@ -0,0 +1,45 @@
+public class TestOperatorBitwise {
+
+	public m1(a,b) {
+		return a & b;
+	}
+	
+	public m2(a,b) {
+		return a ^ b;
+	}
+	
+	public m3(a,b) {
+		return a | b;
+	}
+	
+	public m4(Integer a, b) {
+		return a & b;
+	}
+	
+	public m5(a, Long b) {
+		return a & b;
+	}
+	
+	public Integer m6(a,b) {
+		return a & b;
+	}
+	
+	/* bit-shift not accepted by parser
+
+	public m7(a,b) {
+		return x << y;
+	}
+	
+	public m8(a,b) {
+		return x >> y;
+	}
+	
+	public m9(a,b) {
+		return x >>> y;
+	}
+	
+	public m10(a) {
+		return ~a;
+	}
+	*/
+}

bin/mycompiler/test/operators/TestOperatorBool.jav

@@ -0,0 +1,19 @@
+public class TestOperatorBool {
+
+	public m1(a,b) {
+		return a && b;	
+	}
+	
+	public m2(a,b) {
+		return a || b;
+	}
+	
+	public m3(a) {
+		return !a;
+	}
+	
+	public m4( a, b) {
+		return a==b;
+	}
+
+}

bin/mycompiler/test/operators/TestOperatorComparison.jav

@@ -0,0 +1,22 @@
+public class TestOperatorComparison {
+
+/*	public m1(a,b) {
+		return a < b;
+	}
+	
+	public m2(a, b) {
+		return a >= b;
+	}
+	*/
+	public m3(a, b) {
+		return a==b;
+	}
+	
+	public java.lang.Boolean m4(a,b) {
+		return a!=b;
+	}
+
+	public m5(Integer a, b) {
+		return a<b;
+	}
+}

bin/mycompiler/test/operators/TestOperatorIncrement.jav

@@ -0,0 +1,11 @@
+
+public class TestOperatorIncrement {
+
+	public void m(i,j,k,l) {
+		i++;
+		j--;
+		++k;
+		--l;
+	}
+
+}

bin/mycompiler/test/operators/TestOperatorObjects.jav

@@ -0,0 +1,18 @@
+class A {
+	
+	public java.lang.Integer m(a) {
+		return a;
+	}
+
+}
+
+public class TestOperatorObjects {
+	
+	public static void main() {
+		b;
+		b=new A();
+		c;
+		c=b.m(3);
+	}
+
+}

bin/mycompiler/test/operators/TestOperatorString.jav

@@ -0,0 +1,11 @@
+public class TestOperatorString {
+
+	public m() {
+		a;
+		b;
+		a="abc";
+		b="def";
+		return a+b;
+	}
+
+}

bin/mycompiler/test/primitiveTypes/BooleanTest.jav

@@ -0,0 +1,5 @@
+class BooleanTest{
+	void booleanTest(b){
+		b = true;
+	}
+}

bin/mycompiler/test/primitiveTypes/ByteTest.jav

@@ -0,0 +1,6 @@
+class ByteTest{
+	void byteTest(b){
+		byte myByte = -1;
+		b = myByte;
+	}
+}

bin/mycompiler/test/primitiveTypes/CharTest.jav

@@ -0,0 +1,5 @@
+class CharTest{
+	void character(c){
+		c = 'c';
+	}
+}

bin/mycompiler/test/primitiveTypes/DoubleTest.jav

@@ -0,0 +1,5 @@
+class DoubleTest{
+	void doublePrecision(d){
+		d = 1.0;
+	}
+}

bin/mycompiler/test/primitiveTypes/FloatTest.jav

@@ -0,0 +1,5 @@
+class FloatTest {
+	void floatingPoint(f) {
+		f = 5f;
+	}
+}

bin/mycompiler/test/primitiveTypes/IntegerTest.jav

@@ -0,0 +1,5 @@
+class IntegerTest{
+	void integer(i){
+		i = 1; /* koennte vielleicht auch short/byte/char sein .. */
+	}
+}