Compare commits

..

5 Commits

Author SHA1 Message Date
KingJulian
a2fa6f55d4 Merge branch 'master' of https://gitea.hb.dhbw-stuttgart.de/i22022/NichtHaskell 2024-07-05 12:36:49 +02:00
KingJulian
8d4e8a9269 Moved DivTest 2024-07-05 12:36:10 +02:00
KingJulian
ec400479bb Merge branch 'master' of https://gitea.hb.dhbw-stuttgart.de/i22022/NichtHaskell 2024-07-05 12:29:41 +02:00
KingJulian
0593d988b4 Merge branch 'master' of https://gitea.hb.dhbw-stuttgart.de/i22022/NichtHaskell 2024-07-05 11:31:54 +02:00
KingJulian
8e55eaca93 Test update 2024-07-05 11:31:25 +02:00
19 changed files with 666 additions and 246 deletions

View File

@ -1,166 +0,0 @@
Grammatik:
1. Ausdrücke
Primary:
Literal
Variable
IncDecExpression
( Expression )
MethodInvocation
Variable:
Identifier { [ Expression ] }
Identifier:
[ Identifier . ] Name
IncDecExpression:
Variable IncDec
IncDec Variable
IncDec:
++ | --
Expression:
UnaryExpression
BinaryExpression
AssignmentExpression
MethodInvocation
CreationExpression
UnaryExpression:
Primary
UnaryExpression
UnaryOperator
+ | - | ! | ...
BinaryExpression:
Expression BinaryOperator Expression
BinaryOperator:
== | + | - | * | / | & | && | | | || |
AssignmentExpression:
Variable = Expression
MethodInvocation:
Method ( [ ActualArguments ] )
Method:
Identifier
ActualArguments:
Expression { , Expression }
CreationExpression:
new ClassIdentifier ( [ ActualArguments ] )
2. Anweisungen
Statement:
SimpleStatement
CompositeStatement
Label : Statement
SimpleStatement:
EmptyStatement
StatementExpression
EmptyStatement ;
ReturnStatement
StatementExpression:
AssignmentExpression
IncDecExpression
MethodInvocation
CreationExpression
ContinueStatement:
continue [ Name ] ;
ReturnStatement.
return [ Expression ] ;
CompositeStatement:
Block
CaseStatement
Block:
"{" { VariableDeclaration | Statement } "}"
VariableDeclaration:
Type VariableDeclarator ;
VariableDeclarator:
Name [ = Expression ]
Type:
Name # konkrete Typen hinzufügen
Identifier
CaseStatement: # Andere CaseStatements heraussuchen. Assign, MethodCall,
ConditionalStatement
WhileStatement
ConditionalStatement:
if ( Expression ) Statement [ else Statement ]
ConstantExpression:
Expression
WhileStatement:
while ( Expression ) Statement
Initialization:
StatementExpression { , StatementExpression }
VariableDeclaration
3. Methoden
MethodDeclaration:
MethodHeader Block
MethodHeader:
{ Modifier } ResultType MethodDeclarator
Modifier:
public | static | ...
ResultType:
Type | void
MethodDeclarator:
Identifier "(" [ FormalArguments ] ")"
FormalArguments:
FormalArgument { , FormalArgument }
FormalArgument:
Type Name
4. Klassen
Start:
ClassDeclaration {ClassDeclaration}
ClassDeclaration:
[ public ] class Name ClassBody
ClassBody:
"{" { { Modifier } Declaration } "}"
Declaration:
VariableDeclaration
MethodDeclaration
ConstructorDeclaration
ConstructorDeclaration:
[ public ] Name ( [ FormalArguments ] ) Block

View File

@ -1,11 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<module version="4">
<component name="AdditionalModuleElements">
<content url="file://$MODULE_DIR$" dumb="true">
<sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
<sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
<sourceFolder url="file://$MODULE_DIR$/src/test/resources" type="java-test-resource" />
<excludeFolder url="file://$MODULE_DIR$/target" />
</content>
</component>
</module>

View File

@ -138,7 +138,7 @@ public class BlockStatement extends AbstractType implements IStatement {
&& Objects.equals(statements, blockStatement.statements
/*&& (Objects.equals(localVars, blockStatement.localVars)*/
);
System.out.println("In ParameterList: " + result);
System.out.println("In BlockStatement: " + result);
return result;
}

View File

@ -70,7 +70,7 @@ public class ReturnStatement extends AbstractType implements IStatement{
boolean result = (Objects.equals(expression, returnStatement.expression)
&& Objects.equals(expression.getTypeCheckResult(), returnStatement.expression.getTypeCheckResult())
);
System.out.println("In PrintStatement: " + result);
System.out.println("In ReturnStatement: " + result);
return result;
}

View File

@ -12,12 +12,47 @@ public class testAll {
}
@Test
public void testAssignWrongType(){
Program ast = AssignWrongTypeAST.getProgram();
String pathToCode = "failTests/AssignWrongType.java";
testAst(ast, pathToCode);
}
@Test
public void testCharArgument(){
Program ast = CharArgumentAST.getProgram();
String pathToCode = "SimpleTests/CharArgument.java";
testAst(ast, pathToCode);
}
@Test
public void testClassWithMain(){
Program ast = ClassWithMainAST.getProgram();
String pathToCode = "basicClasses/classWithMain.java";
testAst(ast, pathToCode);
}
@Test
public void testConstructorThisDot(){
Program ast = ConstructorThisDotAST.getProgram();
String pathToCode = "SimpleTests/ConstructorThisDot.java";
testAst(ast, pathToCode);
}
@Test
public void testConstructorParams(){
Program ast = ConstructorParamsAST.getProgram();
String pathToCode = "SimpleTests/ConstructorParams.java";
testAst(ast, pathToCode);
}
@Test
public void testDivideByZero(){
Program ast = DivideByZeroAST.getProgram();
String pathToCode = "failTests/DivideByzero.java";
testAst(ast, pathToCode);
}
@Test
public void testEmptyClass(){
Program ast = emptyClassAST.getEmptyProgramm();
@ -40,24 +75,16 @@ public class testAll {
}
@Test
public void testAssignWrongType(){
Program ast = AssignWrongTypeAST.getProgram();
String pathToCode = "failTests/AssignWrongType.java";
testAst(ast, pathToCode);
}
@Test
public void testDivideByZero(){
Program ast = DivideByZeroAST.getProgram();
String pathToCode = "failTests/DivideByzero.java";
public void testFieldVariable(){
Program ast = FieldVarAST.getProgram();
String pathToCode = "SimpleTests/FieldVar.java";
testAst(ast, pathToCode);
}
@Test
public void testcharArgument(){
Program ast = CharArgumentAST.getProgram();
String pathToCode = "SimpleTests/CharArgument.java";
public void testIfElseIfStatementWithOneReturne(){
Program ast = IfElseIfStatementWithOneReturnAST.getProgram();
String pathToCode = "SimpleTests/IfElseIfStatementWithOneReturn.java";
testAst(ast, pathToCode);
}

View File

@ -0,0 +1,45 @@
package ASTs;
import abstractSyntaxTree.Class.FieldDecl;
import abstractSyntaxTree.Class.MethodDecl;
import abstractSyntaxTree.Class.RefType;
import abstractSyntaxTree.Parameter.Parameter;
import abstractSyntaxTree.Parameter.ParameterList;
import abstractSyntaxTree.Program;
import abstractSyntaxTree.Statement.BlockStatement;
import java.util.ArrayList;
import java.util.List;
public class ConstructorParamsAST {
public static Program getProgram() {
List<RefType> refTypeList = new ArrayList<>();
refTypeList.add(getRefType());
Program program = new Program(refTypeList);
return program;
}
public static RefType getRefType() {
List<FieldDecl> fieldDeclList = new ArrayList<>();
List<MethodDecl> methodDeclList = new ArrayList<>();
methodDeclList.add(method0());
RefType refType = new RefType("ConstructorParams", fieldDeclList, methodDeclList, false);
return refType;
}
public static MethodDecl method0() {
Parameter parameter0 = new Parameter("int", "i");
List<Parameter> parameterList = new ArrayList<>();
parameterList.add(parameter0);
ParameterList parameterListObj = new ParameterList(parameterList);
BlockStatement blockStatement = new BlockStatement(new ArrayList<>(), null);
MethodDecl methodDecl = new MethodDecl("ConstructorParams", null, "ConstructorParams",
parameterListObj, blockStatement);
return methodDecl;
}
}

View File

@ -0,0 +1,59 @@
package ASTs;
import Typecheck.TypingHelper;
import abstractSyntaxTree.Class.FieldDecl;
import abstractSyntaxTree.Class.MethodDecl;
import abstractSyntaxTree.Class.RefType;
import abstractSyntaxTree.Parameter.Parameter;
import abstractSyntaxTree.Parameter.ParameterList;
import abstractSyntaxTree.Program;
import abstractSyntaxTree.Statement.BlockStatement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class ConstructorParamsASTTyped {
public static Program getProgram() {
List<RefType> refTypeList = new ArrayList<>();
refTypeList.add(getRefType());
Program program = new Program(refTypeList);
addTyping(program);
return program;
}
public static RefType getRefType() {
List<FieldDecl> fieldDeclList = new ArrayList<>();
List<MethodDecl> methodDeclList = new ArrayList<>();
methodDeclList.add(method0());
RefType refType = new RefType("ConstructorParams", fieldDeclList, methodDeclList, false);
return refType;
}
public static MethodDecl method0() {
Parameter parameter0 = new Parameter("int", "i");
List<Parameter> parameterList = new ArrayList<>();
parameterList.add(parameter0);
ParameterList parameterListObj = new ParameterList(parameterList);
BlockStatement blockStatement = new BlockStatement(new ArrayList<>(), "void");
MethodDecl methodDecl = new MethodDecl("ConstructorParams", null, "ConstructorParams",
parameterListObj, blockStatement);
return methodDecl;
}
public static void addTyping(Program program){
// TypeContext
TypingHelper.addTypeContext(program, "ConstructorParams", new HashMap<>());
// MethodContext
HashMap<String, ParameterList> method0 = new HashMap<>();
//method0.put("void", new ParameterList(new ArrayList<>()));
HashMap<String, HashMap<String, ParameterList>> methods = new HashMap<>();
//methods.put("main", method0);
TypingHelper.addMethodContext(program, "ConstructorParams", methods);
}
}

View File

@ -0,0 +1,60 @@
package ASTs;
import abstractSyntaxTree.Class.FieldDecl;
import abstractSyntaxTree.Class.MethodDecl;
import abstractSyntaxTree.Class.RefType;
import abstractSyntaxTree.Expression.InstVarExpression;
import abstractSyntaxTree.Expression.IntConstantExpression;
import abstractSyntaxTree.Expression.SubReceiver;
import abstractSyntaxTree.Parameter.Parameter;
import abstractSyntaxTree.Parameter.ParameterList;
import abstractSyntaxTree.Program;
import abstractSyntaxTree.Statement.BlockStatement;
import abstractSyntaxTree.Statement.IStatement;
import abstractSyntaxTree.StatementExpression.AssignStatementExpression;
import java.util.ArrayList;
import java.util.List;
public class ConstructorThisDotAST {
public static Program getProgram() {
List<RefType> refTypeList = new ArrayList<>();
refTypeList.add(getRefType());
Program program = new Program(refTypeList);
return program;
}
public static RefType getRefType() {
List<FieldDecl> fieldDeclList = new ArrayList<>();
fieldDeclList.add(new FieldDecl("int", "i", null));
List<MethodDecl> methodDeclList = new ArrayList<>();
methodDeclList.add(method0());
RefType refType = new RefType("ConstructorThisDot", fieldDeclList, methodDeclList, false);
return refType;
}
public static MethodDecl method0() {
List<Parameter> parameterList = new ArrayList<>();
ParameterList parameterListObj = new ParameterList(parameterList);
List<IStatement> iStatementList = new ArrayList<>();
SubReceiver subReceiver = new SubReceiver(true);
List<SubReceiver> subReceiverList = new ArrayList<>();
subReceiverList.add(subReceiver);
InstVarExpression instVarExpressionLeft = new InstVarExpression(subReceiverList, new ArrayList<>(), "i");
IntConstantExpression intConstantExpression = new IntConstantExpression(5);
AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", instVarExpressionLeft, intConstantExpression);
iStatementList.add(assignStatementExpression);
BlockStatement blockStatement = new BlockStatement(iStatementList, null);
MethodDecl methodDecl = new MethodDecl("ConstructorThisDot", null, "ConstructorThisDot",
parameterListObj, blockStatement);
return methodDecl;
}
}

View File

@ -0,0 +1,77 @@
package ASTs;
import Typecheck.TypingHelper;
import abstractSyntaxTree.Class.FieldDecl;
import abstractSyntaxTree.Class.MethodDecl;
import abstractSyntaxTree.Class.RefType;
import abstractSyntaxTree.Expression.InstVarExpression;
import abstractSyntaxTree.Expression.IntConstantExpression;
import abstractSyntaxTree.Expression.SubReceiver;
import abstractSyntaxTree.Parameter.Parameter;
import abstractSyntaxTree.Parameter.ParameterList;
import abstractSyntaxTree.Program;
import abstractSyntaxTree.Statement.BlockStatement;
import abstractSyntaxTree.Statement.IStatement;
import abstractSyntaxTree.StatementExpression.AssignStatementExpression;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class ConstructorThisDotASTTyped {
public static Program getProgram() {
List<RefType> refTypeList = new ArrayList<>();
refTypeList.add(getRefType());
Program program = new Program(refTypeList);
addTyping(program);
return program;
}
public static RefType getRefType() {
List<FieldDecl> fieldDeclList = new ArrayList<>();
fieldDeclList.add(new FieldDecl("int", "i", null));
List<MethodDecl> methodDeclList = new ArrayList<>();
methodDeclList.add(method0());
RefType refType = new RefType("ConstructorThisDot", fieldDeclList, methodDeclList, false);
return refType;
}
public static MethodDecl method0() {
List<Parameter> parameterList = new ArrayList<>();
ParameterList parameterListObj = new ParameterList(parameterList);
List<IStatement> iStatementList = new ArrayList<>();
SubReceiver subReceiver = new SubReceiver(true);
List<SubReceiver> subReceiverList = new ArrayList<>();
subReceiverList.add(subReceiver);
InstVarExpression instVarExpressionLeft = new InstVarExpression(subReceiverList, new ArrayList<>(), "i");
instVarExpressionLeft.thisClass = "ConstructorThisDot";
IntConstantExpression intConstantExpression = new IntConstantExpression(5);
AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", instVarExpressionLeft, intConstantExpression);
iStatementList.add(assignStatementExpression);
BlockStatement blockStatement = new BlockStatement(iStatementList, "void");
MethodDecl methodDecl = new MethodDecl("ConstructorThisDot", null, "ConstructorThisDot",
parameterListObj, blockStatement);
return methodDecl;
}
public static void addTyping(Program program){
// TypeContext
HashMap<String, String> typeContextMap = new HashMap<>();
typeContextMap.put("i", "int");
TypingHelper.addTypeContext(program, "ConstructorThisDot", typeContextMap);
// MethodContext
HashMap<String, ParameterList> method0 = new HashMap<>();
//method0.put("void", new ParameterList(new ArrayList<>()));
HashMap<String, HashMap<String, ParameterList>> methods = new HashMap<>();
//methods.put("main", method0);
TypingHelper.addMethodContext(program, "ConstructorThisDot", methods);
}
}

View File

@ -0,0 +1,24 @@
package ASTs;
import abstractSyntaxTree.Class.FieldDecl;
import abstractSyntaxTree.Class.MethodDecl;
import abstractSyntaxTree.Class.RefType;
import abstractSyntaxTree.Program;
import java.util.ArrayList;
import java.util.List;
public class FieldVarAST {
public static Program getProgram() {
// int variable
FieldDecl fieldDecl = new FieldDecl("int", "variable", null);
List<FieldDecl> fieldDeclList = new ArrayList<>();
List<MethodDecl> methodDeclList = new ArrayList<>();
fieldDeclList.add(fieldDecl);
RefType class0 = new RefType("FieldVar", fieldDeclList, methodDeclList, false);
List<RefType> refTypeList = new ArrayList<>();
refTypeList.add(class0);
return new Program(refTypeList);
}
}

View File

@ -0,0 +1,43 @@
package ASTs;
import Typecheck.TypingHelper;
import abstractSyntaxTree.Class.FieldDecl;
import abstractSyntaxTree.Class.MethodDecl;
import abstractSyntaxTree.Class.RefType;
import abstractSyntaxTree.Parameter.ParameterList;
import abstractSyntaxTree.Program;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class FieldVarASTTyped {
public static Program getProgram() {
// int variable
FieldDecl fieldDecl = new FieldDecl("int", "variable", null);
List<FieldDecl> fieldDeclList = new ArrayList<>();
List<MethodDecl> methodDeclList = new ArrayList<>();
fieldDeclList.add(fieldDecl);
RefType class0 = new RefType("FieldVar", fieldDeclList, methodDeclList, false);
List<RefType> refTypeList = new ArrayList<>();
refTypeList.add(class0);
Program program = new Program(refTypeList);
addTyping(program);
return program;
}
public static void addTyping(Program program){
// TypeContext
HashMap<String, String> typeContextMap = new HashMap<>();
typeContextMap.put("variable", "int");
TypingHelper.addTypeContext(program, "FieldVar", typeContextMap);
// MethodContext
HashMap<String, ParameterList> method0 = new HashMap<>();
//method0.put("void", new ParameterList(new ArrayList<>()));
HashMap<String, HashMap<String, ParameterList>> methods = new HashMap<>();
//methods.put("main", method0);
TypingHelper.addMethodContext(program, "FieldVar", methods);
}
}

View File

@ -0,0 +1,104 @@
package ASTs;
import abstractSyntaxTree.Class.FieldDecl;
import abstractSyntaxTree.Class.MethodDecl;
import abstractSyntaxTree.Class.RefType;
import abstractSyntaxTree.Expression.BinaryExpression;
import abstractSyntaxTree.Expression.IntConstantExpression;
import abstractSyntaxTree.Expression.LocalVarIdentifier;
import abstractSyntaxTree.Parameter.Parameter;
import abstractSyntaxTree.Parameter.ParameterList;
import abstractSyntaxTree.Program;
import abstractSyntaxTree.Statement.*;
import abstractSyntaxTree.StatementExpression.AssignStatementExpression;
import java.util.ArrayList;
import java.util.List;
public class IfElseIfStatementWithOneReturnAST {
public static Program getProgram() {
List<RefType> refTypeList = new ArrayList<>();
refTypeList.add(getRefType());
Program program = new Program(refTypeList);
return program;
}
public static RefType getRefType() {
List<FieldDecl> fieldDeclList = new ArrayList<>();
List<MethodDecl> methodDeclList = new ArrayList<>();
methodDeclList.add(method0());
RefType refType = new RefType("IfElseIfStatementWithOneReturn", fieldDeclList, methodDeclList, false);
return refType;
}
public static MethodDecl method0() {
List<Parameter> parameterList = new ArrayList<>();
parameterList.add(new Parameter("int", "i"));
ParameterList parameterListObj = new ParameterList(parameterList);
List<IStatement> iStatementList = new ArrayList<>();
iStatementList.add(statement00());
iStatementList.add(statement01());
iStatementList.add(statement02());
BlockStatement blockStatement0 = new BlockStatement(iStatementList, null);
MethodDecl methodDecl = new MethodDecl("IfElseIfStatementWithOneReturn", "int", "foo", parameterListObj, blockStatement0);
return methodDecl;
}
public static LocalVarDecl statement00() {
LocalVarDecl localVarDecl = new LocalVarDecl("int", "result", null);
return localVarDecl;
}
public static IfElseStatement statement01() {
LocalVarIdentifier conditionLeft = new LocalVarIdentifier("i");
BinaryExpression condition = new BinaryExpression("==", conditionLeft, new IntConstantExpression(1));
LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
List<IStatement> ifStatementList = new ArrayList<>();
ifStatementList.add(new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10)));
BlockStatement ifStatement = new BlockStatement(ifStatementList, null);
IfElseStatement elseStatement = statement010();
IfElseStatement ifElseStatement = new IfElseStatement(condition, ifStatement, elseStatement);
return ifElseStatement;
}
public static IfElseStatement statement010() {
LocalVarIdentifier identifieri = new LocalVarIdentifier("i");
BinaryExpression condition0 = new BinaryExpression("==", identifieri, new IntConstantExpression(2));
List<IStatement> iStatementList = new ArrayList<>();
LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10));
iStatementList.add(assignStatementExpression);
BlockStatement ifStatement = new BlockStatement(iStatementList, null);
BinaryExpression condition1 = new BinaryExpression("==", identifieri, new IntConstantExpression(2));
List<IStatement> iStatementList1 = new ArrayList<>();
iStatementList1.add(new ReturnStatement(new IntConstantExpression(20)));
BlockStatement blockStatementIf = new BlockStatement(iStatementList1, null);
List<IStatement> iStatementList2 = new ArrayList<>();
AssignStatementExpression assignStatementExpression1 = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(30));
iStatementList2.add(assignStatementExpression1);
BlockStatement blockStatementElse = new BlockStatement(iStatementList2, null);
IfElseStatement ifElseStatement = new IfElseStatement(condition1, blockStatementIf, blockStatementElse);
return new IfElseStatement(condition1, blockStatementIf, blockStatementElse);
}
public static ReturnStatement statement02() {
LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
return new ReturnStatement(identifierResult);
}
}

View File

@ -0,0 +1,135 @@
package ASTs;
import TypeCheck.TypeCheckResult;
import Typecheck.TypingHelper;
import abstractSyntaxTree.Class.FieldDecl;
import abstractSyntaxTree.Class.MethodDecl;
import abstractSyntaxTree.Class.RefType;
import abstractSyntaxTree.Expression.BinaryExpression;
import abstractSyntaxTree.Expression.IntConstantExpression;
import abstractSyntaxTree.Expression.LocalVarIdentifier;
import abstractSyntaxTree.Parameter.Parameter;
import abstractSyntaxTree.Parameter.ParameterList;
import abstractSyntaxTree.Program;
import abstractSyntaxTree.Statement.*;
import abstractSyntaxTree.StatementExpression.AssignStatementExpression;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class IfElseIfStatementWithOneReturnASTTyped {
public static Program getProgram() {
List<RefType> refTypeList = new ArrayList<>();
refTypeList.add(getRefType());
Program program = new Program(refTypeList);
addTyping(program);
return program;
}
public static RefType getRefType() {
List<FieldDecl> fieldDeclList = new ArrayList<>();
List<MethodDecl> methodDeclList = new ArrayList<>();
methodDeclList.add(method0());
RefType refType = new RefType("IfElseIfStatementWithOneReturn", fieldDeclList, methodDeclList, false);
return refType;
}
public static MethodDecl method0() {
List<Parameter> parameterList = new ArrayList<>();
parameterList.add(new Parameter("int", "i"));
ParameterList parameterListObj = new ParameterList(parameterList);
List<IStatement> iStatementList = new ArrayList<>();
iStatementList.add(statement00());
iStatementList.add(statement01());
iStatementList.add(statement02());
BlockStatement blockStatement0 = new BlockStatement(iStatementList, "int");
MethodDecl methodDecl = new MethodDecl("IfElseIfStatementWithOneReturn", "int", "foo", parameterListObj, blockStatement0);
return methodDecl;
}
public static LocalVarDecl statement00() {
LocalVarDecl localVarDecl = new LocalVarDecl("int", "result", null);
return localVarDecl;
}
public static IfElseStatement statement01() {
LocalVarIdentifier conditionLeft = new LocalVarIdentifier("i");
conditionLeft.setTypeCheckResult(new TypeCheckResult("int"));
BinaryExpression condition = new BinaryExpression("==", conditionLeft, new IntConstantExpression(1));
condition.setTypeCheckResult(new TypeCheckResult("boolean"));
LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
identifierResult.setTypeCheckResult(new TypeCheckResult("int"));
List<IStatement> ifStatementList = new ArrayList<>();
ifStatementList.add(new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10)));
BlockStatement ifStatement = new BlockStatement(ifStatementList, "void");
IfElseStatement elseStatement = statement010();
IfElseStatement ifElseStatement = new IfElseStatement(condition, ifStatement, elseStatement);
return ifElseStatement;
}
public static IfElseStatement statement010() {
LocalVarIdentifier identifieri = new LocalVarIdentifier("i");
identifieri.setTypeCheckResult(new TypeCheckResult("int"));
BinaryExpression condition0 = new BinaryExpression("==", identifieri, new IntConstantExpression(2));
condition0.setTypeCheckResult(new TypeCheckResult("boolean"));
List<IStatement> iStatementList = new ArrayList<>();
LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
identifierResult.setTypeCheckResult(new TypeCheckResult("int"));
AssignStatementExpression assignStatementExpression = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(10));
iStatementList.add(assignStatementExpression);
BlockStatement ifStatement = new BlockStatement(iStatementList, "void");
BinaryExpression condition1 = new BinaryExpression("==", identifieri, new IntConstantExpression(2));
condition1.setTypeCheckResult(new TypeCheckResult("boolean"));
List<IStatement> iStatementList1 = new ArrayList<>();
IntConstantExpression intConstantExpression20 = new IntConstantExpression(20);
intConstantExpression20.setTypeCheckResult(new TypeCheckResult("int"));
ReturnStatement return20 = new ReturnStatement(intConstantExpression20);
return20.setTypeCheckResult(new TypeCheckResult("int"));
iStatementList1.add(return20);
BlockStatement blockStatementIf = new BlockStatement(iStatementList1, "int");
List<IStatement> iStatementList2 = new ArrayList<>();
AssignStatementExpression assignStatementExpression1 = new AssignStatementExpression("=", identifierResult, new IntConstantExpression(30));
iStatementList2.add(assignStatementExpression1);
BlockStatement blockStatementElse = new BlockStatement(iStatementList2, "void");
IfElseStatement ifElseStatement = new IfElseStatement(condition1, blockStatementIf, blockStatementElse);
return new IfElseStatement(condition1, blockStatementIf, blockStatementElse);
}
public static ReturnStatement statement02() {
LocalVarIdentifier identifierResult = new LocalVarIdentifier("result");
identifierResult.setTypeCheckResult(new TypeCheckResult("int"));
return new ReturnStatement(identifierResult);
}
public static void addTyping(Program program){
// TypeContext
TypingHelper.addTypeContext(program, "IfElseIfStatementWithOneReturn", new HashMap<>());
// MethodContext
HashMap<String, ParameterList> method0 = new HashMap<>();
List<Parameter> parameterList = new ArrayList<>();
parameterList.add(new Parameter("int", "i"));
ParameterList parameterListObj = new ParameterList(parameterList);
method0.put("int", parameterListObj);
HashMap<String, HashMap<String, ParameterList>> methods = new HashMap<>();
methods.put("foo", method0);
TypingHelper.addMethodContext(program, "IfElseIfStatementWithOneReturn", methods);
}
}

View File

@ -77,7 +77,6 @@ public class ByteCodeTester {
private Program generateAST(String pathToJavaFile){
String content = "";
try {
System.out.println("Classpath: " + Path.of(pathToJavaFile));
content = Files.readString(Path.of(pathToJavaFile));
} catch (IOException e) {
System.out.println("File not found!");
@ -115,7 +114,6 @@ public class ByteCodeTester {
public void compareJarFilesFromScratch(String javaCodePath, String jarPath, String[] classNames){
String content = "";
try {
System.out.println("Classpath: " + Path.of(javaCodePath));
content = Files.readString(Path.of(javaCodePath));
} catch (IOException e) {
System.out.println("File not found!");

View File

@ -98,7 +98,7 @@ public class CompareByteCodeBehaviour {
Method method1 = methods1[i];
Method method2 = methods2[i];
System.out.println(method1);
System.out.println("\n" + method1);
System.out.println(method2);
method1.setAccessible(true);
@ -108,7 +108,7 @@ public class CompareByteCodeBehaviour {
// Test with some sample inputs
Object[] testInputs = getTestInputs(method1.getParameterTypes());
for(int j = 0; j < testInputs.length; j++){
System.out.println("TestInput: " + testInputs[j]);
System.out.println("Parameter[" + i + "]: " + testInputs[j]);
}
Object result1 = method1.invoke(obj1, testInputs);

View File

@ -35,11 +35,11 @@ public class TestAll {
@Test
public void testFakultaet() {
String classPath = "src/test/resources/basicClasses/Fakultaet.class";
Program ast = FakultaetASTTyped.getProgram();
Program ast = FakultaetAST.getProgram();
String className = "Fakultaet";
String javacode = "src/test/resources/basicClasses/Fakultaet.java";
//byteCodeTester.testByteCodeFromTypedAst(classPath, ast ,className);
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
byteCodeTester.testByteCodeFromAst(classPath, ast ,className);
//byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@Test
@ -92,15 +92,6 @@ public class TestAll {
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@Test
public void testDivMethod() {
String classPath = "src/test/resources/SimpleTests/DivMethod.class";
//Program ast = ClassWithMainASTTyped.getProgram();
String className = "DivMethod";
String javacode = "src/test/resources/SimpleTests/DivMethod.java";
//testByteCodeFromAst(classPath, ast ,className);
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
// We dont do null assignments
/*
@ -118,10 +109,10 @@ public class TestAll {
@Test
public void testFieldVar() {
String classPath = "src/test/resources/SimpleTests/FieldVar.class";
//Program ast = ClassWithMainASTTyped.getProgram();
Program ast = FieldVarASTTyped.getProgram();
String className = "FieldVar";
String javacode = "src/test/resources/SimpleTests/FieldVar.java";
//testByteCodeFromAst(classPath, ast ,className);
byteCodeTester.testByteCodeFromTypedAst(classPath, ast ,className);
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@ -135,6 +126,7 @@ public class TestAll {
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@Test
public void testGetterFunction() {
String classPath = "src/test/resources/SimpleTests/GetterFunction.class";
@ -145,6 +137,16 @@ public class TestAll {
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@Test
public void testDivMethod() {
String classPath = "src/test/resources/SimpleTests/DivMethod.class";
//Program ast = ClassWithMainASTTyped.getProgram();
String className = "DivMethod";
String javacode = "src/test/resources/SimpleTests/DivMethod.java";
//byteCodeTester.testByteCodeFromAst(classPath, ast ,className);
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@Test
public void testIfElseIfStatement() {
String classPath = "src/test/resources/SimpleTests/IfElseIfStatement.class";
@ -158,10 +160,10 @@ public class TestAll {
@Test
public void testIfElseIfStatementWithOneReturn() {
String classPath = "src/test/resources/SimpleTests/IfElseIfStatementWithOneReturn.class";
//Program ast = ClassWithMainASTTyped.getProgram();
Program ast = IfElseIfStatementWithOneReturnAST.getProgram();
String className = "IfElseIfStatementWithOneReturn";
String javacode = "src/test/resources/SimpleTests/IfElseIfStatementWithOneReturn.java";
//testByteCodeFromAst(classPath, ast ,className);
byteCodeTester.testByteCodeFromAst(classPath, ast ,className);
byteCodeTester.testClassFileFromScratch(classPath, javacode, className);
}
@ -185,17 +187,6 @@ public class TestAll {
byteCodeTester.compareJarFilesFromScratch(javacode, jarPath, classNames);
}
/*
@Test
public void testDijkstra() {
String jarPath = "src/test/resources/Integration/Dijkstra.jar";
//Program ast = ClassWithMainASTTyped.getProgram();
String[] classNames = {"FourClasses", "Test", "Test2", "Test3"};
String javacode = "src/test/resources/Integration/Dijkstra.java";
byteCodeTester.compareJarFilesFromScratch(javacode, jarPath, classNames);
}
*/

View File

@ -21,44 +21,44 @@ public class TestAll {
@Test
public void testClassWithMain() {
Program emptyClassAst = ClassWithMainAST.getProgram();
Program astToBeTested = ClassWithMainAST.getProgram();
Program correctAST = ClassWithMainASTTyped.getProgram();
boolean expectedResult = true;
testTypeCheck(emptyClassAst, correctAST, expectedResult);
testTypeCheck(astToBeTested, correctAST, expectedResult);
}
@Test
public void testEmptyClass() {
Program emptyClassAst = emptyClassAST.getEmptyProgramm();
Program astToBeTested = emptyClassAST.getEmptyProgramm();
Program correctAST = emptyClassASTTyped.getEmptyProgramm();
boolean expectedResult = false;
testTypeCheck(emptyClassAst, correctAST, expectedResult);
testTypeCheck(astToBeTested, correctAST, expectedResult);
}
@Test
public void testEmptyClassWM() {
Program emptyClassAst = emptyClassAST.getEmptyProgramm();
Program astToBeTested = emptyClassAST.getEmptyProgramm();
Program correctAST = emptyClassASTTyped.getEmptyProgramm();
boolean expectedResult = true;
testTypeCheckWM(emptyClassAst, correctAST, expectedResult);
testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
@Test
public void testEmptyClassWithConstructor(){
Program abstractSyntaxTree = EmptyClassWithConstructorAST.getProgram();
Program astToBeTested = EmptyClassWithConstructorAST.getProgram();
Program correctAST = EmptyClassWithConstructorASTTyped.getProgram();
boolean expectedResult = false;
testTypeCheck(abstractSyntaxTree, correctAST, expectedResult);
testTypeCheck(astToBeTested, correctAST, expectedResult);
}
@Test
public void testEmptyClassWithConstructorWM(){
Program abstractSyntaxTree = EmptyClassWithConstructorAST.getProgram();
Program astToBeTested = EmptyClassWithConstructorAST.getProgram();
Program correctAST = EmptyClassWithConstructorASTTyped.getProgram();
boolean expectedResult = true;
testTypeCheckWM(abstractSyntaxTree, correctAST, expectedResult);
testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
/*
@ -79,44 +79,78 @@ public class TestAll {
@Test
public void testAssignWrongType(){
Program assignWrongType = AssignWrongTypeAST.getProgram();
Program astToBeTested = AssignWrongTypeAST.getProgram();
Program correctAST = AssignWrongTypeASTTyped.getProgram();
boolean expectedResult = false;
testTypeCheck(assignWrongType, correctAST,expectedResult);
testTypeCheck(astToBeTested, correctAST,expectedResult);
}
@Test
public void testAssignWrongTypeWM(){
Program assignWrongType = AssignWrongTypeAST.getProgram();
Program astToBeTested = AssignWrongTypeAST.getProgram();
Program correctAST = AssignWrongTypeASTTyped.getProgram();
boolean expectedResult = false;
testTypeCheckWM(assignWrongType, correctAST, expectedResult);
testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
@Test
public void testFakultaet(){
Program fakultaet = FakultaetAST.getProgram();
Program astToBeTested = FakultaetAST.getProgram();
Program correctAST = FakultaetASTTyped.getProgram();
boolean expectedResult = true;
testTypeCheck(fakultaet, correctAST, expectedResult);
testTypeCheck(astToBeTested, correctAST, expectedResult);
}
@Test
public void testDivideByZero(){
Program fakultaet = DivideByZeroAST.getProgram();
Program astToBeTested = DivideByZeroAST.getProgram();
Program correctAST = DivideByZeroASTTyped.getProgram();
boolean expectedResult = true;
testTypeCheck(fakultaet, correctAST, expectedResult);
testTypeCheck(astToBeTested, correctAST, expectedResult);
}
@Test
public void testCharArgument(){
Program fakultaet = CharArgumentAST.getProgram();
Program astToBeTested = CharArgumentAST.getProgram();
Program correctAST = CharArgumentASTTyped.getProgram();
boolean expectedResult = true;
testTypeCheckWOM(fakultaet, correctAST, expectedResult);
testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
@Test
public void testFieldVar(){
Program astToBeTested = FieldVarAST.getProgram();
Program correctAST = FieldVarASTTyped.getProgram();
boolean expectedResult = true;
testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
@Test
public void testConstructorParams(){
Program astToBeTested = ConstructorParamsAST.getProgram();
Program correctAST = ConstructorParamsASTTyped.getProgram();
boolean expectedResult = true;
testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
@Test
public void testConstructorThisDot(){
Program astToBeTested = ConstructorThisDotAST.getProgram();
Program correctAST = ConstructorThisDotASTTyped.getProgram();
boolean expectedResult = true;
testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
@Test
public void testIfElseIfStatementWithOneReturn(){
Program astToBeTested = IfElseIfStatementWithOneReturnAST.getProgram();
Program correctAST = IfElseIfStatementWithOneReturnASTTyped.getProgram();
boolean expectedResult = true;
testTypeCheckWOM(astToBeTested, correctAST, expectedResult);
}
public void testTypeCheckWOM(Program abstractSyntaxTree, Program correctAST, boolean expectedResult) {
try {

View File

@ -1,5 +1,5 @@
class FieldVar {
int field;
int variable;
}

View File

@ -2,7 +2,7 @@ Class: "class"
Identifier: "FieldVar"
OpenCurlyBracket: "{"
Int: "int"
Identifier: "field"
Identifier: "variable"
Semicolon: ";"
ClosedCurlyBracket: "}"
EOF: "<EOF>"