Merge branch 'Tests' into johns-branch
Some checks are pending
Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run

This commit is contained in:
Bruder John 2024-06-27 08:35:07 +02:00
commit 576146c4fc
49 changed files with 850 additions and 456 deletions

1
.gitignore vendored
View File

@ -83,3 +83,4 @@ src/test/resources/output/javac/CompilerInput$Test.class
src/test/resources/output/javac/CompilerInput.class
src/test/resources/output/raupenpiler/CompilerInput.class
src/test/resources/output/raupenpiler/CompilerInput$Test.class
.idea/inspectionProfiles/Project_Default.xml

View File

@ -20,13 +20,11 @@ import java.nio.file.Paths;
* <p> <code> cd .\src\test\ </code>
* <p> <code> make clean compile-raupenpiler </code>
* <p> Start Raupenpiler using jar:
* <p> <code> java.exe -jar path_to_jar\JavaCompiler-1.0-SNAPSHOT-jar-with-dependencies.jar 'path_to_input_file.java' 'path_to_output_directory' </code>
* <p> <code> java.exe -jar path_to_jar\JavaCompiler-1.0-jar-with-dependencies.jar 'path_to_input_file.java' 'path_to_output_directory' </code>
* <p> Example (jar needs to be in the target directory, compile with make or mvn package first):
* <code> java.exe -jar .\target\JavaCompiler-1.0-SNAPSHOT-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' </code>
* <code> java.exe -jar .\target\JavaCompiler-1.0-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' </code>
*/
public class Main {
public static void main(String[] args) throws Exception {
if (args.length == 2) {
// args[0] is the input file path

View File

@ -16,18 +16,18 @@ import java.util.List;
import java.util.logging.*;
/**
Beispiel für Logging-Arten:
<p><code>logger.severe("Schwerwiegender Fehler");</code>
<p><code>logger.warning("Warnung");</code>
<p><code>logger.info("Information");</code>
<p><code>logger.config("Konfigurationshinweis");</code>
<p><code>logger.fine("Fein");</code>
<p><code>logger.finer("Feiner");</code>
<p><code>logger.finest("Am feinsten");</code>
<p>You may toggle the logging level of the console and file handlers by
changing the level ALL/OFF/etc. in the constructor.
<code>consoleHandler.setLevel(Level.OFF);</code>
<code>fileHandler.setLevel(Level.ALL);</code>
* Beispiel für Logging-Arten:
* <p><code>logger.severe("Schwerwiegender Fehler");</code>
* <p><code>logger.warning("Warnung");</code>
* <p><code>logger.info("Information");</code>
* <p><code>logger.config("Konfigurationshinweis");</code>
* <p><code>logger.fine("Fein");</code>
* <p><code>logger.finer("Feiner");</code>
* <p><code>logger.finest("Am feinsten");</code>
* <p>You may toggle the logging level of the console and file handlers by
* changing the level ALL/OFF/etc. in the constructor.
* <code>consoleHandler.setLevel(Level.OFF);</code>
* <code>fileHandler.setLevel(Level.ALL);</code>
*/
public class RaupenLogger {
@ -172,9 +172,9 @@ public class RaupenLogger {
}
String indentString = " ".repeat(indent * 2);
logger.info(indentString + abstractSyntaxTree.getClass());
//for (ASTNode child : abstractSyntaxTree.getChildren()) {
// logAST(child, indent + 1);
// }
// for (ASTNode child : node.) {
// printAST(child, indent + 1);
// }
}
}

View File

@ -1,7 +1,7 @@
package semantic;
import ast.type.type.*;
import semantic.exeptions.AlreadyDeclearedException;
import semantic.exceptions.AlreadyDeclaredException;
import java.util.HashMap;
import java.util.Stack;
@ -16,7 +16,7 @@ public class Scope {
public void addLocalVar(String name, ITypeNode type) {
if (this.contains(name)) {
throw new AlreadyDeclearedException("Variable " + name + " already exists in this scope");
throw new AlreadyDeclaredException("Variable " + name + " already exists in this scope");
}
localVars.peek().put(name, type);
}

View File

@ -24,7 +24,7 @@ import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
import ast.statements.*;
import ast.type.type.*;
import semantic.context.Context;
import semantic.exeptions.*;
import semantic.exceptions.*;
import typechecker.TypeCheckResult;
public class SemanticAnalyzer implements SemanticVisitor {
@ -116,7 +116,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
if (Objects.equals(otherMethod, methodNode))
break;
if (otherMethod.isSame(methodNode)) {
errors.add(new AlreadyDeclearedException(
errors.add(new AlreadyDeclaredException(
"Method " + methodNode.getIdentifier() + " is already defined in class "
+ currentClass.identifier));
valid = false;
@ -129,8 +129,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
valid = valid && result.isValid();
try {
currentScope.addLocalVar(parameter.identifier, parameter.type);
} catch (AlreadyDeclearedException e) {
errors.add(new AlreadyDeclearedException(parameter.identifier));
} catch (AlreadyDeclaredException e) {
errors.add(new AlreadyDeclaredException(parameter.identifier));
}
}
@ -167,7 +167,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
@Override
public TypeCheckResult analyze(FieldNode toCheck) {
if (currentFields.get(toCheck.identifier) != null) {
errors.add(new AlreadyDeclearedException("Already declared " + toCheck.identifier));
errors.add(new AlreadyDeclaredException("Already declared " + toCheck.identifier));
return new TypeCheckResult(false, null);
} else {
currentFields.put(toCheck.identifier, toCheck.type);
@ -401,7 +401,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
unary.setType(result.getType());
return result;
} else {
errors.add(new NotDeclearedException("Var is not Decleared"));
errors.add(new NotDeclaredException("Var is not Declared"));
}
return new TypeCheckResult(valid, null);
}

View File

@ -0,0 +1,9 @@
package semantic.exceptions;
public class AlreadyDeclaredException extends RuntimeException {
public AlreadyDeclaredException(String message) {
super(message);
}
}

View File

@ -1,4 +1,4 @@
package semantic.exeptions;
package semantic.exceptions;
public class AlreadyDefinedException extends RuntimeException {

View File

@ -1,4 +1,4 @@
package semantic.exeptions;
package semantic.exceptions;
public class MultipleReturnTypes extends RuntimeException {

View File

@ -0,0 +1,9 @@
package semantic.exceptions;
public class NotDeclaredException extends RuntimeException {
public NotDeclaredException(String message) {
super(message);
}
}

View File

@ -1,4 +1,4 @@
package semantic.exeptions;
package semantic.exceptions;
public class TypeMismatchException extends RuntimeException {

View File

@ -0,0 +1,9 @@
package semantic.exceptions;
public class UnknownException extends RuntimeException {
public UnknownException(String message) {
super(message);
}
}

View File

@ -1,9 +0,0 @@
package semantic.exeptions;
public class AlreadyDeclearedException extends RuntimeException {
public AlreadyDeclearedException(String message) {
super(message);
}
}

View File

@ -1,9 +0,0 @@
package semantic.exeptions;
public class NotDeclearedException extends RuntimeException {
public NotDeclearedException(String message) {
super(message);
}
}

View File

@ -1,9 +0,0 @@
package semantic.exeptions;
public class NotDefinedException extends RuntimeException {
public NotDefinedException(String message) {
super(message);
}
}

View File

@ -10,20 +10,33 @@ compile-javac:
compile-raupenpiler:
cd ../.. ; mvn -DskipTests install
cd ../.. ; mvn exec:java -Dexec.mainClass="main.Main" -Dexec.args="'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' "
cp ../main/resources/output/CompilerInput.class .java/resources/output/raupenpiler
test: test-javac test-raupenpiler
test: compile-javac compile-raupenpiler test-javac test-raupenpiler
test-javac:
#compile-javac
#java -cp .\resources\output\javac CompilerInput
# gleich wie bei raupenpiler, kann ich ohne funktionierenden Compiler nicht testen
test-raupenpiler:
#java -cp .\resources\output\raupenpiler CompilerInput
# move the compiled class to the test/main folder
mv ../main/resources/output/CompilerInput.class .java/main/
# compile the test class
javac .java/main.EndToEndTester.java
# run the test class
java .java/main.EndToEndTester
clean:
# clean output folders
rm -f ../main/resources/output/*.class
rm -f ./resources/output/javac/*.class
rm -f ./resources/output/raupenpiler/*.class
rm -f ./java/*.class
rm -f ../main/resources/output/*.class
# clean logs
rm -f ../main/resources/logs/*.log
# clean test/main folders from .class files for End-to-End tests
rm -f ./java/main/*.class
# clean javac output from featureTests
rm -f ./resources/input/featureTests/*.class

View File

@ -78,8 +78,8 @@ Compiled Classfile
wenn beides erfolgreich
- Ergebnis vom eigenen Compiler mithilfe von main.TestCompilerOutput ausführen
- (Ergebnis von javac mithilfe von main.TestCompilerOutput ausführen)
- Ergebnis vom eigenen Compiler mithilfe von main.EndToEndTester ausführen
- (Ergebnis von javac mithilfe von main.EndToEndTester ausführen)
### Andis Tipps:
@ -89,4 +89,5 @@ wenn beides erfolgreich
- mvn package
- javac tester // tester compilen
- java tester // tester ausführen
- -> tester ist in unserem Fall main.TestCompilerOutput.java
- -> tester ist in unserem Fall main.EndToEndTester.java
- -> Hab ich alles umgesetzt

View File

@ -1,6 +0,0 @@
package main;
public class EmptyClassExample {
private class Inner {
}
} // -o für outout

View File

@ -3,18 +3,18 @@ package main;
/**
* This class is used to test the output of the compiler.
*
* <p>Im gleichen Ordner wie diese Datei (main.TestCompilerOutput.java) muss die selbst kompilierte CompilerInput.class Datei sein.
* <br><strong>Hinweis:</strong> Diese muss man also vom Ordner <code> main/resources/output </code> in diesen Ordner hier (test/java) rein kopieren. (bis es eine bessere Lösung gibt)</p>
* <p>Im gleichen Ordner wie diese Datei (EndToEndTester.java) muss die selbst kompilierte CompilerInput.class Datei sein.
* <br><strong>Hinweis:</strong> Diese muss man also vom Ordner <code> main/resources/output </code> in diesen Ordner hier (test/java/main) rein kopieren. (bis es eine bessere Lösung gibt -> bin grad in der Make dran das alles hier automatisch zu machen)</p>
*
* <p>Die selbst kompilierte .class Datei wird dann hier drin geladen und eine Instanz von ihr erstellt, es können auch Methoden aufgerufen werden.
* <p>Diese main.TestCompilerOutput.java Datei wird dann in <code> \src\test\java> </code> mit <code>javac .\main.TestCompilerOutput.java</code> kompiliert und mit <code>java main.TestCompilerOutput</code> ausgeführt.
* <p>Diese EndToEndTester.java Datei wird dann in <code> \src\test\java> </code> mit <code>javac .\main.EndToEndTester.java</code> kompiliert und mit <code>java main.EndToEndTester</code> ausgeführt.
* Wenn unser Compiler funktioniert, sollten keine Errors kommen (sondern nur die Ausgaben, die wir in der CompilerInput.java Datei gemacht haben,
* oder Methoden, die wir hier aufrufen).</p>
*
* <p><strong>PROBLEM:</strong> Hier kommen Errors, was eigentlich heißt, dass der Compiler nicht funktioniert, der Test sollte eigentlich passen.
* <br><strong>DENN:</strong> Wenn ich statt unserem CompilerInput.class die CompilerInput.class von javac verwende (aus <code> src/test/resources/output/javac </code>), dann funktioniert es.</p>
*/
public class TestCompilerOutput {
public class EndToEndTester {
public static void main(String[] args) {
try {
// Try to load the class named "CompilerInput"

View File

@ -3,71 +3,45 @@ package main;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.junit.jupiter.api.Test;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
public class FailureTest {
private static final List<String> TEST_FILES = Arrays.asList(
"src/main/test/resources/input/failureTests/TestClass1.java",
"src/main/test/resources/input/failureTests/TestClass2.java",
"src/main/test/resources/input/failureTests/TestClass3.java",
"src/main/test/resources/input/failureTests/TestClass4.java",
"src/main/test/resources/input/failureTests/TestClass5.java",
"src/main/test/resources/input/failureTests/TestClass6.java",
"src/main/test/resources/input/failureTests/TestClass7.java",
"src/main/test/resources/input/failureTests/TestClass8.java",
"src/main/test/resources/input/failureTests/TestClass9.java",
"src/main/test/resources/input/failureTests/TestClass10.java",
"src/main/test/resources/input/failureTests/TestClass11.java"
);
/**
* This test method checks if invalid Java files fail to compile as expected.
* It uses the JavaCompiler from the ToolProvider to compile the files.
* The test passes if all the files fail to compile.
*/
@Test
public void invalidJavaFilesTest() {
public void areTestFilesActuallyFailTest() {
// Get the system Java compiler
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
// Assert that the compiler is available
assertNotNull(compiler, "Java Compiler is not available");
assertNotNull(javac, "Java Compiler is not available");
// Iterate over the test files
for (String fileName : TEST_FILES) {
// Create a File object for the current file
File file = new File(fileName);
String directoryPath = "src/test/resources/input/failureTests";
File folder = new File(directoryPath);
// Try to compile the file and get the result
// The run method returns 0 if the compilation was successful, and non-zero otherwise
int result = compiler.run(null, null, null, file.getPath());
if (folder.isDirectory()) {
File[] files = folder.listFiles((dir, name) -> name.endsWith(".java"));
// Assert that the compilation failed (i.e., the result is non-zero)
assertTrue(result != 0, "Expected compilation failure for " + fileName);
}
}
if (files != null) {
for (File file : files) {
// Try to compile the file and get the result
// The run method returns 0 if the compilation was successful, and non-zero otherwise
int result = javac.run(null, null, null, file.getPath());
// schmeißt John Fehler, wenn namen doppelt sind?
// Input: ParseTree mit genanntem Fehler
// Output: Fehlermeldung
@Test
void typedASTTest() throws IOException {
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/main/EmptyClassExample.java"));
Main.compileFile(codeCharStream, "src/main/test/resources/output");
} catch (IOException e) {
System.err.println("Error reading the file: " + e.getMessage());
// Assert that the compilation failed (i.e., the result is non-zero)
assertTrue(result != 0, "Expected compilation failure for " + file.getName());
}
} else {
System.out.println("No files found in the directory.");
}
} else {
System.out.println("The provided path is not a directory.");
}
}
}

View File

@ -0,0 +1,46 @@
package main;
import org.junit.jupiter.api.Test;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.File;
import static org.junit.jupiter.api.Assertions.*;
public class FeatureTest {
/**
* This test method checks if valid Java files compile successfully.
* It uses the JavaCompiler from the ToolProvider to compile the files.
* The test passes if all the files compile without errors.
*/
@Test
public void areTestFilesActuallyValid() {
// Get the system Java compiler
JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
// Assert that the compiler is available
assertNotNull(javac, "Java Compiler is not available");
String directoryPath = "src/test/resources/input/featureTests";
File folder = new File(directoryPath);
if (folder.isDirectory()) {
File[] files = folder.listFiles((dir, name) -> name.endsWith(".java"));
if (files != null) {
for (File file : files) {
// Try to compile the file and get the result
// The run method returns 0 if the compilation was successful, and non-zero otherwise
int result = javac.run(null, null, null, file.getPath());
// Assert that the compilation succeeded (i.e., the result is zero)
assertEquals(0, result, "Expected compilation success for " + file.getName());
}
} else {
System.out.println("No files found in the directory.");
}
} else {
System.out.println("The provided path is not a directory.");
}
}
}

View File

@ -7,14 +7,14 @@ import org.antlr.v4.runtime.CharStreams;
import java.io.IOException;
import java.nio.file.Paths;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* run: mvn test
* run every test: mvn test
* Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen
*/
public class MainTest {
@Test
void testEmptyClass() {
void test() {
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/CompilerInput.java"));

View File

@ -0,0 +1,103 @@
package parser;
import ast.ClassNode;
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 org.junit.jupiter.api.Test;
import parser.astBuilder.ASTBuilder;
import parser.generated.SimpleJavaLexer;
import parser.generated.SimpleJavaParser;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class AstBuilderTest {
@Test
public void astBuilderTest() {
// ---------------- Leere Klasse nachgebaut ----------------
ProgramNode expectedASTEmptyClass = new ProgramNode();
// public class Name {}
ClassNode nameClass = new ClassNode("public", "Name");
expectedASTEmptyClass.addClass(nameClass);
// ---------------- Leere Klasse erzeugt ----------------
// init
CharStream inputCharStream = CharStreams.fromString("public class Name {}");
SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
tokenStream.fill();
/* Parser -> Parsetree */
SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
ParseTree parseTreeEmptyClass = parser.program(); // parse the input
/* AST builder -> AST */
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode actualASTEmptyClass = (ProgramNode) new ASTBuilder().visit(parseTreeEmptyClass);
// ---------------- Vergleichen ----------------
String expectedASTasString = expectedASTEmptyClass.toString();
String actualASTasString = new ASTBuilder().visit(parseTreeEmptyClass).toString();
// Wie vergleiche ich das?
assertEquals(expectedASTasString, actualASTasString);
assertEquals(expectedASTEmptyClass, actualASTEmptyClass);
}
// ---------------- Alter CompilerInput nachgebaut ----------------
// ProgramNode startNode = new ProgramNode();
// public class CompilerInput {}
// ClassNode compilerInputClass = new ClassNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), "CompilerInput");
// public int a;
// compilerInputClass.addMember(new FieldNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), new BaseTypeNode(EnumTypeNode.INT), "a"));
// public static int testMethod(char x) { return 0; }
/* compilerInputClass.addMember(
new MethodNode(
new AccessTypeNode(EnumAccessTypeNode.PUBLIC),
new BaseTypeNode(EnumTypeNode.INT),
"testMethod",
new ParameterListNode(List.of(new ParameterNode(new BaseTypeNode(EnumTypeNode.CHAR), "x"))),
List.of(new ReturnStatementNode(new LiteralNode(0)))
));
ClassNode testClass = new ClassNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), "Test");
testClass.addMember(
new MethodNode(
new AccessTypeNode(EnumAccessTypeNode.PUBLIC),
new BaseTypeNode(EnumTypeNode.INT),
"testMethod",
new ParameterListNode(List.of(new ParameterNode(new BaseTypeNode(EnumTypeNode.CHAR), "x"), new ParameterNode(new BaseTypeNode(EnumTypeNode.INT), "a"))),
List.of(new ReturnStatementNode(new LiteralNode(0)))
)
);
*/
//compilerInputClass.addClass(testClass);
// startNode.addClass(compilerInputClass);
// startNode.addClass(testClass);
}

View File

@ -4,7 +4,6 @@ import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.tree.ParseTree;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import parser.astBuilder.ASTBuilder;
import parser.generated.SimpleJavaLexer;
import parser.generated.SimpleJavaParser;
@ -13,41 +12,13 @@ import static org.junit.jupiter.api.Assertions.*;
import java.util.*;
public class ParserTest {
/*
@BeforeEach
public void init() { // noch nicht benötigt
String inputFilePath = "src/main/resources/input/CompilerInput.java";
String outputDirectoryPath = "src/main/resources/output";
}
/**
* This test method is used to test the scanner functionality of the SimpleJavaLexer.
* It creates a CharStream from a string representing a simple Java class declaration,
* and uses the SimpleJavaLexer to tokenize this input.
* It then compares the actual tokens and their types produced by the lexer to the expected tokens and their types.
*/
@Test
public void scannerTest() {
// Create a CharStream from a string representing a simple Java class declaration
CharStream inputCharStream = CharStreams.fromString("public class Name {}");
// Use the SimpleJavaLexer to tokenize the input
SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
tokenStream.fill();
// Prepare the expected results
List<Token> actualTokens = tokenStream.getTokens();
List<String> expectedTokens = Arrays.asList("public", "class", "Name", "{", "}", "<EOF>");
List<String> expectedTokenTypes = Arrays.asList(null, null, "IDENTIFIER", null, null, "EOF");
// Compare the actual tokens and their types to the expected tokens and their types
assertEquals(expectedTokens.size(), actualTokens.size());
for (int i = 0; i < expectedTokens.size(); i++) {
assertEquals(expectedTokens.get(i), actualTokens.get(i).getText());
assertEquals(expectedTokenTypes.get(i), SimpleJavaLexer.VOCABULARY.getSymbolicName(actualTokens.get(i).getType()));
}
}
@Test
public void parserTest() {
@ -63,38 +34,20 @@ public class ParserTest {
ParseTree parseTree = parser.program(); // parse the input
//Variante 1 (geht)
String expectedParseTreeAsString = "(program (classDeclaration public class Name { }))";
String actualParseTreeAsString = parseTree.toStringTree(parser);
String expectedParseTreeAsString = "(program (classDeclaration (accessType public) class Name { }))";
assertEquals(actualParseTreeAsString, expectedParseTreeAsString);
assertEquals(expectedParseTreeAsString, actualParseTreeAsString);
//Variante 2 (geht nicht)
// Variante 2 (geht nicht)
// - Sollte es gehen und es liegt am Parser? (keine Ahnung) -> Bitte Fehler (actual und expected) durchlesen
Map<String, Object> actualTreeStructure = buildTreeStructure(parseTree, parser);
// ist die Methode parseStringToTree() korrekt? -> (glaub nicht)
Map<String, Object> expectedTreeStructure = parseStringToTree(expectedParseTreeAsString);
Map<String, Object> actualTreeStructure = buildTreeStructure(parseTree, parser);
assertEquals(actualTreeStructure, expectedTreeStructure);
// assertEquals(expectedTreeStructure, actualTreeStructure);
}
@Test
public void astBuilderTest() {
// TODO: Implement this test method
/* AST builder -> AST */
ASTBuilder astBuilder = new ASTBuilder();
// ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
//String actualASTasString = new ASTBuilder().visit(parseTree).toString();
// ProgramNode actualAST = new ASTBuilder().visit(parseTree);
// ProgramNode expectedAST = new ProgramNode();
// expectedAST.add(new ProgramNode.ClassNode("Name", new ProgramNode()));
}
// Helpers Variante 2.1
@ -146,7 +99,7 @@ public class ParserTest {
for (char ch : input.toCharArray()) {
if (ch == '(') {
if (depth == 0) {
if (currentToken.length() > 0) {
if (!currentToken.isEmpty()) {
node.put("node", currentToken.toString().trim());
currentToken.setLength(0);
}
@ -163,7 +116,7 @@ public class ParserTest {
currentToken.append(ch);
}
} else if (Character.isWhitespace(ch) && depth == 0) {
if (currentToken.length() > 0) {
if (!currentToken.isEmpty()) {
node.put("node", currentToken.toString().trim());
currentToken.setLength(0);
}
@ -172,7 +125,7 @@ public class ParserTest {
}
}
if (currentToken.length() > 0) {
if (!currentToken.isEmpty()) {
node.put("node", currentToken.toString().trim());
}

View File

@ -0,0 +1,45 @@
package parser;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.Token;
import org.junit.jupiter.api.Test;
import parser.generated.SimpleJavaLexer;
import java.util.Arrays;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class ScannerTest {
/**
* This test method is used to test the scanner functionality of the SimpleJavaLexer.
* It creates a CharStream from a string representing a simple Java class declaration,
* and uses the SimpleJavaLexer to tokenize this input.
* It then compares the actual tokens and their types produced by the lexer to the expected tokens and their types.
*/
@Test
public void scannerTest() {
// Create a CharStream from a string representing a simple Java class declaration
CharStream inputCharStream = CharStreams.fromString("public class Name {}");
// Use the SimpleJavaLexer to tokenize the input
SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
tokenStream.fill();
// Prepare the expected results
List<String> expectedTokens = Arrays.asList("public", "class", "Name", "{", "}", "<EOF>");
List<String> expectedTokenTypes = Arrays.asList("AccessModifier", "Class", "Identifier", "OpenCurlyBracket", "ClosedCurlyBracket", "EOF");
List<Token> actualTokens = tokenStream.getTokens();
// Compare the actual tokens and their types to the expected tokens and their types
assertEquals(expectedTokens.size(), actualTokens.size());
for (int i = 0; i < expectedTokens.size(); i++) {
assertEquals(expectedTokens.get(i), actualTokens.get(i).getText());
assertEquals(expectedTokenTypes.get(i), SimpleJavaLexer.VOCABULARY.getSymbolicName(actualTokens.get(i).getType()));
}
}
}

View File

@ -1,258 +0,0 @@
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 org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import parser.astBuilder.ASTBuilder;
import parser.generated.SimpleJavaLexer;
import parser.generated.SimpleJavaParser;
import semantic.exeptions.AlreadyDeclearedException;
import semantic.exeptions.MultipleReturnTypes;
import semantic.exeptions.NotDeclearedException;
import semantic.exeptions.TypeMismatchException;
import java.io.IOException;
import java.nio.file.Paths;
import static org.junit.jupiter.api.Assertions.*;
public class EndToTAST {
@BeforeEach
public void setup(){
SemanticAnalyzer.clearAnalyzer();
}
@Test
public void CorrectTest(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/CorrectTest.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(); // parse the input
/* ------------------------- AST builder -> AST ------------------------- */
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertEquals(0, SemanticAnalyzer.errors.size());
assertNotNull(tast);
}
@Test
public void notDecleared() {
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/NotDecleared.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(); // parse the input
/* ------------------------- AST builder -> AST ------------------------- */
ASTBuilder astBuilder = new ASTBuilder();
ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
assertFalse(SemanticAnalyzer.errors.isEmpty());
assertInstanceOf(NotDeclearedException.class, SemanticAnalyzer.errors.getFirst());
}
@Test
public void typeMismatch(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/TypeMismatchIntBool.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 parameterAlreadyDecleared(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/ParameterAlreadyDecleared.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(AlreadyDeclearedException.class, SemanticAnalyzer.errors.getFirst());
}
@Test
public void fieldAlreadyDecleared(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/FieldAlreadyDecleared.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(AlreadyDeclearedException.class, SemanticAnalyzer.errors.getFirst());
}
@Test
public void typeMismatchRefType(){
CharStream codeCharStream = null;
try {
codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/TypeMismatchRefType.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 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());
}
}

View File

@ -0,0 +1,218 @@
package semantic;
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 ast.ASTNode;
import ast.ProgramNode;
import parser.astBuilder.ASTBuilder;
import parser.generated.SimpleJavaLexer;
import parser.generated.SimpleJavaParser;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
public class EndToTypedAstTest {
private static final Map<String, Class<?>> exceptionMap = new HashMap<>();
@Test
public void exceptionsTest() {
String directoryPath = "src/test/resources/input/typedAstExceptionsTests";
File folder = new File(directoryPath);
try {
loadCustomExceptions();
System.out.println("Custom exceptions loaded successfully.");
} catch (Exception e) {
throw new RuntimeException("Failed to load custom exceptions", e);
}
if (folder.isDirectory()) {
File[] files = folder.listFiles((_, name) -> name.endsWith(".java"));
if (files != null) {
for (File file : files) {
String expectedException = extractExpectedException(file);
SemanticAnalyzer.clearAnalyzer();
CharStream codeCharStream;
try {
codeCharStream = CharStreams.fromPath(Paths.get(file.getPath()));
} 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 typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
if (expectedException != null) {
System.out.println("Testing the file: " + file.getName());
assertFalse(SemanticAnalyzer.errors.isEmpty(), "Expected an exception, but none was found.");
assertInstanceOf(getExceptionClass(expectedException), SemanticAnalyzer.errors.getFirst());
} else {
System.out.println("No expected exception specified.");
// If no expected exception is specified, you might want to add a different check
// e.g., assertTrue(SemanticAnalyzer.errors.isEmpty(), "No exceptions expected, but some were found.");
}
}
} else {
System.out.println("No files found in the directory.");
}
} else {
System.out.println("The provided path is not a directory.");
}
}
@Test
public void featureTest(){
String directoryPath = "src/test/resources/input/typedAstFeaturesTests";
File folder = new File(directoryPath);
if (folder.isDirectory()) {
File[] files = folder.listFiles((_, name) -> name.endsWith(".java"));
if (files != null) {
for (File file : files) {
SemanticAnalyzer.clearAnalyzer();
CharStream codeCharStream;
try {
codeCharStream = CharStreams.fromPath(Paths.get(file.getPath()));
} 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 typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
System.out.println("Testing the file: " + file.getName());
assertTrue(SemanticAnalyzer.errors.isEmpty());
assertNotNull(typedAst);
}
} else {
System.out.println("No files found in the directory.");
}
} else {
System.out.println("The provided path is not a directory.");
}
}
// ------------------ Helpers ------------------
/**
* This method is used to extract the expected exception from a given file.
* It reads the file line by line and uses a regular expression to match the expected exception annotation.
* The expected exception annotation should be in the format: "// @expected: ExceptionName".
* If the expected exception annotation is found, it returns the name of the expected exception.
* If the expected exception annotation is not found, it returns null.
*
* @param file The file from which the expected exception is to be extracted.
* @return The name of the expected exception, or null if the expected exception annotation is not found.
*/
private String extractExpectedException(File file) {
String annotationPattern = "//\\s*@expected:\\s*(\\S+)";
Pattern pattern = Pattern.compile(annotationPattern);
try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
String line;
while ((line = reader.readLine()) != null) {
Matcher matcher = pattern.matcher(line);
if (matcher.find()) {
return matcher.group(1);
}
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* This method is used to retrieve the Class object associated with a given exception name.
* It first prints the original exception name, then appends the package name to the exception name and prints it.
* It then retrieves the Class object from the exceptionMap using the fully qualified exception name.
* If the Class object is not found in the exceptionMap, it throws a RuntimeException.
*
* @param exceptionName The name of the exception for which the Class object is to be retrieved.
* @return The Class object associated with the given exception name.
* @throws RuntimeException If the Class object for the given exception name is not found in the exceptionMap.
*/
private Class<?> getExceptionClass(String exceptionName) {
System.out.println(exceptionName);
exceptionName = "semantic.exceptions." + exceptionName;
System.out.println(exceptionName);
Class<?> exceptionClass = exceptionMap.get(exceptionName);
if (exceptionClass == null) {
throw new RuntimeException("Exception class not found: " + exceptionName);
}
return exceptionClass;
}
/**
* This method is used to load custom exceptions from a specified package.
* It first constructs the directory path from the package name and checks if the directory exists.
* If the directory does not exist, it throws an IllegalArgumentException.
* It then creates a URLClassLoader to load the classes from the directory.
* It iterates over all the files in the directory, and for each file, it constructs the class name and loads the class.
* If the loaded class is a subtype of Throwable, it adds the class to the exceptionMap.
*
* @throws Exception If any error occurs during class loading.
*/
private static void loadCustomExceptions() throws Exception {
final String packName = "semantic.exceptions";
final String dirForMyClasses = "src/main/java/%s".formatted(packName.replace(".", "/"));
File folder = new File(dirForMyClasses);
if (!folder.isDirectory()) {
throw new IllegalArgumentException("The provided path is not a directory.");
}
URL[] urls = {folder.toURI().toURL()};
URLClassLoader classLoader;
try {
classLoader = new URLClassLoader(urls);
} catch (Exception e) {
throw new RuntimeException("Failed to create class loader", e);
}
for (File file : Objects.requireNonNull(folder.listFiles())) {
String className = packName + "." + file.getName().replaceAll("\\.(?:class|java)$", "");
System.out.printf("Loading custom exception: %s (=> %s)", file.getName(), className);
Class<?> cls = classLoader.loadClass(className);
if (Throwable.class.isAssignableFrom(cls)) { // Check if the class is a subtype of Throwable
exceptionMap.put(className, cls);
System.out.println("Loaded custom exception: " + className);
}
}
}
}

View File

@ -0,0 +1,101 @@
package semantic;
public class SemanticTest {
// @Test
// public void alreadyDeclaredLocalFieldVar() {
// ProgramNode programNode = new ProgramNode();
// List<ClassNode> classList = new ArrayList<>();
// AccessTypeNode accessTypeNode = new AccessTypeNode(EnumAccessTypeNode.PUBLIC);
// ClassNode classNode = new ClassNode(accessTypeNode, "testClass");
//
// SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
// ASTNode tast = semanticAnalyzer.generateTast(ast);
//
// MemberNode memberNode2 = new FieldNode(accessTypeNode, new BaseTypeNode(EnumTypeNode.INT), "testVar");
// classNode.members.add(memberNode2);
//
// classList.add(classNode);
// programNode.classes = classList;
//
// ASTNode typedAst = SemanticAnalyzer.generateTast(programNode);
//
// assertEquals(1, SemanticAnalyzer.errors.size());
// assertInstanceOf(AlreadyDeclaredException.class, SemanticAnalyzer.errors.getFirst());
// assertNull(typedAst);
// }
//
// @Test
// public void shouldWorkWithNoError() {
// ProgramNode programNode = new ProgramNode();
// List<ClassNode> classList = new ArrayList<>();
// AccessTypeNode accessTypeNode = new AccessTypeNode(EnumAccessTypeNode.PUBLIC);
// ClassNode classNode = new ClassNode(accessTypeNode, "testClass");
//
// SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
// ASTNode tast = semanticAnalyzer.generateTast(ast);
//
// assertEquals(semanticAnalyzer.errors.size(), 0);
// assertNotNull(tast);
//
// MemberNode memberNode3 = getMemberNode(accessTypeNode);
// classNode.members.add(memberNode3);
//
// classList.add(classNode);
// programNode.classes = classList;
//
// ASTNode typedAst = SemanticAnalyzer.generateTast(programNode);
//
// assertEquals(0, SemanticAnalyzer.errors.size());
// assertEquals(programNode, typedAst);
// }
//
// /**
// * This method is used to create a MemberNode representing a method.
// * It first creates a list of ParameterNodes and adds a ParameterNode to it.
// * Then, it creates a ParameterListNode using the list of ParameterNodes.
// * After that, it creates a list of StatementNodes and adds a StatementNode to it by calling the getStatementNode method.
// * Finally, it creates a MethodNode using the provided AccessTypeNode, a BaseTypeNode representing the return type of the method,
// * the method name, the ParameterListNode, and the list of StatementNodes, and returns this MethodNode.
// *
// * @param accessTypeNode The AccessTypeNode representing the access type of the method.
// * @return The created MemberNode representing the method.
// */
//private static MemberNode getMemberNode(AccessTypeNode accessTypeNode) {
// List<ParameterNode> parameterNodeList = new ArrayList<>();
// ParameterNode parameterNode1 = new ParameterNode(new BaseTypeNode(EnumTypeNode.INT), "param1");
// parameterNodeList.add(parameterNode1);
// ParameterListNode parameterListNode = new ParameterListNode(parameterNodeList);
//
// List<StatementNode> statementNodeList = new ArrayList<>();
//
// StatementNode statementNode1 = getStatementNode();
// statementNodeList.add(statementNode1);
//
// return new MethodNode(accessTypeNode, new BaseTypeNode(EnumTypeNode.INT), "testVar2", parameterListNode, statementNodeList);
//}
//
// /**
// * This method is used to create a StatementNode for an assignment operation.
// * It first creates two IdentifierExpressionNodes for 'this' and 'objectVar'.
// * Then, it creates a BinaryExpressionNode to represent the operation 'this.objectVar'.
// * After that, it creates a LiteralNode to represent the integer value 1.
// * Finally, it creates another BinaryExpressionNode to represent the assignment operation 'this.objectVar = 1',
// * and wraps this expression in an AssignmentStatementNode.
// *
// * @return The created AssignmentStatementNode representing the assignment operation 'this.objectVar = 1'.
// */
//private static StatementNode getStatementNode() {
// ExpressionNode expressionNodeObjectVariableLeft = new IdentifierExpressionNode("this");
// ExpressionNode expressionNodeObjectVariableRight = new IdentifierExpressionNode("objectVar");
//
// ExpressionNode expressionNodeLeft = new BinaryExpressionNode(expressionNodeObjectVariableLeft, expressionNodeObjectVariableRight, ExpresssionOperator.DOT);
//
// ExpressionNode expressionNodeRight = new LiteralNode(1);
//
// BinaryExpressionNode expressionNode = new BinaryExpressionNode(expressionNodeLeft, expressionNodeRight, ExpresssionOperator.ASSIGNMENT);
//
// return new AssignmentStatementNode(expressionNode);
//}
}

View File

@ -1,5 +1,3 @@
package resources;
public class AllFeaturesClassExample {
int a;
boolean b;

View File

@ -1,5 +1,3 @@
package resources;
public class CombinedExample {
int number;
boolean flag;

View File

@ -1,5 +1,3 @@
package resources;
public class MoreFeaturesClassExample {
int hallo;
private class Inner {

View File

@ -1,5 +1,3 @@
package resources.featureTests;
public class BooleanOperations {
boolean flag;

View File

@ -1,5 +1,3 @@
package resources.featureTests;
public class CharManipulation {
char letter;

View File

@ -1,5 +1,3 @@
package resources.featureTests;
public class ConditionalStatements {
int number;

View File

@ -0,0 +1,2 @@
public class EmptyClassExample {
}

View File

@ -1,5 +1,3 @@
package resources.featureTests;
public class LoopExamples {
public static void main(String[] args) {
// For loop example

View File

@ -1,5 +1,3 @@
package resources.featureTests;
public class MethodOverloading {
public int add(int a, int b) {
return a + b;

View File

@ -1,3 +1,4 @@
// @expected: AlreadyDeclaredException
public class Example {
public int a;

View File

@ -1,3 +1,4 @@
// @expected: MultipleReturnTypes
public class Example {
public static int testMethod(int x, char c){

View File

@ -1,3 +1,4 @@
// @expected: NotDeclaredException
public class Test {
public static int testMethod(int x){
int a = b;

View File

@ -1,3 +1,4 @@
// @expected: AlreadyDeclaredException
public class Example {
public static int testMethod(char a, int a){

View File

@ -1,3 +1,4 @@
// @expected: TypeMismatchException
public class Example {
public static int testMethod(char x){

View File

@ -1,3 +1,4 @@
// @expected: TypeMismatchException
public class Test {
public boolean b;

View File

@ -1,3 +1,4 @@
// @expected: TypeMismatchException
public class Test {
public static int testMethod(ExampleA exampleA, ExampleB exampleB){

View File

@ -0,0 +1,8 @@
// @expected: TypeMismatchException
public class Example {
public static void testMethod(int x){
}
}

View File

@ -0,0 +1,70 @@
{
"classes": [
{
"identifier": "testClass1",
"accessType": {
"enumAccessTypeNode": "PUBLIC"
},
"members": [
{
"@type": "Field",
"accessTypeNode": {
"enumAccessTypeNode": "PUBLIC"
},
"type": {
"@type": "Base",
"enumType": "INT"
},
"identifier": "testVar1"
},
{
"@type": "Method",
"visibility": {
"enumAccessTypeNode": "PUBLIC"
},
"type": {
"@type": "Base",
"enumType": "INT"
},
"identifier": "testMethod",
"parameters": {
"parameters": [
{
"type": {
"@type": "Base",
"enumType": "INT"
},
"identifier": "param1"
}
]
},
"statements": [
{
"@type": "Assignment",
"expressionLeft": {
"@type": "InstVar",
"identifier": "testVar1",
"expression": {
"@type": "This",
"type": {
"@type": "Reference",
"identifier": "testClass1"
}
},
"type": null
},
"expressionRight": {
"@type": "Literal",
"type": {
"@type": "Base",
"enumType": "INT"
}
}
}
]
}
],
"hasConstructor": false
}
]
}

View File

@ -0,0 +1,133 @@
{
"classes": [
{
"identifier": "testClass1",
"accessType": {
"enumAccessTypeNode": "PUBLIC"
},
"members": [
{
"@type": "Field",
"accessTypeNode": {
"enumAccessTypeNode": "PUBLIC"
},
"type": {
"@type": "Base",
"enumType": "INT"
},
"identifier": "testVar1"
},
{
"@type": "Method",
"visibility": {
"enumAccessTypeNode": "PUBLIC"
},
"type": {
"@type": "Base",
"enumType": "INT"
},
"identifier": "testMethod",
"parameters": {
"parameters": [
{
"type": {
"@type": "Base",
"enumType": "INT"
},
"identifier": "param1"
}
]
},
"statements": [
{
"@type": "Assignment",
"expressionLeft": {
"@type": "InstVar",
"identifier": "testVar1",
"expression": {
"@type": "This",
"type": {
"@type": "Reference",
"identifier": "testClass1"
}
},
"type": null
},
"expressionRight": {
"@type": "Literal",
"type": {
"@type": "Base",
"enumType": "BOOLEAN"
}
}
}
]
}
],
"hasConstructor": false,
"methods": [
{
"@type": "Method",
"visibility": {
"enumAccessTypeNode": "PUBLIC"
},
"type": {
"@type": "Base",
"enumType": "INT"
},
"identifier": "testMethod",
"parameters": {
"parameters": [
{
"type": {
"@type": "Base",
"enumType": "INT"
},
"identifier": "param1"
}
]
},
"statements": [
{
"@type": "Assignment",
"expressionLeft": {
"@type": "InstVar",
"identifier": "testVar",
"expression": {
"@type": "InstVar",
"identifier": "testVar",
"expression": {
"@type": "This",
"type": {
"@type": "Reference",
"identifier": "testClass2"
}
},
"type": null
},
"type": null
},
"expressionRight": {
"@type": "Literal",
"type": null
},
"type": null
},
{
"@type": "VariableDeclaration",
"type": {
"@type": "Base",
"enumType": "CHAR"
},
"identifier": "objectVar",
"expression": {
"@type": "Literal",
"type": null
}
}
]
}
]
}
]
}

View File

@ -0,0 +1 @@
{"classes":[{"identifier":"testClass","accessType":{"enumAccessTypeNode":"PUBLIC"},"members":[{"@type":"Field","accessTypeNode":{"enumAccessTypeNode":"PUBLIC"},"type":{"@type":"Base","enumType":"INT"},"identifier":"testVar1"},{"@type":"Field","accessTypeNode":{"enumAccessTypeNode":"PUBLIC"},"type":{"@type":"Base","enumType":"INT"},"identifier":"objectVar"},{"@type":"Method","visibility":{"enumAccessTypeNode":"PUBLIC"},"type":{"@type":"Base","enumType":"INT"},"identifier":"testVar2","parameters":{"parameters":[{"type":{"@type":"Base","enumType":"INT"},"identifier":"param1"}]},"statements":[{"@type":"Assignment","expressionLeft":{"@type":"InstVar","identifier":"objectVar","expression":{"@type":"This","type":{"@type":"Reference","identifier":"testClass"}},"type":null},"expressionRight":{"@type":"Literal","type":{"@type":"Base","enumType":"INT"}}}]}],"hasConstructor":false,"methods":[{"@type":"Method","visibility":{"enumAccessTypeNode":"PUBLIC"},"type":{"@type":"Base","enumType":"INT"},"identifier":"testVar2","parameters":{"parameters":[{"type":{"@type":"Base","enumType":"INT"},"identifier":"param1"}]},"statements":[{"@type":"Assignment","expressionLeft":{"@type":"InstVar","identifier":"objectVar","expression":{"@type":"This","type":{"@type":"Reference","identifier":"testClass"}},"type":null},"expressionRight":{"@type":"Literal","type":{"@type":"Base","enumType":"INT"}}}]}]}]}