revisit tests

Author: ftomassetti

src/test/kotlin/IntermediateToJavaTest.kt

@@ -0,0 +1,50 @@
+import com.github.javaparser.ast.expr.AssignExpr
+import com.github.javaparser.ast.expr.FieldAccessExpr
+import com.github.javaparser.ast.expr.IntegerLiteralExpr
+import com.github.javaparser.ast.expr.ThisExpr
+import com.github.javaparser.ast.type.PrimitiveType
+import com.strumenta.rpgtojava.intermediateast.*
+import com.strumenta.rpgtojava.transformations.transformFromIntermediateToJava
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import com.github.javaparser.ast.CompilationUnit as JavaCU
+
+class IntermediateToJavaTest {
+
+    @Test
+    fun simpleGlobalVariable() {
+        val intermediateProgram = GProgram("Test", globalVariables = mutableListOf(GGlobalVariable("NBR", GIntegerType)))
+        val actualJavaCu = transformFromIntermediateToJava(intermediateProgram)
+        val expectedJavaCu = JavaCU()
+        val expectedJavaClass = expectedJavaCu.addClass("Test")
+        expectedJavaClass.addField(PrimitiveType.longType(), "NBR").setPrivate(true)
+        expectedJavaClass.addMethod("executeProgram")
+        assertEquals(expectedJavaCu, actualJavaCu)
+    }
+
+    @Test
+    fun simpleStatement() {
+        val intermediateProgram = GProgram("Test",
+                globalVariables = mutableListOf(GGlobalVariable("NBR", GIntegerType)))
+        intermediateProgram.mainFunction.body.add(GAssignment(GGlobalVariableTarget(intermediateProgram.globalVariables[0]), GIntegerLiteral(123L)))
+        val actualJavaCu = transformFromIntermediateToJava(intermediateProgram)
+        val expectedJavaCu = JavaCU()
+        val expectedJavaClass = expectedJavaCu.addClass("Test")
+        expectedJavaClass.addField(PrimitiveType.longType(), "NBR").setPrivate(true)
+        val executeProgram = expectedJavaClass.addMethod("executeProgram")
+        executeProgram.body.get().addStatement(AssignExpr(FieldAccessExpr(ThisExpr(), "NBR"), IntegerLiteralExpr("123"), AssignExpr.Operator.ASSIGN))
+        assertEquals(expectedJavaCu, actualJavaCu)
+    }
+
+    @Test
+    fun emptySupportFunction() {
+        val intermediateProgram = GProgram("Test", otherFunctions = mutableListOf(GFunction("FIB")))
+        val actualJavaCu = transformFromIntermediateToJava(intermediateProgram)
+        val expectedJavaCu = JavaCU()
+        val expectedJavaClass = expectedJavaCu.addClass("Test")
+        expectedJavaClass.addMethod("executeProgram")
+        expectedJavaClass.addMethod("FIB")
+        assertEquals(expectedJavaCu, actualJavaCu)
+    }
+
+}

src/test/kotlin/RpgToIntermediateTest.kt

@@ -1,24 +1,32 @@
 import com.strumenta.kolasu.parsing.toStream
 import com.strumenta.rpgtojava.intermediateast.*
 import com.strumenta.rpgtojava.transformRpgToIntermediate
-import com.strumenta.rpgtojava.transpileRpgToJava
-import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.Assertions.*
 
 class RpgToIntermediateTest {
 
     @Test
     fun simpleGlobalVariable() {
-        val program = transformRpgToIntermediate("""     D NBR             S              8  0""".toStream(), "Test")
-        assertEquals(GProgram("Test", globalVariables = mutableListOf(GGlobalVariable("NBR", GIntegerType))), program)
+        val actualGProgram = transformRpgToIntermediate("""     D NBR             S              8  0""".toStream(), "Test")
+        assertEquals(GProgram("Test", globalVariables = mutableListOf(GGlobalVariable("NBR", GIntegerType))), actualGProgram)
     }
 
     @Test
-    fun simpleFunctions() {
-        val program = transformRpgToIntermediate("""     C     FIB           BEGSR
+    fun simpleStatement() {
+        val actualGProgram = transformRpgToIntermediate("""     D NBR             S              8  0
+     C                   EVAL      NBR = 123""".toStream(), "Test")
+        val expectedGProgram = GProgram("Test",
+                globalVariables = mutableListOf(GGlobalVariable("NBR", GIntegerType)))
+        expectedGProgram.mainFunction.body.add(GAssignment(GGlobalVariableTarget(expectedGProgram.globalVariables[0]), GIntegerLiteral(123L)))
+        assertEquals(expectedGProgram, actualGProgram)
+    }
+
+    @Test
+    fun emptySupportFunction() {
+        val actualGProgram = transformRpgToIntermediate("""     C     FIB           BEGSR
      C                   ENDSR""".toStream(), "Test")
-        assertEquals(GProgram("Test", otherFunctions = mutableListOf(GFunction("FIB"))), program)
+        assertEquals(GProgram("Test", otherFunctions = mutableListOf(GFunction("FIB"))), actualGProgram)
     }
 
 }