diff --git a/output/Operators.class b/output/Operators.class
new file mode 100644
index 0000000..bf364f7
Binary files /dev/null and b/output/Operators.class differ
diff --git a/pom.xml b/pom.xml
index b3ad7f7..5ef0e2f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -75,6 +75,12 @@
RELEASE
test
+
+ junit
+ junit
+ 4.13.1
+ test
+
commons-cli
diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java
index c4740b4..aec8ef4 100644
--- a/src/main/java/de/maishai/typedast/typedclass/TypedClass.java
+++ b/src/main/java/de/maishai/typedast/typedclass/TypedClass.java
@@ -223,4 +223,23 @@ public class TypedClass implements TypedNode {
return cw.toByteArray();
}
+
+ public ClassWriter codeGenClassWriter() {
+ ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
+ ClassContext ctx = new ClassContext(className, cw);
+ cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, "java/lang/Object", null);
+ for (TypedDeclaration declaration : typedDeclarations) {
+ declaration.codeGen(cw);
+ }
+
+ for (TypedConstructor constructor : typedConstructors) {
+ constructor.codeGen(ctx);
+ }
+
+ for (TypedMethod m : typedMethods) {
+ m.codeGen(ctx);
+ }
+
+ return cw;
+ }
}
diff --git a/src/test/java/CodegeneratorTests.java b/src/test/java/CodegeneratorTests.java
index be9ea37..d1f9b50 100644
--- a/src/test/java/CodegeneratorTests.java
+++ b/src/test/java/CodegeneratorTests.java
@@ -1,5 +1,12 @@
-import e2e.BytecodeTestUtil;
+import de.maishai.Compiler;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import testResources.CodeGen.BytecodeTestUtil;
+import testResources.CodeGen.Features.*;
+
+import java.util.List;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -12,14 +19,32 @@ public class CodegeneratorTests {
// assertEquals(AbstractSyntax_PublicClass.get(), resultBytecode);
// }
- @Test
- public void testMethodCall() {
- assertDoesNotThrow(() -> {
- BytecodeTestUtil testUtility = new BytecodeTestUtil("src/test/testFiles/JavaTestfilesFeatures/MethodCall.java", "MethodCall");
+// @Test
+// public void testMethodCall() {
+// assertDoesNotThrow(() -> {
+// BytecodeTestUtil testUtility = new BytecodeTestUtil("src/test/testFiles/ASTandTypedASTFeatures/MethodCall.java", "MethodCall");
+//
+// assertEquals(0, testUtility.invokeMethod("method", null));
+// assertEquals(1, testUtility.invokeMethod("method1", new Class>[]{int.class}, 1));
+// assertEquals(3, testUtility.invokeMethod("method2", new Class>[]{int.class, int.class}, 1, 2));
+// });
+// }
- assertEquals(0, testUtility.invokeMethod("method", null));
- assertEquals(1, testUtility.invokeMethod("method1", new Class>[]{int.class}, 1));
- assertEquals(3, testUtility.invokeMethod("method2", new Class>[]{int.class, int.class}, 1, 2));
- });
- }
+// @Test
+// public void testBreak() {
+// ByteCode_Break ByteCode_Break = new ByteCode_Break();
+// Assertions.assertTrue(ByteCode_Break.allTestsSuccessful());
+// }
+
+// @Test
+// public void testClass() {
+// ByteCode_Class ByteCode_Class = new ByteCode_Class();
+// Assertions.assertTrue(ByteCode_Class.allTestsSuccessful());
+// }
+
+// @Test
+// public void testClassObjects() {
+// ByteCode_ClassObjects ByteCode_ClassObjects = new ByteCode_ClassObjects();
+// Assertions.assertTrue(ByteCode_ClassObjects.allTestsSuccessful());
+// }
}
diff --git a/src/test/java/ScannerParserTests.java b/src/test/java/ScannerParserTests.java
index e5524ed..a77b2ca 100644
--- a/src/test/java/ScannerParserTests.java
+++ b/src/test/java/ScannerParserTests.java
@@ -217,7 +217,4 @@ public class ScannerParserTests {
Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/While.java"));
assertEquals(AST_While.get(), resultAst);
}
-
- //TODO: Anschauen: Warum sind die FieldVarAccess von Methodenaufrufen manchmal fields und manchmal ned (z.B. bei ComplexCalls)
- // Warum geht MultipleClasses nicht?
}
diff --git a/src/test/java/testResources/CodeGen/BytecodeTestUtil.java b/src/test/java/testResources/CodeGen/BytecodeTestUtil.java
new file mode 100644
index 0000000..498d687
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/BytecodeTestUtil.java
@@ -0,0 +1,177 @@
+package testResources.CodeGen;
+
+import de.maishai.Compiler;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+public class BytecodeTestUtil {
+
+ private Class> clazz;
+ private Object instance;
+
+ public BytecodeTestUtil(List sourceFilePaths, String className) throws Exception {
+ byte[] resultBytecode = Compiler.generateByteCodeArrayFromFiles(sourceFilePaths).get(0);
+
+ ClassLoader classLoader = new ClassLoader() {
+ @Override
+ protected Class> findClass(String name) {
+ return defineClass(name, resultBytecode, 0, resultBytecode.length);
+ }
+ };
+ clazz = classLoader.loadClass(className);
+ this.instance = clazz.getDeclaredConstructor().newInstance();
+ }
+
+
+
+ public int getConstructorCount() {
+ return clazz.getDeclaredConstructors().length;
+ }
+
+ public List getConstructorNames() {
+ List constructorNames = new ArrayList<>();
+ for (Constructor> constructor : clazz.getDeclaredConstructors()) {
+ constructorNames.add(constructor.getName());
+ }
+ return constructorNames;
+ }
+
+ public int getConstructorParameterCount(int index) {
+ return clazz.getDeclaredConstructors()[index].getParameterCount();
+ }
+
+ public List getConstructorParameterTypes(int index) {
+ List parameterTypes = new ArrayList<>();
+ for (Class> parameterType : clazz.getDeclaredConstructors()[index].getParameterTypes()) {
+ parameterTypes.add(parameterType.getSimpleName());
+ }
+ return parameterTypes;
+ }
+
+ public Object invokeConstructor(Class>[] parameterTypes, Object... args) throws Exception {
+ return clazz.getDeclaredConstructor(parameterTypes).newInstance(args);
+ }
+
+
+
+ public int getMethodCount() {
+ return clazz.getDeclaredMethods().length;
+ }
+
+ public List getMethodNames() {
+ List methodNames = new ArrayList<>();
+ for (Method method : clazz.getDeclaredMethods()) {
+ methodNames.add(method.getName());
+ }
+ return methodNames;
+ }
+
+ public String getMethodReturnType(String methodName, Class>... params) throws Exception {
+ return clazz.getMethod(methodName, params).getReturnType().getSimpleName();
+ }
+
+ public int getMethodParameterCount(String methodName, Class>... params) throws Exception {
+ return clazz.getMethod(methodName, params).getParameterCount();
+ }
+
+ public List getMethodParameterTypes(String methodName, Class>... params) throws Exception {
+ List parameterTypes = new ArrayList<>();
+ for (Class> parameterType : clazz.getMethod(methodName, params).getParameterTypes()) {
+ parameterTypes.add(parameterType.getSimpleName());
+ }
+ return parameterTypes;
+ }
+
+ public Object invokeMethod(String methodName, Class>[] parameterTypes, Object... args) throws Exception {
+ try {
+ Method method = clazz.getMethod(methodName, parameterTypes);
+ return method.invoke(instance, args);
+ } catch (InvocationTargetException e) {
+ e.getTargetException().printStackTrace();
+ throw new RuntimeException(e.getTargetException());
+ }
+ }
+
+
+
+ public int getFieldCount() {
+ return clazz.getDeclaredFields().length;
+ }
+
+ public List getFieldNames() {
+ List fieldNames = new ArrayList<>();
+ for (Field field : clazz.getDeclaredFields()) {
+ fieldNames.add(field.getName());
+ }
+ return fieldNames;
+ }
+
+ public List getFieldTypes() {
+ List fieldTypes = new ArrayList<>();
+ for (Field field : clazz.getDeclaredFields()) {
+ fieldTypes.add(field.getType().getSimpleName());
+ }
+ return fieldTypes;
+ }
+
+ public Object getFieldValue(String fieldName) throws Exception {
+ return clazz.getField(fieldName).get(instance);
+ }
+
+ public void setFieldValue(String fieldName, Object value) throws Exception {
+ clazz.getField(fieldName).set(instance, value);
+ }
+
+
+
+ public Object getFieldValueAfterMethodInvocation(String fieldName, String methodName, Class>[] parameterTypes, Object... args) throws Exception {
+ Object instance = clazz.getDeclaredConstructor().newInstance();
+
+ // Methode aufrufen
+ Method method = clazz.getMethod(methodName, parameterTypes);
+ method.invoke(instance, args);
+
+ // Wert des Feldes nach dem Methodenaufruf abrufen
+ return clazz.getField(fieldName).get(instance);
+ }
+
+
+ public Object getFieldValueOfObject(Object obj, String fieldName) {
+ try {
+ Field field = obj.getClass().getField(fieldName);
+ return field.get(obj);
+ } catch (NoSuchFieldException e) {
+ System.out.println("Das Feld " + fieldName + " existiert nicht.");
+ return null;
+ } catch (IllegalAccessException e) {
+ System.out.println("Zugriff auf das Feld " + fieldName + " ist nicht erlaubt.");
+ return null;
+ }
+ }
+
+
+
+ private Class>[] toClassArray(Object... args) {
+ return java.util.Arrays.stream(args)
+ .map(Object::getClass)
+ .toArray(Class>[]::new);
+ }
+
+
+
+ public Object getValueOfFieldInObject(Object instance, String fieldName) {
+ try {
+ Field field = instance.getClass().getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(instance);
+ } catch (NoSuchFieldException | IllegalAccessException e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Break.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Break.java
new file mode 100644
index 0000000..9b82327
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Break.java
@@ -0,0 +1,144 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import testResources.CodeGen.BytecodeTestUtil;
+
+import java.util.List;
+
+public class ByteCode_Break {
+
+ private BytecodeTestUtil util;
+
+ @BeforeEach
+ public void setUp() {
+ try {
+ util = new BytecodeTestUtil(List.of("src/test/testFiles/CodeGenFeatures/Break.java"), "Break");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+
+ @Test
+ public void testConstructorCount() {
+ Assertions.assertEquals(1, util.getConstructorCount());
+ // default constructor
+ }
+
+ @Test
+ public void testDefaultConstructor() {
+ Assertions.assertEquals("Break", util.getConstructorNames().get(0));
+ Assertions.assertEquals(0, util.getConstructorParameterCount(0));
+ try {
+ Assertions.assertEquals("Break", util.invokeConstructor(new Class>[]{}, null).getClass().getName());
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+
+
+ @Test
+ public void testMethodCount() {
+ Assertions.assertEquals(1, util.getMethodCount());
+ }
+
+ @Test
+ public void testMethodNames() {
+ Assertions.assertEquals("breakMethod", util.getMethodNames().get(0));
+ }
+
+ @Test
+ public void testMethodReturnType() {
+ try {
+ Assertions.assertEquals("void", util.getMethodReturnType("breakMethod", new Class>[]{boolean.class}));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testMethodParameters() {
+ try {
+ Assertions.assertEquals(1, util.getMethodParameterCount("breakMethod", new Class>[]{}));
+ Assertions.assertEquals("boolean", util.getMethodParameterTypes("breakMethod", new Class>[]{}).get(0));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testFieldCount() {
+ Assertions.assertEquals(2, util.getFieldCount());
+ }
+
+ @Test
+ public void testFieldNames() {
+ Assertions.assertEquals("whileRepetition", util.getFieldNames().get(0));
+ Assertions.assertEquals("forRepetition", util.getFieldNames().get(1));
+ }
+
+ @Test
+ public void testFieldTypes() {
+ Assertions.assertEquals("int", util.getFieldTypes().get(0));
+ Assertions.assertEquals("int", util.getFieldTypes().get(1));
+ }
+
+ @Test
+ public void testFieldValues() {
+ try {
+ Assertions.assertEquals(0, util.getFieldValue("whileRepetition"));
+ Assertions.assertEquals(0, util.getFieldValue("forRepetition"));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+
+
+ @Test
+ public void testInvokeDefaultConstructor() {
+ try {
+ Object instance = util.invokeConstructor(new Class>[]{}, null);
+ Assertions.assertEquals(instance.getClass().getName(), "Break");
+ Assertions.assertEquals(0, util.getFieldValueOfObject(instance, "whileRepetition"));
+ Assertions.assertEquals(0, util.getFieldValueOfObject(instance, "forRepetition"));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testInvokeBreakMethodWithFalse() {
+ try {
+ int fieldWhileRepetition = (int) util.getFieldValue("whileRepetition");
+ int fieldForRepetition = (int) util.getFieldValue("forRepetition");
+ util.invokeMethod("breakMethod", new Class>[]{boolean.class}, new Object[]{false});
+ Assertions.assertNotEquals(fieldWhileRepetition, util.getFieldValue("whileRepetition"));
+ Assertions.assertEquals(10, util.getFieldValue("whileRepetition"));
+ Assertions.assertNotEquals(fieldForRepetition, util.getFieldValue("forRepetition"));
+ Assertions.assertEquals(10, util.getFieldValue("forRepetition"));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Test
+ public void testInvokeBreakMethodWithTrue() {
+ try {
+ int fieldWhileRepetition = (int) util.getFieldValue("whileRepetition");
+ int fieldForRepetition = (int) util.getFieldValue("forRepetition");
+ util.invokeMethod("breakMethod", new Class>[]{boolean.class}, new Object[]{true});
+ Assertions.assertNotEquals(fieldWhileRepetition, util.getFieldValue("whileRepetition"));
+ Assertions.assertEquals(5, util.getFieldValue("whileRepetition"));
+ Assertions.assertNotEquals(fieldForRepetition, util.getFieldValue("forRepetition"));
+ Assertions.assertEquals(5, util.getFieldValue("forRepetition"));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Class.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Class.java
new file mode 100644
index 0000000..47fc361
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Class.java
@@ -0,0 +1,66 @@
+package testResources.CodeGen.Features;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import testResources.CodeGen.BytecodeTestUtil;
+
+import java.util.List;
+
+public class ByteCode_Class {
+
+ private BytecodeTestUtil util;
+
+ @BeforeEach
+ public void setUp() {
+ try {
+ util = new BytecodeTestUtil(List.of("src/test/testFiles/CodeGenFeatures/Class.java"), "Class");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+ @Test
+ public void testConstructorCount() {
+ Assertions.assertEquals(1, util.getConstructorCount());
+ // default constructor
+ }
+
+ @Test
+ public void testDefaultConstructor() {
+ Assertions.assertEquals("Class", util.getConstructorNames().get(0));
+ Assertions.assertEquals(0, util.getConstructorParameterCount(0));
+ try {
+ Assertions.assertEquals("Class", util.invokeConstructor(new Class>[]{}, null).getClass().getName());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+
+ @Test
+ public void testMethodCount() {
+ Assertions.assertEquals(0, util.getMethodCount());
+ }
+
+
+
+ @Test
+ public void testFieldCount() {
+ Assertions.assertEquals(0, util.getFieldCount());
+ }
+
+
+
+ @Test
+ public void testInvokeDefaultConstructor() {
+ try {
+ Object instance = util.invokeConstructor(new Class>[]{}, null);
+ Assertions.assertEquals(instance.getClass().getName(), "Class");
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_ClassObjects.java b/src/test/java/testResources/CodeGen/Features/ByteCode_ClassObjects.java
new file mode 100644
index 0000000..0085d39
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_ClassObjects.java
@@ -0,0 +1,150 @@
+package testResources.CodeGen.Features;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import testResources.CodeGen.BytecodeTestUtil;
+
+import java.util.List;
+
+public class ByteCode_ClassObjects {
+
+ private BytecodeTestUtil util;
+
+ @BeforeEach
+ public void setUp() {
+ try {
+ util = new BytecodeTestUtil(List.of("src/test/testFiles/CodeGenFeatures/ClassObjects.java"), "ClassObjects");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+
+ @Test
+ public void testConstructorCount() {
+ Assertions.assertEquals(2, util.getConstructorCount());
+ }
+
+ @Test
+ public void testConstructor1() {
+ Assertions.assertEquals("ClassObjects", util.getConstructorNames().get(0));
+ Assertions.assertEquals(0, util.getConstructorParameterCount(0));
+ }
+
+ @Test
+ public void testConstructor2() {
+ Assertions.assertEquals("ClassObjects", util.getConstructorNames().get(1));
+ Assertions.assertEquals(1, util.getConstructorParameterCount(1));
+ }
+
+
+
+ @Test
+ public void testMethodCount() {
+ Assertions.assertEquals(1, util.getMethodCount());
+ }
+
+ @Test
+ public void testMethodNames() {
+ Assertions.assertEquals("objectsMethod", util.getMethodNames().get(0));
+ }
+
+ @Test
+ public void testMethodReturnType() {
+ try {
+ Assertions.assertEquals("void", util.getMethodReturnType("objectsMethod", new Class>[]{}));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testMethodParameters() {
+ try {
+ Assertions.assertEquals(0, util.getMethodParameterCount("objectsMethod", new Class>[]{}));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+
+
+ @Test
+ public void testFieldCount() {
+ Assertions.assertEquals(3, util.getFieldCount());
+ }
+
+ @Test
+ public void testFieldNames() {
+ Assertions.assertEquals("object", util.getFieldNames().get(0));
+ Assertions.assertEquals("objectWithValue", util.getFieldNames().get(1));
+ Assertions.assertEquals("integerValue", util.getFieldNames().get(2));
+ }
+
+ @Test
+ public void testFieldTypes() {
+ Assertions.assertEquals("ClassObjects", util.getFieldTypes().get(0));
+ Assertions.assertEquals("ClassObjects", util.getFieldTypes().get(1));
+ Assertions.assertEquals("int", util.getFieldTypes().get(2));
+ }
+
+ @Test
+ public void testFieldValues() {
+ try {
+ Assertions.assertNull(util.getFieldValue("object"));
+ Assertions.assertNull(util.getFieldValue("objectWithValue"));
+ Assertions.assertEquals(0, util.getFieldValue("integerValue"));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+
+
+ @Test
+ public void testInvokeConstructor1() {
+ try {
+ Object constructor1ReturnValue = util.invokeConstructor(new Class>[]{}, new Object[]{});
+ Assertions.assertEquals(constructor1ReturnValue.getClass().getName(), "ClassObjects");
+ Assertions.assertNull(util.getFieldValueOfObject(constructor1ReturnValue,"object"));
+ Assertions.assertNull(util.getFieldValueOfObject(constructor1ReturnValue, "objectWithValue"));
+ Assertions.assertEquals(0,
+ (int) util.getFieldValueOfObject(constructor1ReturnValue,"integerValue"));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Test
+ public void testInvokeConstructor2() {
+ try {
+ Object constructor2ReturnValue = util.invokeConstructor(new Class>[]{int.class}, new Object[]{2});
+ Assertions.assertEquals(constructor2ReturnValue.getClass().getName(), "ClassObjects");
+ Assertions.assertNull(util.getFieldValueOfObject(constructor2ReturnValue, "object"));
+ Assertions.assertNull(util.getFieldValueOfObject(constructor2ReturnValue, "objectWithValue"));
+ Assertions.assertEquals(2,
+ (int) util.getFieldValueOfObject(constructor2ReturnValue,"integerValue"));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Test
+ public void testInvokeMethod() {
+ try {
+ Object fieldObject = util.getFieldValue("object");
+ Object fieldObjectWithValue = util.getFieldValue("objectWithValue");
+ int fieldIntegerValue = (int) util.getFieldValue("integerValue");
+ util.invokeMethod("objectsMethod", new Class>[]{}, new Object[]{});
+ Assertions.assertNotSame(util.getFieldValue("object"), fieldObject);
+ Assertions.assertEquals(util.getFieldValue("object").getClass().getName(), "ClassObjects");
+ Assertions.assertNotSame(util.getFieldValue("objectWithValue"), fieldObjectWithValue);
+ Assertions.assertEquals(util.getFieldValue("objectWithValue").getClass().getName(), "ClassObjects");
+ Assertions.assertEquals((int) util.getFieldValue("integerValue"), fieldIntegerValue);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Comment.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Comment.java
new file mode 100644
index 0000000..d257d7e
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Comment.java
@@ -0,0 +1,71 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.TypedBlock;
+import de.maishai.typedast.typedclass.TypedClass;
+import de.maishai.typedast.typedclass.TypedConstructor;
+import de.maishai.typedast.typedclass.TypedProgram;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import testResources.CodeGen.BytecodeTestUtil;
+
+import java.util.List;
+
+public class ByteCode_Comment {
+
+ private BytecodeTestUtil util;
+
+ @BeforeEach
+ public void setUp() {
+ try {
+ util = new BytecodeTestUtil(List.of("src/test/testFiles/CodeGenFeatures/Comment.java"), "Comment");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+ @Test
+ public void testConstructorCount() {
+ Assertions.assertEquals(1, util.getConstructorCount());
+ // default constructor
+ }
+
+ @Test
+ public void testDefaultConstructor() {
+ Assertions.assertEquals("Comment", util.getConstructorNames().get(0));
+ Assertions.assertEquals(0, util.getConstructorParameterCount(0));
+ try {
+ Assertions.assertEquals("Comment", util.invokeConstructor(new Class>[]{}, null).getClass().getName());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+
+ @Test
+ public void testMethodCount() {
+ Assertions.assertEquals(0, util.getMethodCount());
+ }
+
+
+
+ @Test
+ public void testFieldCount() {
+ Assertions.assertEquals(0, util.getFieldCount());
+ }
+
+
+
+ @Test
+ public void testInvokeDefaultConstructor() {
+ try {
+ Object instance = util.invokeConstructor(new Class>[]{}, null);
+ Assertions.assertEquals(instance.getClass().getName(), "Comment");
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_CompAssign.java b/src/test/java/testResources/CodeGen/Features/ByteCode_CompAssign.java
new file mode 100644
index 0000000..a03eccc
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_CompAssign.java
@@ -0,0 +1,156 @@
+package testResources.CodeGen.Features;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import testResources.CodeGen.BytecodeTestUtil;
+
+import java.util.List;
+
+public class ByteCode_CompAssign {
+
+ private BytecodeTestUtil util;
+
+ @BeforeEach
+ public void setUp() {
+ try {
+ util = new BytecodeTestUtil(List.of("src/test/testFiles/CodeGenFeatures/CompAssign.java"), "CompAssign");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+
+ @Test
+ public void testConstructorCount() {
+ Assertions.assertEquals(1, util.getConstructorCount());
+ // default constructor
+ }
+
+ @Test
+ public void testDefaultConstructor() {
+ Assertions.assertEquals("CompAssign", util.getConstructorNames().get(0));
+ Assertions.assertEquals(0, util.getConstructorParameterCount(0));
+ try {
+ Assertions.assertEquals("CompAssign", util.invokeConstructor(new Class>[]{}, null).getClass().getName());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+
+ @Test
+ public void testMethodCount() {
+ Assertions.assertEquals(5, util.getMethodCount());
+ }
+
+ @Test
+ public void testMethodNames() {
+ Assertions.assertTrue(util.getMethodNames().contains("increase"));
+ Assertions.assertTrue(util.getMethodNames().contains("decrease"));
+ Assertions.assertTrue(util.getMethodNames().contains("multiply"));
+ Assertions.assertTrue(util.getMethodNames().contains("divide"));
+ Assertions.assertTrue(util.getMethodNames().contains("modulus"));
+ }
+
+ @Test
+ public void testMethodReturnType() {
+ try {
+ Assertions.assertEquals("int", util.getMethodReturnType("increase", new Class>[]{int.class}));
+ Assertions.assertEquals("int", util.getMethodReturnType("decrease", new Class>[]{int.class}));
+ Assertions.assertEquals("int", util.getMethodReturnType("multiply", new Class>[]{int.class}));
+ Assertions.assertEquals("int", util.getMethodReturnType("divide", new Class>[]{int.class}));
+ Assertions.assertEquals("int", util.getMethodReturnType("modulus", new Class>[]{int.class}));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testMethodParameters() {
+ try {
+ Assertions.assertEquals(1, util.getMethodParameterCount("increase", new Class>[]{int.class}));
+ Assertions.assertEquals("int", util.getMethodParameterTypes("increase", new Class>[]{int.class}).get(0));
+ Assertions.assertEquals(1, util.getMethodParameterCount("decrease", new Class>[]{int.class}));
+ Assertions.assertEquals("int", util.getMethodParameterTypes("decrease", new Class>[]{int.class}).get(0));
+ Assertions.assertEquals(1, util.getMethodParameterCount("multiply", new Class>[]{int.class}));
+ Assertions.assertEquals("int", util.getMethodParameterTypes("multiply", new Class>[]{int.class}).get(0));
+ Assertions.assertEquals(1, util.getMethodParameterCount("divide", new Class>[]{int.class}));
+ Assertions.assertEquals("int", util.getMethodParameterTypes("divide", new Class>[]{int.class}).get(0));
+ Assertions.assertEquals(1, util.getMethodParameterCount("modulus", new Class>[]{int.class}));
+ Assertions.assertEquals("int", util.getMethodParameterTypes("modulus", new Class>[]{int.class}).get(0));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+
+ @Test
+ public void testFieldCount() {
+ Assertions.assertEquals(0, util.getFieldCount());
+ }
+
+
+
+ @Test
+ public void testInvokeDefaultConstructor() {
+ try {
+ Object instance = util.invokeConstructor(new Class>[]{}, null);
+ Assertions.assertEquals(instance.getClass().getName(), "CompAssign");
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testInvokeIncrease() {
+ try {
+ Assertions.assertEquals(1, util.invokeMethod("increase", new Class>[]{int.class}, new Object[]{0}));
+ Assertions.assertEquals(6, util.invokeMethod("increase", new Class>[]{int.class}, new Object[]{5}));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testInvokeDecrease() {
+ try {
+ Assertions.assertEquals(0, util.invokeMethod("decrease", new Class>[]{int.class}, new Object[]{1}));
+ Assertions.assertEquals(4, util.invokeMethod("decrease", new Class>[]{int.class}, new Object[]{5}));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testInvokeMultiply() {
+ try {
+ Assertions.assertEquals(0, util.invokeMethod("multiply", new Class>[]{int.class}, new Object[]{0}));
+ Assertions.assertEquals(10, util.invokeMethod("multiply", new Class>[]{int.class}, new Object[]{5}));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testInvokeDivide() {
+ try {
+ Assertions.assertEquals(0, util.invokeMethod("divide", new Class>[]{int.class}, new Object[]{0}));
+ Assertions.assertEquals(2, util.invokeMethod("divide", new Class>[]{int.class}, new Object[]{5}));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testInvokeModulus() {
+ try {
+ Assertions.assertEquals(0, util.invokeMethod("modulus", new Class>[]{int.class}, new Object[]{0}));
+ Assertions.assertEquals(1, util.invokeMethod("modulus", new Class>[]{int.class}, new Object[]{5}));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_ComplexCalls.java b/src/test/java/testResources/CodeGen/Features/ByteCode_ComplexCalls.java
new file mode 100644
index 0000000..b1c9f51
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_ComplexCalls.java
@@ -0,0 +1,178 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import testResources.CodeGen.BytecodeTestUtil;
+
+import java.util.List;
+
+public class ByteCode_ComplexCalls {
+
+ private BytecodeTestUtil util;
+
+ @BeforeEach
+ public void setUp() {
+ try {
+ util = new BytecodeTestUtil(List.of("src/test/testFiles/CodeGenFeatures/ComplexCalls.java"), "ComplexCalls");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+
+ @Test
+ public void testConstructorCount() {
+ Assertions.assertEquals(1, util.getConstructorCount());
+ // default constructor
+ }
+
+ @Test
+ public void testDefaultConstructor() {
+ Assertions.assertEquals("ComplexCalls", util.getConstructorNames().get(0));
+ Assertions.assertEquals(0, util.getConstructorParameterCount(0));
+ try {
+ Assertions.assertEquals("ComplexCalls", util.invokeConstructor(new Class>[]{}, null).getClass().getName());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+
+ @Test
+ public void testMethodCount() {
+ Assertions.assertEquals(3, util.getMethodCount());
+ }
+
+ @Test
+ public void testMethodNames() {
+ Assertions.assertTrue(util.getMethodNames().contains("makeComplexCalls"));
+ Assertions.assertTrue(util.getMethodNames().contains("getClassObject"));
+ Assertions.assertTrue(util.getMethodNames().contains("getA"));
+ }
+
+ @Test
+ public void testMethodReturnType() {
+ try {
+ Assertions.assertEquals("int", util.getMethodReturnType("makeComplexCalls", new Class>[]{}));
+ Assertions.assertEquals("ComplexCalls", util.getMethodReturnType("getClassObject", new Class>[]{}));
+ Assertions.assertEquals("int", util.getMethodReturnType("getA", new Class>[]{int.class}));
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Test
+ public void testMethodParameters() {
+ try {
+ Assertions.assertEquals(0, util.getMethodParameterCount("makeComplexCalls", new Class>[]{}));
+ Assertions.assertEquals(0, util.getMethodParameterCount("getClassObject", new Class>[]{}));
+ Assertions.assertEquals(1, util.getMethodParameterCount("getA", new Class>[]{int.class}));
+ Assertions.assertEquals("int", util.getMethodParameterTypes("getA", new Class>[]{int.class}).get(0));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+
+
+ @Test
+ public void testFieldCount() {
+ Assertions.assertEquals(2, util.getFieldCount());
+ }
+
+ @Test
+ public void testFieldNames() {
+ Assertions.assertTrue(util.getFieldNames().contains("a"));
+ Assertions.assertTrue(util.getFieldNames().contains("classObject"));
+ }
+
+ @Test
+ public void testFieldTypes() {
+ Assertions.assertEquals("int", util.getFieldTypes().get(1));
+ Assertions.assertEquals("ComplexCalls", util.getFieldTypes().get(0));
+ }
+
+ @Test
+ public void testFieldValues() {
+ try {
+ Assertions.assertEquals(0, util.getFieldValue("a"));
+ Assertions.assertNull(util.getFieldValue("classObject"));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+
+
+ @Test
+ public void testInvokeDefaultConstructor() {
+ try {
+ Object instance = util.invokeConstructor(new Class>[]{}, null);
+ Assertions.assertEquals(instance.getClass().getName(), "ComplexCalls");
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testInvokeMethodMakeComplexCalls() {
+ try {
+ Object fieldClassObject = util.getFieldValue("classObject");
+ Assertions.assertNull(fieldClassObject);
+ int fieldA = (int) util.getFieldValue("a");
+ Assertions.assertEquals(0, fieldA);
+ int returnValue = (int) util.invokeMethod("makeComplexCalls", new Class>[]{}, new Object[]{});
+ Assertions.assertEquals(3, returnValue);
+ Assertions.assertNotEquals(fieldClassObject, util.getFieldValue("classObject"));
+ Assertions.assertEquals("ComplexCalls", util.getFieldValue("classObject").getClass().getName());
+ Assertions.assertNotEquals(fieldA, util.getFieldValue("a"));
+ Assertions.assertEquals(1, util.getFieldValue("a"));
+ Object fieldClassObjectContent = util.getFieldValue("classObject");
+ Assertions.assertEquals(2, util.getFieldValueOfObject(fieldClassObjectContent, "a"));
+ Assertions.assertEquals("ComplexCalls", util.getFieldValueOfObject(
+ fieldClassObjectContent, "classObject").getClass().getName());
+ Assertions.assertEquals(3, util.getFieldValueOfObject(
+ util.getFieldValueOfObject(fieldClassObjectContent, "classObject"), "a"));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testInvokeMethodGetClassObject() {
+ try {
+ Object fieldClassObject = util.getFieldValue("classObject");
+ Assertions.assertNull(fieldClassObject);
+ int fieldA = (int) util.getFieldValue("a");
+ Assertions.assertEquals(0, fieldA);
+ Object returnValue = util.invokeMethod("getClassObject", new Class>[]{}, new Object[]{});
+ Assertions.assertEquals(util.getFieldValue("classObject"), returnValue);
+ Assertions.assertEquals(fieldClassObject, util.getFieldValue("classObject"));
+ Assertions.assertEquals(fieldA, util.getFieldValue("a"));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+
+ @Test
+ public void testInvokeMethodGetA() {
+ try {
+ Object fieldClassObject = util.getFieldValue("classObject");
+ Assertions.assertNull(fieldClassObject);
+ int fieldA = (int) util.getFieldValue("a");
+ Assertions.assertEquals(0, fieldA);
+ int returnValue = (int) util.invokeMethod("getA", new Class>[]{int.class}, new Object[]{5});
+ Assertions.assertEquals(5, returnValue);
+ Assertions.assertEquals(fieldClassObject, util.getFieldValue("classObject"));
+ Assertions.assertNotEquals(fieldA, util.getFieldValue("a"));
+ Assertions.assertEquals(5, util.getFieldValue("a"));
+ } catch (Exception e) {
+ Assertions.fail();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Constructor.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Constructor.java
new file mode 100644
index 0000000..a77f5d5
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Constructor.java
@@ -0,0 +1,159 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.ast.Operator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_Constructor {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "Constructor",
+ List.of(),
+ List.of(),
+ List.of(
+ new TypedConstructor(
+ "Constructor",
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "i",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 1,
+ Type.INT),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ ),
+ new TypedConstructor(
+ "Constructor",
+ List.of(
+ new TypedParameter(
+ "x",
+ Type.INT
+ )
+ ),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "i",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of(
+ new TypedLocalVariable(
+ "x",
+ Type.INT
+ )
+ )
+ ),
+ new TypedConstructor(
+ "Constructor",
+ List.of(
+ new TypedParameter(
+ "x",
+ Type.INT
+ ),
+ new TypedParameter(
+ "y",
+ Type.INT
+ )
+ ),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "i",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of(
+ new TypedLocalVariable(
+ "x",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "y",
+ Type.INT
+ )
+ )
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("Constructor")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Continue.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Continue.java
new file mode 100644
index 0000000..9b05d9f
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Continue.java
@@ -0,0 +1,145 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.ast.Operator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_Continue {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "Continue",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "continueLoop",
+ Type.VOID,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "i",
+ Type.INT
+ )),
+ List.of(
+ new TypedFor(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 0,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Operator.LT,
+ new TypedIntLiteral(
+ 5,
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ new TypedAssignment(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedIntLiteral(
+ 1,
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedIfElse(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Operator.EQ,
+ new TypedIntLiteral(
+ 3,
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedContinue()
+ ),
+ Type.VOID
+
+ ),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID
+ )
+ ),
+ Type.VOID
+ ),
+ Type.INT
+ )
+ ),
+ Type.VOID
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "Continue",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("Continue")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_DataTypes.java b/src/test/java/testResources/CodeGen/Features/ByteCode_DataTypes.java
new file mode 100644
index 0000000..1f2dd98
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_DataTypes.java
@@ -0,0 +1,184 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_DataTypes {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "DataTypes",
+ List.of(
+ new TypedDeclaration(
+ "x",
+ Type.INT
+ ),
+ new TypedDeclaration(
+ "y",
+ Type.BOOL
+ ),
+ new TypedDeclaration(
+ "z",
+ Type.CHAR
+ )
+ ),
+ List.of(
+ new TypedMethod(
+ "integer",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "i",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "a",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 1,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedReturn(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "bool",
+ Type.BOOL,
+ List.of(
+ new TypedParameter(
+ "b",
+ Type.BOOL
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "a",
+ Type.BOOL
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedBoolLiteral(
+ true,
+ Type.BOOL
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.BOOL
+ ),
+ Type.BOOL
+ ),
+ new TypedReturn(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.BOOL
+ )
+ ),
+ new TypedMethod(
+ "character",
+ Type.CHAR,
+ List.of(
+ new TypedParameter(
+ "c",
+ Type.CHAR
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "a",
+ Type.CHAR
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedCharLiteral(
+ 'a',
+ Type.CHAR
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.CHAR
+ ),
+ Type.CHAR
+ ),
+ new TypedReturn(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.CHAR
+ ),
+ Type.CHAR
+ )
+ ),
+ Type.CHAR
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "DataTypes",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("DataTypes")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Field.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Field.java
new file mode 100644
index 0000000..236d8c8
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Field.java
@@ -0,0 +1,86 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_Field {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "Field",
+ List.of(
+ new TypedDeclaration(
+ "x",
+ Type.INT
+ ),
+ new TypedDeclaration(
+ "c",
+ Type.CHAR
+ )
+ ),
+ List.of(
+ new TypedMethod(
+ "fieldAccess",
+ Type.VOID,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 0,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ true,
+ null,
+ "x",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedAssignment(
+ new TypedCharLiteral(
+ 'a',
+ Type.CHAR
+ ),
+ new TypedFieldVarAccess(
+ true,
+ null,
+ "c",
+ Type.CHAR
+ ),
+ Type.CHAR
+ )
+ ),
+ Type.VOID
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "Field",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("Field")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_For.java b/src/test/java/testResources/CodeGen/Features/ByteCode_For.java
new file mode 100644
index 0000000..6670d6d
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_For.java
@@ -0,0 +1,176 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.ast.Operator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_For {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "For",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "testFor",
+ Type.VOID,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "i",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "j",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedFor(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 0,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Operator.LT,
+ new TypedIntLiteral(
+ 10,
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ new TypedAssignment(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedIntLiteral(
+ 1,
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID
+ ),
+ new TypedFor(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 0,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "j",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "j",
+ Type.INT
+ ),
+ Operator.LT,
+ new TypedIntLiteral(
+ 10,
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ new TypedAssignment(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "j",
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedIntLiteral(
+ 1,
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "j",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID
+ )
+ )
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "For",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("For")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_If.java b/src/test/java/testResources/CodeGen/Features/ByteCode_If.java
new file mode 100644
index 0000000..3733c16
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_If.java
@@ -0,0 +1,86 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_If {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "If",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "ifMethod",
+ Type.VOID,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedIfElse(
+ new TypedBoolLiteral(
+ false,
+ Type.BOOL
+ ),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedIfElse(
+ new TypedBoolLiteral(
+ true,
+ Type.BOOL
+ ),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID
+ )
+ ),
+ Type.VOID
+ ),
+ Type.VOID
+ )
+ ),
+ Type.VOID
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "If",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("If")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_LogicExpr.java b/src/test/java/testResources/CodeGen/Features/ByteCode_LogicExpr.java
new file mode 100644
index 0000000..be4dcdc
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_LogicExpr.java
@@ -0,0 +1,568 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.ast.Operator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_LogicExpr {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "LogicExpr",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "test",
+ Type.BOOL,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "x",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "y",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 10,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 20,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Operator.LT,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.BOOL
+ )
+ ),
+ new TypedMethod(
+ "test2",
+ Type.BOOL,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "x",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "y",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 10,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 20,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Operator.GT,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.BOOL
+ )
+ ),
+ new TypedMethod(
+ "test3",
+ Type.BOOL,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "x",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "y",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 10,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 20,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Operator.EQ,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.BOOL
+ )
+ ),
+ new TypedMethod(
+ "test4",
+ Type.BOOL,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "x",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "y",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 10,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 20,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Operator.NE,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.BOOL
+ )
+ ),
+ new TypedMethod(
+ "test5",
+ Type.BOOL,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "x",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "y",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 10,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 20,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Operator.LE,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.BOOL
+ )
+ ),
+ new TypedMethod(
+ "test6",
+ Type.BOOL,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "x",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "y",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 10,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 20,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Operator.GE,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.BOOL
+ )
+ ),
+ new TypedMethod(
+ "test7",
+ Type.BOOL,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "x",
+ Type.BOOL
+ ),
+ new TypedLocalVariable(
+ "y",
+ Type.BOOL
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedBoolLiteral(
+ true,
+ Type.BOOL
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.BOOL
+ ),
+ Type.BOOL
+ ),
+ new TypedAssignment(
+ new TypedBoolLiteral(
+ false,
+ Type.BOOL
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.BOOL
+ ),
+ Type.BOOL
+ ),
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.BOOL
+ ),
+ Operator.AND,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.BOOL
+ ),
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.BOOL
+ )
+ ),
+ new TypedMethod(
+ "test8",
+ Type.BOOL,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "x",
+ Type.BOOL
+ ),
+ new TypedLocalVariable(
+ "y",
+ Type.BOOL
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedBoolLiteral(
+ true,
+ Type.BOOL
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.BOOL
+ ),
+ Type.BOOL
+ ),
+ new TypedAssignment(
+ new TypedBoolLiteral(
+ false,
+ Type.BOOL
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.BOOL
+ ),
+ Type.BOOL
+ ),
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.BOOL
+ ),
+ Operator.OR,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.BOOL
+ ),
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.BOOL
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "LogicExpr",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("LogicExpr")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Main.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Main.java
new file mode 100644
index 0000000..d33d24f
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Main.java
@@ -0,0 +1,72 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_Main {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "Main",
+ List.of(),
+ List.of(),
+ List.of(
+ new TypedConstructor(
+ "Main",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ new TypedMain(
+ Type.VOID,
+ new TypedMethod(
+ "main",
+ Type.VOID,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "i",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 0,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.VOID
+ )
+
+ )
+
+ ),
+ null,
+ null,
+ Type.REFERENCE("Main")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Method.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Method.java
new file mode 100644
index 0000000..a18dd24
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Method.java
@@ -0,0 +1,50 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_Method {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "Method",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "method",
+ Type.VOID,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "Method",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("Method")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_MethodCall.java b/src/test/java/testResources/CodeGen/Features/ByteCode_MethodCall.java
new file mode 100644
index 0000000..de2116b
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_MethodCall.java
@@ -0,0 +1,214 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.ast.Operator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_MethodCall {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "MethodCall",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "methodCall",
+ Type.INT,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedMethodCall(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "method",
+ Type.INT
+ ),
+ List.of(),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "methodCall1",
+ Type.INT,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedMethodCall(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "method1",
+ Type.INT
+ ),
+ List.of(
+ new TypedIntLiteral(
+ 1,
+ Type.INT
+ )
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "methodCall2",
+ Type.INT,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedMethodCall(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "method2",
+ Type.INT
+ ),
+ List.of(
+ new TypedIntLiteral(
+ 1,
+ Type.INT
+ ),
+ new TypedIntLiteral(
+ 2,
+ Type.INT
+ )
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "method",
+ Type.INT,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedIntLiteral(
+ 0,
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "method1",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "x",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "method2",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "x",
+ Type.INT
+ ),
+ new TypedParameter(
+ "y",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "MethodCall",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("MethodCall")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_MultipleClasses.java b/src/test/java/testResources/CodeGen/Features/ByteCode_MultipleClasses.java
new file mode 100644
index 0000000..d2dc293
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_MultipleClasses.java
@@ -0,0 +1,98 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_MultipleClasses {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "MultipleClasses",
+ List.of(
+ new TypedDeclaration(
+ "anotherClass",
+ Type.REFERENCE("AnotherClass")
+ )
+ ),
+ List.of(),
+ List.of(
+ new TypedConstructor(
+ "MultipleClasses",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedAssignment(
+ new TypedNew(
+ Type.REFERENCE("AnotherClass"),
+ List.of()
+ ),
+ new TypedFieldVarAccess(
+ true,
+ null,
+ "anotherClass",
+ Type.REFERENCE("AnotherClass")
+ ),
+ Type.REFERENCE("AnotherClass")
+ )
+ ),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("MultipleClasses")
+ ),
+ new TypedClass(
+ "AnotherClass",
+ List.of(
+ new TypedDeclaration(
+ "multipleClasses",
+ Type.REFERENCE("MultipleClasses")
+ )
+ ),
+ List.of(),
+ List.of(
+ new TypedConstructor(
+ "AnotherClass",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedAssignment(
+ new TypedNew(
+ Type.REFERENCE("MultipleClasses"),
+ List.of()
+ ),
+ new TypedFieldVarAccess(
+ true,
+ null,
+ "multipleClasses",
+ Type.REFERENCE("MultipleClasses")
+ ),
+ Type.REFERENCE("MultipleClasses")
+ )
+ ),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("AnotherClass")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Operators.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Operators.java
new file mode 100644
index 0000000..cfddc31
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Operators.java
@@ -0,0 +1,446 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.ast.Operator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+
+public class ByteCode_Operators {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "Operators",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "add",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "a",
+ Type.INT
+ ),
+ new TypedParameter(
+ "b",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "sub",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "a",
+ Type.INT
+ ),
+ new TypedParameter(
+ "b",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Operator.SUB,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "mul",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "a",
+ Type.INT
+ ),
+ new TypedParameter(
+ "b",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Operator.MUL,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "div",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "a",
+ Type.INT
+ ),
+ new TypedParameter(
+ "b",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Operator.DIV,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "mod",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "a",
+ Type.INT
+ ),
+ new TypedParameter(
+ "b",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Operator.MOD,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "brackets",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "a",
+ Type.INT
+ ),
+ new TypedParameter(
+ "b",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedBinary(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Operator.MUL,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "callOperatedMethods",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "a",
+ Type.INT
+ ),
+ new TypedParameter(
+ "b",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedBinary(
+ new TypedBinary(
+ new TypedBinary(
+ new TypedBinary(
+ new TypedMethodCall(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "add",
+ Type.INT
+ ),
+ List.of(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ )
+ ),
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedMethodCall(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "sub",
+ Type.INT
+ ),
+ List.of(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ )
+ ),
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedMethodCall(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "mul",
+ Type.INT
+ ),
+ List.of(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ )
+ ),
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedMethodCall(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "div",
+ Type.INT
+ ),
+ List.of(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ )
+ ),
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedMethodCall(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "mod",
+ Type.INT
+ ),
+ List.of(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ )
+ ),
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "Operators",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("Operators")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Overloaded.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Overloaded.java
new file mode 100644
index 0000000..a679cdc
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Overloaded.java
@@ -0,0 +1,125 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.ast.Operator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_Overloaded {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "Overloaded",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "overloadedMethod",
+ Type.INT,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedIntLiteral(
+ 0,
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "overloadedMethod",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "x",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "overloadedMethod",
+ Type.INT,
+ List.of(
+ new TypedParameter(
+ "x",
+ Type.INT
+ ),
+ new TypedParameter(
+ "y",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "Overloaded",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("Overloaded")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Print.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Print.java
new file mode 100644
index 0000000..14557ff
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Print.java
@@ -0,0 +1,106 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.ast.Operator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_Print {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "Print",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "printIt",
+ Type.VOID,
+ List.of(
+ new TypedParameter(
+ "c",
+ Type.CHAR
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedPrint(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "c",
+ Type.CHAR
+ ),
+ Type.VOID
+ )
+ ),
+ Type.VOID
+ )
+ ),
+ new TypedMethod(
+ "printMoreComplex",
+ Type.VOID,
+ List.of(
+ new TypedParameter(
+ "x",
+ Type.INT
+ ),
+ new TypedParameter(
+ "y",
+ Type.INT
+ )
+ ),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedPrint(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "x",
+ Type.INT
+ ),
+ Operator.LT,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "y",
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ Type.VOID
+ )
+ ),
+ Type.VOID
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "Print",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("Print")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Return.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Return.java
new file mode 100644
index 0000000..d6fd43f
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Return.java
@@ -0,0 +1,131 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_Return {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "Return",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "returnInt",
+ Type.INT,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedIntLiteral(
+ 10,
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.INT
+ )
+ ),
+ new TypedMethod(
+ "returnVoid",
+ Type.VOID,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ null,
+ Type.VOID
+ )
+ ),
+ Type.VOID
+ )
+ ),
+ new TypedMethod(
+ "returnBoolean",
+ Type.BOOL,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedBoolLiteral(
+ true,
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.BOOL
+ )
+ ),
+ new TypedMethod(
+ "returnChar",
+ Type.CHAR,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedCharLiteral(
+ 'a',
+ Type.CHAR
+ ),
+ Type.CHAR
+ )
+ ),
+ Type.CHAR
+ )
+ ),
+ new TypedMethod(
+ "returnClass",
+ Type.REFERENCE("Return"),
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedReturn(
+ new TypedNew(
+ Type.REFERENCE("Return"),
+ List.of()
+ ),
+ Type.REFERENCE("Return")
+ )
+ ),
+ Type.REFERENCE("Return")
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "Return",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("Return")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Unary.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Unary.java
new file mode 100644
index 0000000..255356e
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_Unary.java
@@ -0,0 +1,102 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.ast.UnaryOperator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_Unary {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "Unary",
+ List.of(),
+ List.of(),
+ List.of(
+ new TypedConstructor(
+ "Unary",
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "a",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "b",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "c",
+ Type.BOOL
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 5,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedAssignment(
+ new TypedUnary(
+ UnaryOperator.SUB,
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedAssignment(
+ new TypedUnary(
+ UnaryOperator.NOT,
+ new TypedBoolLiteral(
+ true,
+ Type.BOOL
+ ),
+ Type.BOOL
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "c",
+ Type.BOOL
+ ),
+ Type.BOOL
+ )
+ ),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("Unary")
+ )
+ ),
+ null
+ );
+ }
+}
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_VariableDefWithDecl.java b/src/test/java/testResources/CodeGen/Features/ByteCode_VariableDefWithDecl.java
new file mode 100644
index 0000000..f33ed3f
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_VariableDefWithDecl.java
@@ -0,0 +1,74 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_VariableDefWithDecl {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "VariableDefWithDecl",
+ List.of(),
+ List.of(),
+ List.of(
+ new TypedConstructor(
+ "VariableDefWithDecl",
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "a",
+ Type.INT
+ ),
+ new TypedLocalVariable(
+ "b",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 10,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "a",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 20,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "b",
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("VariableDefWithDecl")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_While.java b/src/test/java/testResources/CodeGen/Features/ByteCode_While.java
new file mode 100644
index 0000000..9fbde62
--- /dev/null
+++ b/src/test/java/testResources/CodeGen/Features/ByteCode_While.java
@@ -0,0 +1,190 @@
+package testResources.CodeGen.Features;
+
+import de.maishai.ast.Operator;
+import de.maishai.typedast.Type;
+import de.maishai.typedast.typedclass.*;
+
+import java.util.List;
+
+public class ByteCode_While {
+ public static TypedProgram get() {
+ return new TypedProgram(
+ List.of(
+ new TypedClass(
+ "While",
+ List.of(),
+ List.of(
+ new TypedMethod(
+ "whileLoop",
+ Type.VOID,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "i",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 0,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedWhile(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Operator.LT,
+ new TypedIntLiteral(
+ 5,
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedAssignment(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedIntLiteral(
+ 1,
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.VOID
+ ),
+ Type.VOID
+ )
+ )
+ )
+ ),
+ new TypedMethod(
+ "doWhileLoop",
+ Type.VOID,
+ List.of(),
+ List.of(),
+ new TypedBlock(
+ List.of(
+ new TypedLocalVariable(
+ "i",
+ Type.INT
+ )
+ ),
+ List.of(
+ new TypedAssignment(
+ new TypedIntLiteral(
+ 0,
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedDoWhile(
+ new TypedBlock(
+ List.of(),
+ List.of(
+ new TypedAssignment(
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Operator.ADD,
+ new TypedIntLiteral(
+ 1,
+ Type.INT
+ ),
+ Type.INT
+ ),
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Type.INT
+ )
+ ),
+ Type.VOID
+ ),
+ new TypedBinary(
+ new TypedFieldVarAccess(
+ false,
+ null,
+ "i",
+ Type.INT
+ ),
+ Operator.LT,
+ new TypedIntLiteral(
+ 5,
+ Type.INT
+ ),
+ Type.BOOL
+ ),
+ Type.VOID
+ )
+ )
+ )
+ )
+ ),
+ List.of(
+ new TypedConstructor(
+ "While",
+ List.of(),
+ new TypedBlock(
+ List.of(),
+ List.of(),
+ Type.VOID
+ ),
+ Type.VOID,
+ List.of()
+ )
+ ),
+ null,
+ null,
+ null,
+ Type.REFERENCE("While")
+ )
+ ),
+ null
+ );
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/testResources/TypedAST/TypedASTFeatures/TypedAST_Main.java b/src/test/java/testResources/TypedAST/TypedASTFeatures/TypedAST_Main.java
index 76e3aae..fa665d6 100644
--- a/src/test/java/testResources/TypedAST/TypedASTFeatures/TypedAST_Main.java
+++ b/src/test/java/testResources/TypedAST/TypedASTFeatures/TypedAST_Main.java
@@ -31,7 +31,12 @@ public class TypedAST_Main {
new TypedMethod(
"main",
Type.VOID,
- List.of(),
+ List.of(
+ new TypedParameter(
+ "args",
+ Type.REFERENCE("String[]")
+ )
+ ),
List.of(),
new TypedBlock(
List.of(
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Break.java b/src/test/testFiles/ASTandTypedASTFeatures/Break.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Break.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Break.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Class.java b/src/test/testFiles/ASTandTypedASTFeatures/Class.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Class.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Class.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/ClassObjects.java b/src/test/testFiles/ASTandTypedASTFeatures/ClassObjects.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/ClassObjects.java
rename to src/test/testFiles/ASTandTypedASTFeatures/ClassObjects.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Comment.java b/src/test/testFiles/ASTandTypedASTFeatures/Comment.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Comment.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Comment.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/CompAssign.java b/src/test/testFiles/ASTandTypedASTFeatures/CompAssign.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/CompAssign.java
rename to src/test/testFiles/ASTandTypedASTFeatures/CompAssign.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/ComplexCalls.java b/src/test/testFiles/ASTandTypedASTFeatures/ComplexCalls.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/ComplexCalls.java
rename to src/test/testFiles/ASTandTypedASTFeatures/ComplexCalls.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Constructor.java b/src/test/testFiles/ASTandTypedASTFeatures/Constructor.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Constructor.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Constructor.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Continue.java b/src/test/testFiles/ASTandTypedASTFeatures/Continue.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Continue.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Continue.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/DataTypes.java b/src/test/testFiles/ASTandTypedASTFeatures/DataTypes.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/DataTypes.java
rename to src/test/testFiles/ASTandTypedASTFeatures/DataTypes.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Field.java b/src/test/testFiles/ASTandTypedASTFeatures/Field.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Field.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Field.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/For.java b/src/test/testFiles/ASTandTypedASTFeatures/For.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/For.java
rename to src/test/testFiles/ASTandTypedASTFeatures/For.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/If.java b/src/test/testFiles/ASTandTypedASTFeatures/If.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/If.java
rename to src/test/testFiles/ASTandTypedASTFeatures/If.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/LogicExpr.java b/src/test/testFiles/ASTandTypedASTFeatures/LogicExpr.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/LogicExpr.java
rename to src/test/testFiles/ASTandTypedASTFeatures/LogicExpr.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Main.java b/src/test/testFiles/ASTandTypedASTFeatures/Main.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Main.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Main.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Method.java b/src/test/testFiles/ASTandTypedASTFeatures/Method.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Method.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Method.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/MethodCall.java b/src/test/testFiles/ASTandTypedASTFeatures/MethodCall.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/MethodCall.java
rename to src/test/testFiles/ASTandTypedASTFeatures/MethodCall.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/MultipleClasses.java b/src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/MultipleClasses.java
rename to src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Operators.java b/src/test/testFiles/ASTandTypedASTFeatures/Operators.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Operators.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Operators.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Overloaded.java b/src/test/testFiles/ASTandTypedASTFeatures/Overloaded.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Overloaded.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Overloaded.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Print.java b/src/test/testFiles/ASTandTypedASTFeatures/Print.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Print.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Print.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Return.java b/src/test/testFiles/ASTandTypedASTFeatures/Return.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Return.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Return.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/Unary.java b/src/test/testFiles/ASTandTypedASTFeatures/Unary.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/Unary.java
rename to src/test/testFiles/ASTandTypedASTFeatures/Unary.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/VariableDefWithDecl.java b/src/test/testFiles/ASTandTypedASTFeatures/VariableDefWithDecl.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/VariableDefWithDecl.java
rename to src/test/testFiles/ASTandTypedASTFeatures/VariableDefWithDecl.java
diff --git a/src/test/testFiles/JavaTestfilesFeatures/While.java b/src/test/testFiles/ASTandTypedASTFeatures/While.java
similarity index 100%
rename from src/test/testFiles/JavaTestfilesFeatures/While.java
rename to src/test/testFiles/ASTandTypedASTFeatures/While.java
diff --git a/src/test/testFiles/CodeGenFeatures/Break.java b/src/test/testFiles/CodeGenFeatures/Break.java
new file mode 100644
index 0000000..ae9eded
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Break.java
@@ -0,0 +1,21 @@
+public class Break {
+ int whileRepetition;
+ int forRepetition;
+
+ public void breakMethod(boolean breakCondition) {
+ this.whileRepetition = 0;
+ while (this.whileRepetition < 10) {
+ this.whileRepetition += 1;
+ if (breakCondition && (this.whileRepetition == 5)) {
+ break;
+ }
+ }
+ this.forRepetition = 0;
+ for (int i = 0; i < 10; i += 1) {
+ this.forRepetition += 1;
+ if (breakCondition && (this.forRepetition == 5)) {
+ break;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Class.java b/src/test/testFiles/CodeGenFeatures/Class.java
new file mode 100644
index 0000000..366f84e
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Class.java
@@ -0,0 +1,2 @@
+public class Class {
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/ClassObjects.java b/src/test/testFiles/CodeGenFeatures/ClassObjects.java
new file mode 100644
index 0000000..565f559
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/ClassObjects.java
@@ -0,0 +1,19 @@
+public class ClassObjects {
+
+ ClassObjects object;
+ ClassObjects objectWithValue;
+ int integerValue;
+
+ public ClassObjects() {
+ }
+
+ public ClassObjects(int value) {
+ this.integerValue = value;
+ }
+
+ public void objectsMethod() {
+ this.object = new ClassObjects();
+ this.objectWithValue = new ClassObjects(2);
+ this.integerValue = 2;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Comment.java b/src/test/testFiles/CodeGenFeatures/Comment.java
new file mode 100644
index 0000000..a8ce7f3
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Comment.java
@@ -0,0 +1,12 @@
+public class Comment {
+ // This is a comment
+
+
+ // This is another comment
+ // With multiple lines
+
+ /* This is a comment
+ with multiple lines written in a block
+ which is closed/started with a * and a /
+ */
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/CompAssign.java b/src/test/testFiles/CodeGenFeatures/CompAssign.java
new file mode 100644
index 0000000..e0d42c2
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/CompAssign.java
@@ -0,0 +1,26 @@
+public class CompAssign {
+ public int increase(int a) {
+ a += 1;
+ return a;
+ }
+
+ public int decrease(int a) {
+ a -= 1;
+ return a;
+ }
+
+ public int multiply(int a) {
+ a *= 2;
+ return a;
+ }
+
+ public int divide(int a) {
+ a /= 2;
+ return a;
+ }
+
+ public int modulus(int a) {
+ a %= 2;
+ return a;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/ComplexCalls.java b/src/test/testFiles/CodeGenFeatures/ComplexCalls.java
new file mode 100644
index 0000000..2b33c79
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/ComplexCalls.java
@@ -0,0 +1,22 @@
+public class ComplexCalls {
+ ComplexCalls classObject;
+ int a;
+
+ public int makeComplexCalls() {
+ this.classObject = new ComplexCalls();
+ this.a = 1;
+ this.classObject.a = 2;
+ this.classObject.classObject = new ComplexCalls();
+ this.classObject.classObject.a = this.getClassObject().a;
+ return this.classObject.classObject.getA(3);
+ }
+
+ public ComplexCalls getClassObject() {
+ return this.classObject;
+ }
+
+ public int getA(int x) {
+ this.a = x;
+ return x;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Constructor.java b/src/test/testFiles/CodeGenFeatures/Constructor.java
new file mode 100644
index 0000000..4262853
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Constructor.java
@@ -0,0 +1,18 @@
+public class Constructor {
+ int i;
+
+ public Constructor() {
+ this.i;
+ i = 1;
+ }
+
+ public Constructor(this.x) {
+ this.i;
+ i= x;
+ }
+
+ public Constructor(this.x, this.y) {
+ this.i;
+ i= x + y;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Continue.java b/src/test/testFiles/CodeGenFeatures/Continue.java
new file mode 100644
index 0000000..69f4c6c
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Continue.java
@@ -0,0 +1,12 @@
+public class Continue {
+ int repetitions;
+ public void continueLoop(boolean shouldContinue) {
+ this.repetitions = 0;
+ for (int i = 0; i < 5; i+=1) {
+ if (shouldContinue && i == 3) {
+ continue;
+ }
+ repetitions += 1;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/DataTypes.java b/src/test/testFiles/CodeGenFeatures/DataTypes.java
new file mode 100644
index 0000000..9c3b8db
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/DataTypes.java
@@ -0,0 +1,23 @@
+public class DataTypes {
+ int x;
+ boolean y;
+ char z;
+
+ public int integer(int i) {
+ int a = 1;
+ this.x = a;
+ return a;
+ }
+
+ public boolean bool(boolean b) {
+ boolean a = true;
+ this.y = a;
+ return a;
+ }
+
+ public char character(char c) {
+ char a = 'a';
+ this.z = a;
+ return a;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Field.java b/src/test/testFiles/CodeGenFeatures/Field.java
new file mode 100644
index 0000000..5c23526
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Field.java
@@ -0,0 +1,17 @@
+public class Field {
+ int x;
+ public char c;
+
+ public void fieldAccess() {
+ this.x = 0;
+ this.c = 'a';
+ }
+
+ public void setX(int x) {
+ this.x = x;
+ }
+
+ public void setC(char c) {
+ this.c = c;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/For.java b/src/test/testFiles/CodeGenFeatures/For.java
new file mode 100644
index 0000000..012eb0b
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/For.java
@@ -0,0 +1,21 @@
+public class For {
+ int repititionsFirtsFor;
+ int repititionsSecondFor;
+
+ public For() {
+ this.repititionsFirtsFor = 0;
+ this.repititionsSecondFor = 0;
+ }
+
+ public void testFor() {
+ this.repititionsFirtsFor = 0;
+ for (int i = 0; i < 10; i = i+1) {
+ this.repititionsFirtsFor = this.repititionsFirtsFor + i;
+ }
+ this.repititionsSecondFor = 0;
+ int j;
+ for (j = 0; j < 10; j += 1) {
+ this.repititionsSecondFor = this.repititionsSecondFor + j;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/If.java b/src/test/testFiles/CodeGenFeatures/If.java
new file mode 100644
index 0000000..53b929f
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/If.java
@@ -0,0 +1,11 @@
+public class If {
+ public int ifMethod(boolean ifShouldRun, boolean elseIfShouldRun) {
+ if (ifShouldRun) {
+ return 1;
+ } else if (elseIfShouldRun) {
+ return 2;
+ } else {
+ return 3;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/LogicExpr.java b/src/test/testFiles/CodeGenFeatures/LogicExpr.java
new file mode 100644
index 0000000..520ba79
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/LogicExpr.java
@@ -0,0 +1,33 @@
+public class LogicExpr {
+ public boolean testSmaller(int x, int y) {
+ return x < y;
+ }
+
+ public boolean testLarger(int x, int y) {
+ return x > y;
+ }
+
+ public boolean testEqual(int x, int y) {
+ return x == y;
+ }
+
+ public boolean testNotEqual(int x, int y) {
+ return x != y;
+ }
+
+ public boolean testSmallerEqual(int x, int y) {
+ return x <= y;
+ }
+
+ public boolean testLargerEqual(int x, int y) {
+ return x >= y;
+ }
+
+ public boolean testAND(boolean x, boolean y) {
+ return x && y;
+ }
+
+ public boolean testOR(boolean x, boolean y) {
+ return x || y;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Main.java b/src/test/testFiles/CodeGenFeatures/Main.java
new file mode 100644
index 0000000..5fab2d3
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Main.java
@@ -0,0 +1,11 @@
+public class Main {
+ int i;
+
+ public Main() {
+ this.i = 0;
+ }
+
+ public static void main(String[] args) {
+ this.i = 10;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Method.java b/src/test/testFiles/CodeGenFeatures/Method.java
new file mode 100644
index 0000000..f19481b
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Method.java
@@ -0,0 +1,11 @@
+public class Method {
+ int x;
+
+ public Method() {
+ this.x = 0;
+ }
+
+ public void method() {
+ this.x = 10;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/MethodCall.java b/src/test/testFiles/CodeGenFeatures/MethodCall.java
new file mode 100644
index 0000000..3bc0840
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/MethodCall.java
@@ -0,0 +1,26 @@
+public class MethodCall {
+
+ public int methodCall() {
+ return method();
+ }
+
+ public int methodCall1() {
+ return method1(1);
+ }
+
+ public int methodCall2() {
+ return method2(1, 2);
+ }
+
+ public int method() {
+ return 0;
+ }
+
+ public int method1(int x) {
+ return x;
+ }
+
+ public int method2(int x, int y) {
+ return x + y;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/MultipleClasses.java b/src/test/testFiles/CodeGenFeatures/MultipleClasses.java
new file mode 100644
index 0000000..84c63bf
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/MultipleClasses.java
@@ -0,0 +1,15 @@
+public class MultipleClasses {
+ AnotherClass anotherClass;
+
+ public MultipleClasses() {
+ this.anotherClass = new AnotherClass();
+ }
+}
+
+public class AnotherClass {
+ MultipleClasses multipleClasses;
+
+ public AnotherClass() {
+ this.multipleClasses = new MultipleClasses();
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Operators.java b/src/test/testFiles/CodeGenFeatures/Operators.java
new file mode 100644
index 0000000..55b6b40
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Operators.java
@@ -0,0 +1,29 @@
+public class Operators {
+ public int add(int a, int b) {
+ return a + b;
+ }
+
+ public int sub(int a, int b) {
+ return a - b;
+ }
+
+ public int mul(int a, int b) {
+ return a * b;
+ }
+
+ public int div(int a, int b) {
+ return a / b;
+ }
+
+ public int mod(int a, int b) {
+ return a % b;
+ }
+
+ public int brackets(int a, int b) {
+ return (a + b) * a;
+ }
+
+ public int callOperatedMethods(int a, int b) {
+ return add(a, b) + sub(a, b) + mul(a, b) + div(a, b) + mod(a, b);
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Overloaded.java b/src/test/testFiles/CodeGenFeatures/Overloaded.java
new file mode 100644
index 0000000..bcb688c
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Overloaded.java
@@ -0,0 +1,13 @@
+public class Overloaded {
+ public int overloadedMethod() {
+ return 0;
+ }
+
+ public int overloadedMethod(int x) {
+ return x;
+ }
+
+ public int overloadedMethod(int x, int y) {
+ return x + y;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Print.java b/src/test/testFiles/CodeGenFeatures/Print.java
new file mode 100644
index 0000000..5a2ceb9
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Print.java
@@ -0,0 +1,9 @@
+public class Print {
+ public void printIt(char c) {
+ print(c);
+ }
+
+ public void printMoreComplex(int x, int y) {
+ print(x < y);
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Return.java b/src/test/testFiles/CodeGenFeatures/Return.java
new file mode 100644
index 0000000..491c22a
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Return.java
@@ -0,0 +1,21 @@
+public class Return {
+ public int returnInt() {
+ return 10;
+ }
+
+ public void returnVoid() {
+ return;
+ }
+
+ public boolean returnBoolean() {
+ return true;
+ }
+
+ public char returnChar() {
+ return 'a';
+ }
+
+ public Return returnClass() {
+ return new Return();
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/Unary.java b/src/test/testFiles/CodeGenFeatures/Unary.java
new file mode 100644
index 0000000..d0ca0e1
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/Unary.java
@@ -0,0 +1,10 @@
+public class Unary {
+
+ public int testMinus(int a) {
+ return -a;
+ }
+
+ public boolean testNot(boolean a) {
+ return !a;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/VariableDefWithDecl.java b/src/test/testFiles/CodeGenFeatures/VariableDefWithDecl.java
new file mode 100644
index 0000000..514de1e
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/VariableDefWithDecl.java
@@ -0,0 +1,13 @@
+public class VariableDefWithDecl {
+
+ public int testDefWithDeclInOne() {
+ int a = 10;
+ return a;
+ }
+
+ public int testDefWithDeclSeparate() {
+ int a;
+ a = 10;
+ return a;
+ }
+}
\ No newline at end of file
diff --git a/src/test/testFiles/CodeGenFeatures/While.java b/src/test/testFiles/CodeGenFeatures/While.java
new file mode 100644
index 0000000..93d88e9
--- /dev/null
+++ b/src/test/testFiles/CodeGenFeatures/While.java
@@ -0,0 +1,24 @@
+public class While {
+ int whileRepititions;
+ int doWhileRepititions;
+
+ public While() {
+ this.whileRepititions = 0;
+ this.doWhileRepititions = 0;
+ }
+
+
+ public void whileLoop() {
+ this.whileRepititions = 0;
+ while (i < 5) {
+ this.whileRepititions = this.whileRepititions + 1;
+ }
+ }
+
+ public void doWhileLoop() {
+ this.doWhileRepititions = 0;
+ do {
+ this.doWhileRepititions = this.doWhileRepititions + 1;
+ } while (i < 5);
+ }
+}
\ No newline at end of file