Юнит-тесты для программ

Author: aNNiMON

test/com/annimon/ownlang/parser/ProgramsTest.java

@@ -0,0 +1,101 @@
+package com.annimon.ownlang.parser;
+
+import com.annimon.ownlang.lib.Functions;
+import com.annimon.ownlang.lib.NumberValue;
+import com.annimon.ownlang.lib.Variables;
+import com.annimon.ownlang.parser.ast.FunctionDefineStatement;
+import com.annimon.ownlang.parser.ast.Statement;
+import com.annimon.ownlang.parser.ast.Visitor;
+import com.annimon.ownlang.parser.visitors.AbstractVisitor;
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.junit.Assert;
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(value = Parameterized.class)
+public class ProgramsTest {
+
+    private static final String RES_DIR = "test/resources";
+
+    private final String programPath;
+
+    public ProgramsTest(String programPath) {
+        this.programPath = programPath;
+    }
+
+    @Parameters(name = "{index}: {0}")
+    public static Collection<String> data() {
+        final File resDir = new File(RES_DIR);
+        return scanDirectory(resDir)
+                .map(f -> f.getPath())
+                .collect(Collectors.toList());
+    }
+
+    private static Stream<File> scanDirectory(File dir) {
+        return Arrays.stream(dir.listFiles())
+                .flatMap(file -> {
+                    if (file.isDirectory()) {
+                        return scanDirectory(file);
+                    }
+                    return Stream.of(file);
+                })
+                .filter(f -> f.getName().endsWith(".own"));
+    }
+
+    @Before
+    public void initialize() {
+        Variables.clear();
+        Functions.getFunctions().clear();
+        // Let's mock junit methods as ounit functions
+        Functions.set("assertEquals", (args) -> {
+            assertEquals(args[0], args[1]);
+            return NumberValue.ONE;
+        });
+        Functions.set("assertNotEquals", (args) -> {
+            assertNotEquals(args[0], args[1]);
+            return NumberValue.ONE;
+        });
+        Functions.set("assertSameType", (args) -> {
+            assertEquals(args[0].type(), args[1].type());
+            return NumberValue.ONE;
+        });
+        Functions.set("assertTrue", (args) -> {
+            assertTrue(args[0].asInt() != 0);
+            return NumberValue.ONE;
+        });
+        Functions.set("assertFalse", (args) -> {
+            assertFalse(args[0].asInt() == 0);
+            return NumberValue.ONE;
+        });
+    }
+
+    @Test
+    public void testProgram() throws IOException {
+        final String source = SourceLoader.readSource(programPath);
+        final Statement s = Parser.parse(Lexer.tokenize(source));
+        try {
+            s.execute();
+            s.accept(testFunctionsExecutor);
+        } catch (Exception oae) {
+            Assert.fail(oae.toString());
+        }
+    }
+
+    private static Visitor testFunctionsExecutor = new AbstractVisitor() {
+        @Override
+        public void visit(FunctionDefineStatement s) {
+            if (s.name.startsWith("test")) {
+                Functions.get(s.name).execute();
+            }
+        }
+    };
+}

test/resources/expressions/assignmentExpression.own

@@ -0,0 +1,30 @@
+def testSimpleAssignment() {
+  a = 8
+  b = "str"
+  assertEquals(8, a)
+  assertEquals("str", b)
+}
+
+def testPrefixIncrement() {
+  a = 8
+  assertEquals(9, ++a)
+  assertEquals(9, a)
+}
+
+def testPostfixIncrement() {
+  a = 8
+  assertEquals(8, a++)
+  assertEquals(9, a)
+}
+
+def testPrefixDecrement() {
+  a = 8
+  assertEquals(7, --a)
+  assertEquals(7, a)
+}
+
+def testPostfixDecrement() {
+  a = 8
+  assertEquals(8, a--)
+  assertEquals(7, a)
+}

test/resources/expressions/binaryExpressionOnNumbers.own

@@ -0,0 +1,37 @@
+def testAdditionOnNumbers() {
+  assertEquals(4, 2 + 2)
+  assertEquals(6, 0 + 1 + 2 + 3)
+}
+
+def testSubtractionOnNumbers() {
+  assertEquals(0, 2 - 2)
+  assertEquals(-6, 0 - 1 - 2 - 3)
+  assertEquals(110, 100 - (20 - 30))
+}
+
+def testMultiplicationOnNumbers() {
+  assertEquals(4, 2 * 2)
+  assertEquals(30, 5 * (-2 * -3))
+}
+
+def testDivisionOnNumbers() {
+  assertEquals(3, 6 / 2)
+  assertEquals(30, -900 / (60 / -2))
+}
+
+def testRemainder() {
+  assertEquals(2, 10 % 4)
+  assertEquals(5, 15 % (40 % 30))
+}
+
+def testAND() {
+  assertEquals(0x04, 0x04 & 0x0F)
+  assertEquals(0x00, 0x04 & 0x08)
+  assertEquals(8, 12 & 9)
+}
+
+def testOR() {
+  assertEquals(12, 4 | 8)
+  assertEquals(0x0F, 3 | 12)
+  assertEquals(0x0E, 10 | 4)
+}

test/resources/expressions/binaryExpressionOnStrings.own

@@ -0,0 +1,8 @@
+def testStringConcatenation() {
+  assertEquals("22", "2" + "2")
+  assertEquals("22", "2" + 2)
+}
+
+def testStringMultiplication() {
+  assertEquals("******", "*" * 6)
+}

test/resources/expressions/binaryUnaryExpr.own

@@ -0,0 +1,27 @@
+def testAdditionOnNumbers() {
+  assertEquals(6, 0 + 1 + 2 + 3)
+}
+
+def testSubtractionOnNumbers() {
+  assertEquals(-6, 0 - 1 - 2 - 3)
+}
+
+def testPrefixIncrement() {
+  a = 8
+  assertEquals(9, ++a)
+  assertEquals(9, a)
+}
+
+def testPostfixIncrement() {
+  a = 8
+  assertEquals(8, a++)
+  assertEquals(9, a)
+}
+
+def testStringReversing() {
+  assertEquals("tset", -"test")
+}
+
+def testStringMultiplication() {
+  assertEquals("******", "*" * 6)
+}

test/resources/expressions/functionReference.own

@@ -0,0 +1,6 @@
+def func() = "function"
+var = def() = "variable"
+def consumer(x) = x();
+
+assertEquals("function", consumer(::func))
+assertEquals("variable", consumer(var))

test/resources/expressions/unaryExpressionOnStrings.own

@@ -0,0 +1,3 @@
+def testStringReversing() {
+  assertEquals("tset", -"test")
+}

test/resources/expressions/varFuncSameName.own

@@ -0,0 +1,5 @@
+def function() = "function"
+function = "variable"
+
+assertEquals("variable", function)
+assertEquals("function", function())

test/resources/modules/date/compareDates.own

@@ -0,0 +1,7 @@
+use "date"
+
+def testCompareDates() {
+  assertTrue(newDate(2016, 04, 10) > newDate(2015, 03, 11))
+  assertTrue(newDate(2012, 04, 10) < newDate(2015, 03, 11))
+  assertTrue(newDate(2015, 03, 11, 0, 0, 0) == newDate(2015, 03, 11))
+}

test/resources/modules/date/dateFormat.own

@@ -0,0 +1,6 @@
+use "date"
+
+def testDateFormat() {
+  d = formatDate(newDate(2016, 04, 10), newFormat("yyyy/MM/dd HH:mm:ss"))
+  assertEquals("2016/05/10 00:00:00", d)
+}