diff --git a/src/main/java/semantic/SemanticAnalyzer.java b/src/main/java/semantic/SemanticAnalyzer.java index 9878989..6ebd124 100644 --- a/src/main/java/semantic/SemanticAnalyzer.java +++ b/src/main/java/semantic/SemanticAnalyzer.java @@ -21,7 +21,6 @@ import ast.statementexpressions.AssignableNode; import ast.statementexpressions.NewDeclarationNode; import ast.statementexpressions.crementexpressions.DecrementNode; import ast.statementexpressions.crementexpressions.IncrementNode; -import ast.statementexpressions.methodcallstatementnexpressions.ChainedMethodNode; import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; import ast.statementexpressions.methodcallstatementnexpressions.TargetNode; import ast.statements.*; @@ -30,7 +29,6 @@ import ast.type.EnumAccessModifierNode; import ast.type.ValueNode; import ast.type.type.*; import com.sun.jdi.IntegerType; -import semantic.context.ClassContext; import semantic.context.Context; import semantic.exceptions.*; import typechecker.TypeCheckResult; @@ -165,11 +163,6 @@ public class SemanticAnalyzer implements SemanticVisitor { @Override public TypeCheckResult analyze(FieldNode toCheck) { - if (toCheck.type instanceof ReferenceType referenceType) { - if(!context.containsClass(referenceType.getIdentifier())){ - errors.add(new NotDeclaredException(referenceType.getIdentifier() + " not declared")); - } - } if (currentFields.get(toCheck.identifier) != null) { errors.add(new AlreadyDeclaredException("Already declared " + toCheck.identifier)); return new TypeCheckResult(false, null); @@ -177,8 +170,6 @@ public class SemanticAnalyzer implements SemanticVisitor { currentFields.put(toCheck.identifier, toCheck.type); } return new TypeCheckResult(true, null); - - } @Override @@ -284,6 +275,13 @@ public class SemanticAnalyzer implements SemanticVisitor { currentNullType = oldNullType; var valid = true; + // This check currently handles things like : + /** + * private int i; + * void foo(int i){ + * i = i; + * } + */ if (assignable.equals(rExpression)) { errors.add(new TypeMismatchException("Cannot assign to self")); valid = false; @@ -326,15 +324,6 @@ public class SemanticAnalyzer implements SemanticVisitor { targetType = currentFields.get(toCheck.target.identifier); } if (targetType instanceof ReferenceType reference) { - if (!toCheck.chainedMethods.isEmpty()) { - for (ChainedMethodNode chainedMethod : toCheck.chainedMethods) { - var type = getTypeFromMethod(chainedMethod, reference); - if (type instanceof ReferenceType referenceType) - reference = referenceType; - else - errors.add(new TypeMismatchException("Ein Basetyp hat keine funktionen")); - } - } var type = getTypeFromMethod(toCheck, reference); if (type != null) { return new TypeCheckResult(true, type); @@ -631,37 +620,4 @@ public class SemanticAnalyzer implements SemanticVisitor { return null; } - private ITypeNode getTypeFromMethod(ChainedMethodNode toCheck, ReferenceType reference) { - var classContext = context.getClass(reference.getIdentifier()); - - var methods = classContext.getMethods(); - for (var method : methods) { - if (toCheck.identifier.equals(method.getIdentifier())) { - if (method.getParameters().size() == toCheck.expressions.size() && !(method instanceof ConstructorNode)) { - boolean same = true; - for (int i = 0; i < method.getParameters().size(); i++) { - var result1 = method.getParameters().get(i).accept(this); - var result2 = toCheck.expressions.get(i).accept(this); - if (!Objects.equals(result1.getType(), result2.getType())) { - same = false; - } - } - if (same) { - if (method.accesModifier.accessType == EnumAccessModifierNode.PUBLIC) { - if (method.getType() == null) { - return new BaseType(TypeEnum.VOID); - } - return method.getType(); - } else { - errors.add(new NotVisibleException("This Method is not Visible")); - } - - } - } - } - } - - return null; - } - } \ No newline at end of file diff --git a/src/main/java/semantic/context/Context.java b/src/main/java/semantic/context/Context.java index 4b20c8f..39e279a 100644 --- a/src/main/java/semantic/context/Context.java +++ b/src/main/java/semantic/context/Context.java @@ -21,10 +21,6 @@ public class Context { return classes.get(identifier); } - public HashMap getClasses() { - return classes; - } - public boolean containsClass(String identifier) { return classes.containsKey(identifier); } diff --git a/src/test/java/main/MainTest.java b/src/test/java/main/MainTest.java index 24389bc..54ab8be 100644 --- a/src/test/java/main/MainTest.java +++ b/src/test/java/main/MainTest.java @@ -12,16 +12,11 @@ import java.nio.file.Paths; * run every test: mvn test * Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen */ +@Deprecated public class MainTest { @Test void test() { - CharStream codeCharStream = null; - try { - codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/CompilerInput.java")); - Main.compileFile(codeCharStream, "src/main/test/resources/output"); - } catch (IOException e) { - System.err.println("Error reading the file: " + e.getMessage()); - } + System.out.println("MainTest"); } } diff --git a/src/test/java/main/ReflectionsTest.java b/src/test/java/main/ReflectionsTest.java index d47d95a..3b4cffd 100644 --- a/src/test/java/main/ReflectionsTest.java +++ b/src/test/java/main/ReflectionsTest.java @@ -11,7 +11,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; - +@Deprecated public class ReflectionsTest { @Test diff --git a/src/test/java/parser/AstBuilderTest.java b/src/test/java/parser/AstBuilderTest.java index 2810e55..15403d3 100644 --- a/src/test/java/parser/AstBuilderTest.java +++ b/src/test/java/parser/AstBuilderTest.java @@ -9,34 +9,20 @@ import ast.expressions.unaryexpressions.MemberAccessNode; import ast.expressions.unaryexpressions.UnaryNode; import ast.members.ConstructorNode; import ast.members.FieldNode; -import ast.members.MemberNode; import ast.members.MethodNode; import ast.parameters.ParameterNode; import ast.statementexpressions.AssignNode; import ast.statementexpressions.AssignableNode; import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; import ast.statements.BlockNode; -import ast.statements.IStatementNode; import ast.statements.ReturnNode; import ast.type.AccessModifierNode; import ast.type.EnumValueNode; import ast.type.ValueNode; import ast.type.type.BaseType; -import ast.type.type.ITypeNode; import ast.type.type.TypeEnum; -import com.fasterxml.jackson.annotation.JsonFormat; -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.CharStreams; -import org.antlr.v4.runtime.CommonTokenStream; -import org.antlr.v4.runtime.tree.ParseTree; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import parser.astBuilder.ASTBuilder; -import parser.generated.SimpleJavaLexer; -import parser.generated.SimpleJavaParser; - -import java.io.IOException; -import java.lang.reflect.Member; import static org.assertj.core.api.Assertions.assertThat; @@ -343,7 +329,7 @@ class AstBuilderTest { @Test @DisplayName("Self Reference Test") - public void selfReferneceTest() { + public void selfReferenceTest() { //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected); } diff --git a/src/test/java/semantic/SemanticTest.java b/src/test/java/semantic/SemanticTest.java index f406580..db86fe9 100644 --- a/src/test/java/semantic/SemanticTest.java +++ b/src/test/java/semantic/SemanticTest.java @@ -1,5 +1,443 @@ package semantic; +import ast.ASTNode; +import ast.ClassNode; +import ast.ProgramNode; +import ast.expressions.IExpressionNode; +import ast.expressions.unaryexpressions.MemberAccessNode; +import ast.expressions.unaryexpressions.UnaryNode; +import ast.members.ConstructorNode; +import ast.members.FieldNode; +import ast.members.MethodNode; +import ast.parameters.ParameterNode; +import ast.statementexpressions.AssignNode; +import ast.statementexpressions.AssignableNode; +import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; +import ast.statements.BlockNode; +import ast.statements.ReturnNode; +import ast.type.AccessModifierNode; +import ast.type.EnumValueNode; +import ast.type.ValueNode; +import ast.type.type.BaseType; +import ast.type.type.TypeEnum; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import parser.Helper; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class SemanticTest { + private final static String directoryPath = "src/test/resources/input/singleFeatureTests/"; + + @BeforeEach + public void setUp() { + SemanticAnalyzer.clearAnalyzer(); + } + + @Test + @DisplayName("Empty Class Test") + public void emptyClassTest() { + ClassNode emptyClass = Helper.generateEmptyClass("EmptyClass"); + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(emptyClass); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + + @Test + @DisplayName("Multiple Empty Classes Test") + public void multipleEmptyClassesTest() { + ClassNode class1 = Helper.generateEmptyClass("MultipleClasses"); + ClassNode class2 = Helper.generateEmptyClass("TestClass2"); + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + abstractSyntaxTree.addClass(class2); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + + @Test + @DisplayName("Empty Class Test with Constructor") + public void emptyClassWithConstructorTest() { + ClassNode class1 = Helper.generateEmptyClass("EmptyClassWithConstructor"); + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Field Test") + public void fieldTest() { + ClassNode class1 = Helper.generateEmptyClass("Field"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Field Test with Accessmodifier") + public void fieldTestWithModifier() { + ClassNode class1 = Helper.generateEmptyClass("FieldWithAccessModifier"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Comments Ignore Test") + public void commentsIgnoreTest() { + ClassNode class1 = Helper.generateEmptyClass("Comments"); + class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a")); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Constructor Parameter Test") + public void constructorParameterTest() { + BlockNode block = new BlockNode(); + block.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "ConstructorParameter", block); + constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); + constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b")); + + ClassNode class1 = new ClassNode("public", "ConstructorParameter"); + class1.addMember(constructor); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("This Dot Test") + public void thisDotTest() { + BlockNode block = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + ValueNode value = new ValueNode(EnumValueNode.INT_VALUE, "1"); + IExpressionNode expression = new UnaryNode(value); + + block.addStatement(new AssignNode(assignable, expression)); + block.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "ThisDot", block); + + ClassNode class1 = new ClassNode("public", "ThisDot"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + class1.addMember(constructor); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Constructor This Dot Test") + public void constructorThisDotTest() { + BlockNode block = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + IExpressionNode expression = new UnaryNode("a"); + + block.addStatement(new AssignNode(assignable, expression)); + block.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "ConstructorThisDot", block); + constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); + + ClassNode class1 = new ClassNode("public", "ConstructorThisDot"); + class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a")); + class1.addMember(constructor); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Void Methoden Test") + public void voidMethodenTest() { + ClassNode class1 = Helper.generateEmptyClass("VoidMethod"); + BlockNode block = new BlockNode(); + block.addStatement(new ReturnNode(null)); + class1.addMember(new MethodNode("public", null, true, "test", block)); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Constructor Method call Test") + public void constructorMethodCallTest() { + BlockNode blockCon = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + IExpressionNode expression = new UnaryNode(new MethodCallNode(null, "testMethod")); + + blockCon.addStatement(new AssignNode(assignable, expression)); + blockCon.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCall", blockCon); + + BlockNode blockMethod = new BlockNode(); + blockMethod.addStatement(new ReturnNode(new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "1")))); + MethodNode method = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod", blockMethod); + + ClassNode class1 = new ClassNode("public", "ConstructorMethodCall"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + class1.addMember(constructor); + class1.addMember(method); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Constructor Method call Parameters Test") + public void constructorMethodCallParametersTest() { + BlockNode blockCon = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + MethodCallNode methodCall = new MethodCallNode(null, "testMethod"); + methodCall.addExpression(new UnaryNode("a")); + IExpressionNode expression = new UnaryNode(methodCall); + + blockCon.addStatement(new AssignNode(assignable, expression)); + blockCon.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCallParameters", blockCon); + constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); + + BlockNode blockMethod = new BlockNode(); + blockMethod.addStatement(new ReturnNode(new UnaryNode("a"))); + MethodNode method = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod", blockMethod); + method.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); + + ClassNode class1 = new ClassNode("public", "ConstructorMethodCallParameters"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + class1.addMember(constructor); + class1.addMember(method); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Char Test") + public void charTest() { + BlockNode blockCon = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + MethodCallNode methodCall = new MethodCallNode(null, "testMethod"); + methodCall.addExpression(new UnaryNode("a")); + IExpressionNode expression = new UnaryNode(methodCall); + + blockCon.addStatement(new AssignNode(assignable, expression)); + blockCon.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "Char", blockCon); + constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a")); + + BlockNode blockMethod = new BlockNode(); + blockMethod.addStatement(new ReturnNode(new UnaryNode("a"))); + MethodNode method = new MethodNode("public", new BaseType(TypeEnum.CHAR), false, "testMethod", blockMethod); + method.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a")); + + ClassNode class1 = new ClassNode("public", "Char"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.CHAR), "a")); + class1.addMember(constructor); + class1.addMember(method); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Null Test") + public void nullTest() { + BlockNode blockCon = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + blockCon.addStatement(new AssignNode(assignable, new UnaryNode(new ValueNode(EnumValueNode.NULL_VALUE, "null")))); + blockCon.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "Null", blockCon); + + ClassNode class1 = new ClassNode("public", "Null"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + class1.addMember(constructor); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Self Reference Test") + public void selfReferenceTest() { + + } + + @Test + @DisplayName("Variable Compare Test") + public void variableCompareTest() { + + } + + @Test + @DisplayName("Variable Calculation Test") + public void variableCalculationTest() { + + } + + @Test + @DisplayName("Main Method Test") + public void mainMethodTest() { + + } + + @Test + @DisplayName("While Test") + public void whileTest() { + + } + + @Test + @DisplayName("Do While Test") + public void doWhileTest() { + + } + + @Test + @DisplayName("For Test") + public void forTest() { + + } + + @Test + @DisplayName("Increment Test") + public void incrementTest() { + ClassNode classNode = Helper.generateEmptyClass("Increment"); + classNode.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(classNode); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } } \ No newline at end of file diff --git a/src/test/resources/input/typedAstExceptionsTests/ClassNotDeclared.java b/src/test/resources/input/typedAstExceptionsTests/ClassNotDeclared.java deleted file mode 100644 index 6e2b81e..0000000 --- a/src/test/resources/input/typedAstExceptionsTests/ClassNotDeclared.java +++ /dev/null @@ -1,12 +0,0 @@ -// @expected: NotDeclaredException -public class Test { - - public House1 h; - - -} - -public class House { - - -}