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

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)
+}

test/resources/modules/date/dateParse.own

@@ -0,0 +1,9 @@
+use "date"
+
+def testDateParse() {
+  d = parseDate("2016/05/10", newFormat("yyyy/MM/dd"))
+  assertEquals(2016, d.year)
+  assertEquals(4, d.month)
+  assertEquals(10, d.day)
+  assertEquals(0, d.hour)
+}

test/resources/modules/date/newDate.own

@@ -0,0 +1,12 @@
+use "date"
+
+def testNewDate() {
+  d = newDate(2016, 04, 10)
+  assertEquals(2016, d.year)
+  assertEquals(4, d.month)
+  assertEquals(10, d.day)
+  assertEquals(0, d.hour)
+  assertEquals(0, d.minute)
+  assertEquals(0, d.second)
+  assertEquals(0, d.millisecond)
+}

test/resources/modules/files/files.own

@@ -0,0 +1,28 @@
+use "files"
+use "types"
+
+def testFiles() {
+  // writeLong
+  f = fopen("test.file", "wb")
+  writeLong(f, 1002003004005006007)
+  flush(f)
+  fclose(f)
+
+  // append & writeFloat
+  fpNumber = 100200.3004005006007
+  f = fopen("test.file", "wb+")
+  writeFloat(f, fpNumber)
+  flush(f)
+  fclose(f)
+
+  f = fopen("test.file", "rb")
+  assertEquals(1002003004005006007, readLong(f))
+  assertEquals(float(fpNumber), readFloat(f))
+  assertEquals(-1, readInt(f)) // EOF
+  assertEquals(0, FILES_COMPARATOR(f, f))
+  fclose(f)
+
+  f = fopen("test.file", "i")
+  delete(f)
+  fclose(f)
+}

test/resources/modules/functional/chain.own

@@ -0,0 +1,11 @@
+use "functional"
+
+def testFunctionalChain() {
+  data = [1,2,3,4,5,6,7]
+  result = chain(data,
+    ::filter, def(x) = x <= 4,
+    ::sortby, def(x) = -x,
+    ::map,    def(x) = x * 2,
+  )
+  assertEquals([8,6,4,2], result)
+}

test/resources/other/recursion.own

@@ -0,0 +1,8 @@
+def testFibonacci() {
+  def fib(n) {
+    if n < 2 return n
+    return fib(n-2) + fib(n-1)
+  }
+  assertEquals(3, fib(4))
+  assertEquals(21, fib(8))
+}

test/resources/other/scope.own

@@ -0,0 +1,10 @@
+def testScope() {
+  x = 5
+  def func() {
+    assertEquals(5, x)
+    x += 10
+    assertEquals(15, x)
+  }
+  func();
+  assertEquals(15, x)
+}

test/resources/other/types.own

@@ -0,0 +1,3 @@
+def testTypes() {
+  assertSameType(0, 0.0)
+}