SemanticAnalyzer Fail Tests

src/test/java/semantic/EndToTypedAstTest.java

@@ -26,6 +26,10 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import org.junit.jupiter.api.Test;
+import semantic.exceptions.AlreadyDeclaredException;
+import semantic.exceptions.MultipleReturnTypes;
+import semantic.exceptions.NotDeclaredException;
+import semantic.exceptions.TypeMismatchException;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -152,6 +156,130 @@ public class EndToTypedAstTest {
         }
     }
 
+    /*
+    @Test
+    public void notDeclared() {
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/johnsTests/NotDeclared.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof NotDeclaredException));
+    }*/
+
+    @Test
+    public void typeMismatchTest() {
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/johnsTests/TypeMismatchIntBool.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof TypeMismatchException));
+    }
+
+    @Test
+    public void parameterAlreadyDecleared() {
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/johnsTests/ParameterAlreadyDecleared.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof AlreadyDeclaredException));
+    }
+
+    @Test
+    public void fieldAlreadyDecleared(){
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/johnsTests/FieldAlreadyDecleared.java");
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof AlreadyDeclaredException));
+
+    }
+
+    @Test
+    public void typeMismatchRefType(){
+        ASTNode tast = SemanticHelper.generateTypedASTFrom("src/test/resources/input/johnsTests/TypeMismatchRefType.java");
+
+        SemanticAnalyzer.generateTast(tast);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertTrue(SemanticAnalyzer.errors.stream().anyMatch(c -> c instanceof TypeMismatchException));
+    }
+
+    @Test
+    public void correctRetType(){
+
+        CharStream codeCharStream = null;
+        try {
+            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/CorrectRetType.java"));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTree = parser.program();
+
+        ASTBuilder astBuilder = new ASTBuilder();
+        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
+
+        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+
+    }
+
+    @Test
+    public void retTypeMismatch(){
+
+        CharStream codeCharStream = null;
+        try {
+            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/retTypeMismatch.java"));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTree = parser.program();
+
+        ASTBuilder astBuilder = new ASTBuilder();
+        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
+
+        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
+
+    }
+
+    @Test
+    public void multipleRetType(){
+
+        CharStream codeCharStream = null;
+        try {
+            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/MultipleRetTypes.java"));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTree = parser.program();
+
+        ASTBuilder astBuilder = new ASTBuilder();
+        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
+
+        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+
+        assertFalse(SemanticAnalyzer.errors.isEmpty());
+        assertInstanceOf(MultipleReturnTypes.class, SemanticAnalyzer.errors.getFirst());
+
+    }
 
     // ------------------ Helpers ------------------
 

src/test/java/semantic/SemanticHelper.java

@@ -0,0 +1,32 @@
+package semantic;
+
+import ast.ASTNode;
+import ast.ProgramNode;
+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 parser.astBuilder.ASTBuilder;
+import parser.generated.SimpleJavaLexer;
+import parser.generated.SimpleJavaParser;
+
+import java.io.IOException;
+
+public class SemanticHelper {
+    public static ASTNode generateTypedASTFrom(String filePath) {
+        CharStream testFile = null;
+        try {
+            testFile = CharStreams.fromFileName(filePath);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        SimpleJavaLexer lexer = new SimpleJavaLexer(testFile);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+        tokenStream.fill();
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTree = parser.program();
+        ASTBuilder astBuilder = new ASTBuilder();
+
+        return (ProgramNode) astBuilder.visit(parseTree);
+    }
+}

src/test/resources/input/johnsTests/FieldAlreadyDecleared.java

@@ -0,0 +1,4 @@
+public class FieldAlreadyDecleared {
+    public int a;
+    public int a;
+}

src/test/resources/input/johnsTests/NotDeclared.java

@@ -0,0 +1,5 @@
+public class NotDeclared {
+    public void Method() {
+        i = 10;
+    }
+}

src/test/resources/input/johnsTests/ParameterAlreadyDecleared.java

@@ -0,0 +1,3 @@
+public class ParameterAlreadyDecleared {
+    public void Method(int a, int a) {}
+}

src/test/resources/input/johnsTests/TypeMismatchIntBool.java

@@ -0,0 +1,6 @@
+public class TypeMismatchIntBool {
+    public void Method() {
+        int intVariable;
+        intVariable = true;
+    }
+}

src/test/resources/input/johnsTests/TypeMismatchRefType.java

@@ -0,0 +1,13 @@
+public class TypeMismatchRefType {
+    public static int Methode(Class1 class1, Class2 class2){
+        class1 = class2;
+    }
+}
+
+public class Class1{
+    public int a;
+}
+
+public class Class2{
+    public boolean a;
+}

src/test/resources/input/typedAstFeatureTests/CorrectTest.java

@@ -1,7 +1,13 @@
+public class Klasse1 {
+    public int test;
 
-    public class Run {
+    public int test1() {
-        public static void main(String[] args) {
+        test = 5;
-//            Test t = new Test();
+        return 1;
-//            System.out.println(t.test());
-        }
     }
+
+    public void test2() {
+        int testInt;
+        testInt = this.test1();
+    }
+}