From 8e55eaca933b6132cbe904b8c0b0773c216a7dd7 Mon Sep 17 00:00:00 2001 From: KingJulian Date: Fri, 5 Jul 2024 11:31:25 +0200 Subject: [PATCH 1/2] Test update --- CharArgument.class | Bin 219 -> 0 bytes ClassFields.class | Bin 248 -> 0 bytes ClassOne.class | Bin 296 -> 0 bytes ClassTwo.class | Bin 182 -> 0 bytes ConstructorParams.class | Bin 141 -> 0 bytes ConstructorThisDot.class | Bin 175 -> 0 bytes DivMethod.class | Bin 167 -> 0 bytes Fakultaet.class | Bin 325 -> 0 bytes FieldVar.class | Bin 158 -> 0 bytes FieldWithExpr.class | Bin 165 -> 0 bytes GetterFunction.class | Bin 218 -> 0 bytes Grammatik.txt | 166 ------------------ IfElseIfStatement.class | Bin 328 -> 0 bytes IfElseIfStatementWithOneReturn.class | Bin 340 -> 0 bytes NichtHaskell.iml | 11 -- classWithMain.class | Bin 187 -> 0 bytes emptyClass.class | Bin 125 -> 0 bytes getI.class | Bin 119 -> 0 bytes .../Statement/BlockStatement.java | 2 +- .../Statement/ReturnStatement.java | 2 +- src/test/java/AST/testAll.java | 55 ++++-- src/test/java/ASTs/ConstructorParamsAST.java | 45 +++++ .../java/ASTs/ConstructorParamsASTTyped.java | 59 +++++++ src/test/java/ASTs/ConstructorThisDotAST.java | 60 +++++++ .../java/ASTs/ConstructorThisDotASTTyped.java | 77 ++++++++ src/test/java/ASTs/FieldVarAST.java | 24 +++ src/test/java/ASTs/FieldVarASTTyped.java | 43 +++++ .../IfElseIfStatementWithOneReturnAST.java | 104 +++++++++++ ...fElseIfStatementWithOneReturnASTTyped.java | 135 ++++++++++++++ src/test/java/ByteCode/ByteCodeTester.java | 2 - .../ByteCode/CompareByteCodeBehaviour.java | 4 +- src/test/java/ByteCode/TestAll.java | 28 +-- src/test/java/Typecheck/TestAll.java | 74 +++++--- src/test/resources/SimpleTests/FieldVar.java | 2 +- .../resources/SimpleTests/FieldVar.tokens | 2 +- 35 files changed, 657 insertions(+), 238 deletions(-) delete mode 100644 CharArgument.class delete mode 100644 ClassFields.class delete mode 100644 ClassOne.class delete mode 100644 ClassTwo.class delete mode 100644 ConstructorParams.class delete mode 100644 ConstructorThisDot.class delete mode 100644 DivMethod.class delete mode 100644 Fakultaet.class delete mode 100644 FieldVar.class delete mode 100644 FieldWithExpr.class delete mode 100644 GetterFunction.class delete mode 100644 Grammatik.txt delete mode 100644 IfElseIfStatement.class delete mode 100644 IfElseIfStatementWithOneReturn.class delete mode 100644 NichtHaskell.iml delete mode 100644 classWithMain.class delete mode 100644 emptyClass.class delete mode 100644 getI.class create mode 100644 src/test/java/ASTs/ConstructorParamsAST.java create mode 100644 src/test/java/ASTs/ConstructorParamsASTTyped.java create mode 100644 src/test/java/ASTs/ConstructorThisDotAST.java create mode 100644 src/test/java/ASTs/ConstructorThisDotASTTyped.java create mode 100644 src/test/java/ASTs/FieldVarAST.java create mode 100644 src/test/java/ASTs/FieldVarASTTyped.java create mode 100644 src/test/java/ASTs/IfElseIfStatementWithOneReturnAST.java create mode 100644 src/test/java/ASTs/IfElseIfStatementWithOneReturnASTTyped.java diff --git a/CharArgument.class b/CharArgument.class deleted file mode 100644 index cc8c57dff2717497152fc93a797c2afd54a416b3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 219 zcmXYq%?`m(5QWe5mTFy;SXx+CH#U|ck^2C4_80Zj&?Zuz%EkhTg$M9Z;#4eV=FB%U zXWpOZ3&02+fi_!voE|r)Ly{F9L=dL-Y=?WBZHBW&nk-3`K$Z+6sE&8pu9yf^G?;66 zs0DE0YgAD6;h@gRI?n}eWCli~fo4G5A~5+Xfv|D;oNna_l|w}v<~F-N6cx~o9|&S~ agO20S-Vst=$;(T6{BAv(i?g}PQZJR#))Ht#5XEJm z8}+xs;(RJOuhYNd&CSu23xYGA>;&5Abl@ToXu)fvfv$jGt5Bd>t3JV9ol*_rfXiPx mta!$Xs`QU}|Ho9_WPixri1Wl8Cl83kxuaJ>RKeiJKGzpVUnu1O diff --git a/ClassOne.class b/ClassOne.class deleted file mode 100644 index 6c40c2f3bc84ee21205c09eacbdcf5751854b94e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 296 zcmYL@%W48a5Jhh}>X>nS#gI+>03QoC?tE+nAt1O=gpgHdGDwT|fR5&;vdKolKt8~a z5^v*3s-df^&aGR0zMTF5bnqm|4OeQrotV&t2+B*fSM8NDi}vJW83wTnN09AlqvL_V zsW;|6GRS&J!xg00N*lp*{eApDIE^>jEV_+3?SjO7v@=1hBWh{!dfz(xid+;t6s^}y z%hp}%qYU4|3KtEd&k%wX_u6py<~Mj(Syh;YInz8M_hUI8c)SD`SX(SNB*?>0&$cIBJ;Y^GSEYA5UsSJz^ wOhCmTzyxFi^#VyAAWslTGXiN=t?djP8$t3wE++#QRGJ?u%`C*d1}w<{05e1ze*gdg diff --git a/ConstructorParams.class b/ConstructorParams.class deleted file mode 100644 index 7c2a9ec6e70401075466318c5468830aed138463..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 141 zcmX^0Z`VEs1_l!bZbk+{=ls0llA_Y&lKi58#G=I9Vs-{bMh1bb#Ii*FoW#6zegCAa z)Z`L&24+SEHk-`6%o00B1{MuZ%`ip=W)00S9tKthb}j}M1`eRGbAC!H10w?ykP8Bg dK*-9#1|+$FJYld50|UF(b_Pyqn~h*43;-dG7-;|i diff --git a/ConstructorThisDot.class b/ConstructorThisDot.class deleted file mode 100644 index 402b19add55332b2b027b0bae01c7fda3617c9fc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 175 zcmXYpJqp4=5QX2k`7tqSNbLbMO&UwFiH((w*vA-jgJdCDy_bau79PMuiBE7~e%?3p z=KXoT0L(EKB)Mri+g?g*+U-eqD`S0#Ag+sRk)4a?m~HlTRgx-!Xy#hrEp(&pQlO@@ zT?8Nf5DtO}F1!Fe3>5#n0w*_z3PR!#(EB_1Pc%`Fs3zPCdz?NHrs|F;O@^#DGR7A? CRvL@| diff --git a/DivMethod.class b/DivMethod.class deleted file mode 100644 index e11ee7f4f902ab20d590f03a8b0d703c9516c24f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 167 zcmX^0Z`VEs1_l!b9!3UEm&`KX)RK(+6m|wiMh1bb#Ii*FoW#6zegCAa)Z`L&24+SE zHk-`6%o00B24)S-Fdhb01~x7R76x`8KP^9>k%2|SQ_~YjIp?ROGB7eQ0p&n|3CIR2 r1(MuAo*cK7I=>9q* zczvx##i@EYSHm&`VS`gwHmXZl+2&`+n|PbM@7R1>8XP!q*VtpF#2aPGQR)- diff --git a/FieldVar.class b/FieldVar.class deleted file mode 100644 index 5844709eb7262bef345770e4df845533446241ac..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 158 zcmX^0Z`VEs1_l!bK1K!(x6IU>l(57ib_Pa927#=^vPAuy#JqHU|D>$c{rb21ZXt1~!|_yv!0iMh0dL%`hGYb_NbE1{MZR9tKthHckd625v?M7U%qwR0c*M nhXrU0P#Z`N$^xnf@_B(gF`zsnkml0b4#dn`8F)4Vc|ZUFY*QAg diff --git a/FieldWithExpr.class b/FieldWithExpr.class deleted file mode 100644 index aa8d31f1c383acd013d7181e771c8af26ceffdc9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 165 zcmX^0Z`VEs1_l!bentjfx6IU>l<>@w4A+W+B6bEwMh1bb#Ii*FoW#6zegCAa)Z`L& z24+SE#tI|+`mOR*7@RCej3KEewUL7twc4v3r zpXUp}6tN&$DPz=ed1|&s9~vJb7}n*vob1b{nyfdq+8Q6WKr|~Ccr)E-GZ#2%J}v}y zIxYhE==R{C7r=$rg@u5DN*OLNKy(&|oq}-U@HbDjK`M*NM~6718_`?jID4R<*>{A= ZEK5jNHrurbgMTz83wv&MLwNa(@dfH+9xMO= diff --git a/Grammatik.txt b/Grammatik.txt deleted file mode 100644 index 91c85f5..0000000 --- a/Grammatik.txt +++ /dev/null @@ -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 diff --git a/IfElseIfStatement.class b/IfElseIfStatement.class deleted file mode 100644 index 34c23f7fde8f5b3bcd65e4d27e3e6ec32d32d534..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 328 zcmZvWy-or_6ot>79T;{6WfwbM0I;C3G=_v&Y+)=U_5;o$xb7O==(CuZ*pS%RSeaNz z?>qT(CNa^%DZV@BoICf<`{(N$fL&}0;xs$RuU(oQSGIB&uBZ$|&|cabJIrk{A0ADY zZbml{)b|#}qS_Y(z5YoPHPj<$80xGn1-h5^(}0u3Bl1wh{fJn#1)blale4Sx)=qP0 zz(9}7QzvNg53}<_dpYq51d7xBQM_{*nNY>7!de@=pz-W;$`H{{JZHP2x6@5F9$y9sL#~B z>gTGs>JP^=Juwmvp?Z)NnK>jl-QIZ(6;uPbknGd4B)HwAmpEJl3$h3-ghk7uLumd@ z9!=-vgBs^rqQS3^%1ccM`B#(c6LmYX2?&BK>=L}^MrM;;gOyk-yRYzGY|hq4@Ea?> zZVUIKwYVMCo*xdZPDAq~j$2lUO&97sef J2nj(XfFA}qI9mV! diff --git a/NichtHaskell.iml b/NichtHaskell.iml deleted file mode 100644 index fbfe57d..0000000 --- a/NichtHaskell.iml +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - - - - - - \ No newline at end of file diff --git a/classWithMain.class b/classWithMain.class deleted file mode 100644 index 225b708d5d983868786793e60066787743df49fb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 187 zcmX^0Z`VEs1_l!b9!3V<$c refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + List 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 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; + } +} diff --git a/src/test/java/ASTs/ConstructorParamsASTTyped.java b/src/test/java/ASTs/ConstructorParamsASTTyped.java new file mode 100644 index 0000000..17c7490 --- /dev/null +++ b/src/test/java/ASTs/ConstructorParamsASTTyped.java @@ -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 refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + addTyping(program); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + List 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 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 method0 = new HashMap<>(); + //method0.put("void", new ParameterList(new ArrayList<>())); + HashMap> methods = new HashMap<>(); + //methods.put("main", method0); + TypingHelper.addMethodContext(program, "ConstructorParams", methods); + } +} diff --git a/src/test/java/ASTs/ConstructorThisDotAST.java b/src/test/java/ASTs/ConstructorThisDotAST.java new file mode 100644 index 0000000..df734a8 --- /dev/null +++ b/src/test/java/ASTs/ConstructorThisDotAST.java @@ -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 refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + fieldDeclList.add(new FieldDecl("int", "i", null)); + List methodDeclList = new ArrayList<>(); + methodDeclList.add(method0()); + RefType refType = new RefType("ConstructorThisDot", fieldDeclList, methodDeclList, false); + return refType; + } + + public static MethodDecl method0() { + + List parameterList = new ArrayList<>(); + ParameterList parameterListObj = new ParameterList(parameterList); + List iStatementList = new ArrayList<>(); + + SubReceiver subReceiver = new SubReceiver(true); + List 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; + } +} diff --git a/src/test/java/ASTs/ConstructorThisDotASTTyped.java b/src/test/java/ASTs/ConstructorThisDotASTTyped.java new file mode 100644 index 0000000..cbfa2f6 --- /dev/null +++ b/src/test/java/ASTs/ConstructorThisDotASTTyped.java @@ -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 refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + addTyping(program); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + fieldDeclList.add(new FieldDecl("int", "i", null)); + List methodDeclList = new ArrayList<>(); + methodDeclList.add(method0()); + RefType refType = new RefType("ConstructorThisDot", fieldDeclList, methodDeclList, false); + return refType; + } + + public static MethodDecl method0() { + + List parameterList = new ArrayList<>(); + ParameterList parameterListObj = new ParameterList(parameterList); + List iStatementList = new ArrayList<>(); + + SubReceiver subReceiver = new SubReceiver(true); + List 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 typeContextMap = new HashMap<>(); + typeContextMap.put("i", "int"); + TypingHelper.addTypeContext(program, "ConstructorThisDot", typeContextMap); + + // MethodContext + HashMap method0 = new HashMap<>(); + //method0.put("void", new ParameterList(new ArrayList<>())); + HashMap> methods = new HashMap<>(); + //methods.put("main", method0); + TypingHelper.addMethodContext(program, "ConstructorThisDot", methods); + } +} diff --git a/src/test/java/ASTs/FieldVarAST.java b/src/test/java/ASTs/FieldVarAST.java new file mode 100644 index 0000000..71b344f --- /dev/null +++ b/src/test/java/ASTs/FieldVarAST.java @@ -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 fieldDeclList = new ArrayList<>(); + List methodDeclList = new ArrayList<>(); + fieldDeclList.add(fieldDecl); + RefType class0 = new RefType("FieldVar", fieldDeclList, methodDeclList, false); + List refTypeList = new ArrayList<>(); + refTypeList.add(class0); + return new Program(refTypeList); + } +} diff --git a/src/test/java/ASTs/FieldVarASTTyped.java b/src/test/java/ASTs/FieldVarASTTyped.java new file mode 100644 index 0000000..7bd6aac --- /dev/null +++ b/src/test/java/ASTs/FieldVarASTTyped.java @@ -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 fieldDeclList = new ArrayList<>(); + List methodDeclList = new ArrayList<>(); + fieldDeclList.add(fieldDecl); + RefType class0 = new RefType("FieldVar", fieldDeclList, methodDeclList, false); + List refTypeList = new ArrayList<>(); + refTypeList.add(class0); + Program program = new Program(refTypeList); + addTyping(program); + return program; + } + + public static void addTyping(Program program){ + // TypeContext + HashMap typeContextMap = new HashMap<>(); + typeContextMap.put("variable", "int"); + TypingHelper.addTypeContext(program, "FieldVar", typeContextMap); + + // MethodContext + HashMap method0 = new HashMap<>(); + //method0.put("void", new ParameterList(new ArrayList<>())); + HashMap> methods = new HashMap<>(); + //methods.put("main", method0); + TypingHelper.addMethodContext(program, "FieldVar", methods); + } +} diff --git a/src/test/java/ASTs/IfElseIfStatementWithOneReturnAST.java b/src/test/java/ASTs/IfElseIfStatementWithOneReturnAST.java new file mode 100644 index 0000000..eee31a6 --- /dev/null +++ b/src/test/java/ASTs/IfElseIfStatementWithOneReturnAST.java @@ -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 refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + List methodDeclList = new ArrayList<>(); + methodDeclList.add(method0()); + RefType refType = new RefType("IfElseIfStatementWithOneReturn", fieldDeclList, methodDeclList, false); + + return refType; + } + + public static MethodDecl method0() { + + List parameterList = new ArrayList<>(); + parameterList.add(new Parameter("int", "i")); + ParameterList parameterListObj = new ParameterList(parameterList); + + List 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 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 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 iStatementList1 = new ArrayList<>(); + iStatementList1.add(new ReturnStatement(new IntConstantExpression(20))); + BlockStatement blockStatementIf = new BlockStatement(iStatementList1, null); + List 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); + } + +} diff --git a/src/test/java/ASTs/IfElseIfStatementWithOneReturnASTTyped.java b/src/test/java/ASTs/IfElseIfStatementWithOneReturnASTTyped.java new file mode 100644 index 0000000..1a3bbac --- /dev/null +++ b/src/test/java/ASTs/IfElseIfStatementWithOneReturnASTTyped.java @@ -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 refTypeList = new ArrayList<>(); + refTypeList.add(getRefType()); + Program program = new Program(refTypeList); + addTyping(program); + + return program; + } + + public static RefType getRefType() { + + List fieldDeclList = new ArrayList<>(); + List methodDeclList = new ArrayList<>(); + methodDeclList.add(method0()); + RefType refType = new RefType("IfElseIfStatementWithOneReturn", fieldDeclList, methodDeclList, false); + + return refType; + } + + public static MethodDecl method0() { + + List parameterList = new ArrayList<>(); + parameterList.add(new Parameter("int", "i")); + ParameterList parameterListObj = new ParameterList(parameterList); + + List 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 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 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 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 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 method0 = new HashMap<>(); + List parameterList = new ArrayList<>(); + parameterList.add(new Parameter("int", "i")); + ParameterList parameterListObj = new ParameterList(parameterList); + method0.put("int", parameterListObj); + HashMap> methods = new HashMap<>(); + methods.put("foo", method0); + TypingHelper.addMethodContext(program, "IfElseIfStatementWithOneReturn", methods); + } +} diff --git a/src/test/java/ByteCode/ByteCodeTester.java b/src/test/java/ByteCode/ByteCodeTester.java index e374316..9128e7c 100644 --- a/src/test/java/ByteCode/ByteCodeTester.java +++ b/src/test/java/ByteCode/ByteCodeTester.java @@ -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!"); diff --git a/src/test/java/ByteCode/CompareByteCodeBehaviour.java b/src/test/java/ByteCode/CompareByteCodeBehaviour.java index c5584db..c5f5b28 100644 --- a/src/test/java/ByteCode/CompareByteCodeBehaviour.java +++ b/src/test/java/ByteCode/CompareByteCodeBehaviour.java @@ -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); diff --git a/src/test/java/ByteCode/TestAll.java b/src/test/java/ByteCode/TestAll.java index 24a70cf..e60a0d6 100644 --- a/src/test/java/ByteCode/TestAll.java +++ b/src/test/java/ByteCode/TestAll.java @@ -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 @@ -98,7 +98,7 @@ public class TestAll { //Program ast = ClassWithMainASTTyped.getProgram(); String className = "DivMethod"; String javacode = "src/test/resources/SimpleTests/DivMethod.java"; - //testByteCodeFromAst(classPath, ast ,className); + //byteCodeTester.testByteCodeFromAst(classPath, ast ,className); byteCodeTester.testClassFileFromScratch(classPath, javacode, className); } @@ -118,10 +118,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 +135,7 @@ public class TestAll { byteCodeTester.testClassFileFromScratch(classPath, javacode, className); } + @Test public void testGetterFunction() { String classPath = "src/test/resources/SimpleTests/GetterFunction.class"; @@ -158,10 +159,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 +186,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); - } - */ - diff --git a/src/test/java/Typecheck/TestAll.java b/src/test/java/Typecheck/TestAll.java index 9ee8040..686f8b5 100644 --- a/src/test/java/Typecheck/TestAll.java +++ b/src/test/java/Typecheck/TestAll.java @@ -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 { diff --git a/src/test/resources/SimpleTests/FieldVar.java b/src/test/resources/SimpleTests/FieldVar.java index 4c83a9c..2265a3f 100644 --- a/src/test/resources/SimpleTests/FieldVar.java +++ b/src/test/resources/SimpleTests/FieldVar.java @@ -1,5 +1,5 @@ class FieldVar { - int field; + int variable; } diff --git a/src/test/resources/SimpleTests/FieldVar.tokens b/src/test/resources/SimpleTests/FieldVar.tokens index c051299..ef2cd13 100644 --- a/src/test/resources/SimpleTests/FieldVar.tokens +++ b/src/test/resources/SimpleTests/FieldVar.tokens @@ -2,7 +2,7 @@ Class: "class" Identifier: "FieldVar" OpenCurlyBracket: "{" Int: "int" -Identifier: "field" +Identifier: "variable" Semicolon: ";" ClosedCurlyBracket: "}" EOF: "" \ No newline at end of file From 8d4e8a92698afe4e2f366ac1771f7a90f491e64f Mon Sep 17 00:00:00 2001 From: KingJulian Date: Fri, 5 Jul 2024 12:36:10 +0200 Subject: [PATCH 2/2] Moved DivTest --- src/test/java/ByteCode/TestAll.java | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/src/test/java/ByteCode/TestAll.java b/src/test/java/ByteCode/TestAll.java index e60a0d6..16801b8 100644 --- a/src/test/java/ByteCode/TestAll.java +++ b/src/test/java/ByteCode/TestAll.java @@ -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"; - //byteCodeTester.testByteCodeFromAst(classPath, ast ,className); - byteCodeTester.testClassFileFromScratch(classPath, javacode, className); - } // We dont do null assignments /* @@ -146,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";