9 files changed, 438 insertions, 0 deletions
diff --git a/src/cz/crcs/ectester/common/test/BaseTestable.java b/src/cz/crcs/ectester/common/test/BaseTestable.java
new file mode 100644
index 0000000..a4b9a00
--- /dev/null
+++ b/src/cz/crcs/ectester/common/test/BaseTestable.java
@@ -0,0 +1,32 @@
+package cz.crcs.ectester.common.test;
+
+/**
+ * @author Jan Jancar johny@neuromancer.sk
+ */
+public abstract class BaseTestable implements Testable {
+    protected boolean hasRun;
+    protected boolean ok;
+    protected boolean error;
+
+    @Override
+    public boolean hasRun() {
+        return hasRun;
+    }
+
+    @Override
+    public boolean ok() {
+        return ok;
+    }
+
+    @Override
+    public boolean error() {
+        return error;
+    }
+
+    @Override
+    public void reset() {
+        hasRun = false;
+        ok = false;
+        error = false;
+    }
+}
diff --git a/src/cz/crcs/ectester/common/test/CompoundTest.java b/src/cz/crcs/ectester/common/test/CompoundTest.java
new file mode 100644
index 0000000..10ecf9c
--- /dev/null
+++ b/src/cz/crcs/ectester/common/test/CompoundTest.java
@@ -0,0 +1,111 @@
+package cz.crcs.ectester.common.test;
+
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * A compound test that runs many Tests and has a Result dependent on all/some of their Results.
+ *
+ * @author Jan Jancar johny@neuromancer.sk
+ */
+public class CompoundTest extends Test {
+    private Function<Test[], Result> callback;
+    private Test[] tests;
+    private String description;
+
+    private CompoundTest(Function<Test[], Result> callback, Test... tests) {
+        this.callback = callback;
+        this.tests = Arrays.stream(tests).filter(Objects::nonNull).toArray(Test[]::new);
+    }
+
+    private CompoundTest(Function<Test[], Result> callback, String descripiton, Test... tests) {
+        this(callback, tests);
+        this.description = descripiton;
+    }
+
+    public static CompoundTest function(Function<Test[], Result> callback, Test... tests) {
+        return new CompoundTest(callback, tests);
+    }
+
+    public static CompoundTest function(Function<Test[], Result> callback, String description, Test... tests) {
+        return new CompoundTest(callback, description, tests);
+    }
+
+    public static CompoundTest all(Result.ExpectedValue what, Test... all) {
+        return new CompoundTest((tests) -> {
+            for (Test test : tests) {
+                if (!Result.Value.fromExpected(what, test.ok()).ok()) {
+                    return new Result(Result.Value.FAILURE, "Some sub-tests did not have the expected result.");
+                }
+            }
+            return new Result(Result.Value.SUCCESS, "All sub-tests had the expected result.");
+        }, all);
+    }
+
+    public static CompoundTest all(Result.ExpectedValue what, String description, Test... all) {
+        CompoundTest result = CompoundTest.all(what, all);
+        result.setDescription(description);
+        return result;
+    }
+
+    public static CompoundTest any(Result.ExpectedValue what, Test... any) {
+        return new CompoundTest((tests) -> {
+            for (Test test : tests) {
+                if (Result.Value.fromExpected(what, test.ok()).ok()) {
+                    return new Result(Result.Value.SUCCESS, "Some sub-tests did have the expected result.");
+                }
+            }
+            return new Result(Result.Value.FAILURE, "None of the sub-tests had the expected result.");
+        }, any);
+    }
+
+    public static CompoundTest any(Result.ExpectedValue what, String description, Test... any) {
+        CompoundTest result = CompoundTest.any(what, any);
+        result.setDescription(description);
+        return result;
+    }
+
+    public static CompoundTest mask(Result.ExpectedValue[] results, Test... masked) {
+        return new CompoundTest((tests) -> {
+            for (int i = 0; i < results.length; ++i) {
+                if (!Result.Value.fromExpected(results[i], tests[i].ok()).ok()) {
+                    return new Result(Result.Value.FAILURE, "Some sub-tests did not match the result mask.");
+                }
+            }
+            return new Result(Result.Value.SUCCESS, "All sub-tests matched the expected mask.");
+        }, masked);
+    }
+
+    public static CompoundTest mask(Result.ExpectedValue[] results, String description, Test... masked) {
+        CompoundTest result = CompoundTest.mask(results, masked);
+        result.setDescription(description);
+        return result;
+    }
+
+    public Test[] getTests() {
+        return tests;
+    }
+
+    @Override
+    public void run() throws TestException {
+        if (hasRun)
+            return;
+
+        for (Test test : tests) {
+            test.run();
+        }
+
+        result = callback.apply(tests);
+        this.hasRun = true;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public String getDescription() {
+        return description;
+    }
+}
diff --git a/src/cz/crcs/ectester/common/test/Result.java b/src/cz/crcs/ectester/common/test/Result.java
new file mode 100644
index 0000000..11fcb4d
--- /dev/null
+++ b/src/cz/crcs/ectester/common/test/Result.java
@@ -0,0 +1,96 @@
+package cz.crcs.ectester.common.test;
+
+/**
+ * A Result of a Test. Has a Value and an optional String cause.
+ *
+ * @author Jan Jancar johny@neuromancer.sk
+ */
+public class Result {
+
+    private Value value;
+    private String cause;
+
+    public Result(Value value) {
+        this.value = value;
+    }
+
+    public Result(Value value, String cause) {
+        this(value);
+        this.cause = cause;
+    }
+
+    public Value getValue() {
+        return value;
+    }
+
+    public String getCause() {
+        return cause;
+    }
+
+    public boolean ok() {
+        return value.ok();
+    }
+
+    public boolean compareTo(Result other) {
+        if (other == null) {
+            return false;
+        }
+        return value == other.value;
+    }
+
+    public boolean compareTo(Value other) {
+        if (other == null) {
+            return false;
+        }
+        return value == other;
+    }
+
+    /**
+     * A result value of a Test.
+     */
+    public enum Value {
+        SUCCESS(true),
+        FAILURE(false),
+        UXSUCCESS(false),
+        XFAILURE(true),
+        ERROR(false);
+
+        private boolean ok;
+
+        Value(boolean ok) {
+            this.ok = ok;
+        }
+
+        public static Value fromExpected(ExpectedValue expected, boolean successful) {
+            switch (expected) {
+                case SUCCESS:
+                    return successful ? SUCCESS : FAILURE;
+                case FAILURE:
+                    return successful ? UXSUCCESS : XFAILURE;
+                case ANY:
+                    return SUCCESS;
+            }
+            return SUCCESS;
+        }
+
+        public static Value fromExpected(ExpectedValue expected, boolean successful, boolean error) {
+            if (error) {
+                return ERROR;
+            }
+            return fromExpected(expected, successful);
+        }
+
+        public boolean ok() {
+            return ok;
+        }
+    }
+
+    /**
+     * A possible expected value result of a Test.
+     */
+    public enum ExpectedValue {
+        SUCCESS,
+        FAILURE,
+        ANY
+    }
+}
diff --git a/src/cz/crcs/ectester/common/test/SimpleTest.java b/src/cz/crcs/ectester/common/test/SimpleTest.java
new file mode 100644
index 0000000..f68320a
--- /dev/null
+++ b/src/cz/crcs/ectester/common/test/SimpleTest.java
@@ -0,0 +1,19 @@
+package cz.crcs.ectester.common.test;
+
+/**
+ * @param <T>
+ * @author Jan Jancar johny@neuromancer.sk
+ */
+public abstract class SimpleTest<T extends BaseTestable> extends Test {
+    protected T testable;
+    protected TestCallback<T> callback;
+
+    public SimpleTest(T testable, TestCallback<T> callback) {
+        this.testable = testable;
+        this.callback = callback;
+    }
+
+    public T getTestable() {
+        return testable;
+    }
+}
diff --git a/src/cz/crcs/ectester/common/test/Test.java b/src/cz/crcs/ectester/common/test/Test.java
new file mode 100644
index 0000000..3d0baf6
--- /dev/null
+++ b/src/cz/crcs/ectester/common/test/Test.java
@@ -0,0 +1,66 @@
+package cz.crcs.ectester.common.test;
+
+import static cz.crcs.ectester.common.test.Result.Value;
+
+/**
+ * An abstract test that can be run and has a Result.
+ *
+ * @author Jan Jancar johny@neuromancer.sk
+ */
+public abstract class Test implements Testable {
+    protected boolean hasRun;
+    protected Result result;
+
+    public Result getResult() {
+        if (!hasRun) {
+            return null;
+        }
+        return result;
+    }
+
+    public Value getResultValue() {
+        if (!hasRun) {
+            return null;
+        }
+        return result.getValue();
+    }
+
+    public String getResultCause() {
+        if (!hasRun) {
+            return null;
+        }
+        return result.getCause();
+    }
+
+    public boolean ok() {
+        if (!hasRun) {
+            return true;
+        }
+        return result.ok();
+    }
+
+    @Override
+    public boolean error() {
+        if (!hasRun) {
+            return false;
+        }
+        return result.compareTo(Value.ERROR);
+    }
+
+    @Override
+    public boolean hasRun() {
+        return hasRun;
+    }
+
+    @Override
+    public void reset() {
+        hasRun = false;
+        result = null;
+    }
+
+    public abstract String getDescription();
+
+    @Override
+    public abstract void run() throws TestException;
+
+}
diff --git a/src/cz/crcs/ectester/common/test/TestCallback.java b/src/cz/crcs/ectester/common/test/TestCallback.java
new file mode 100644
index 0000000..ce6000b
--- /dev/null
+++ b/src/cz/crcs/ectester/common/test/TestCallback.java
@@ -0,0 +1,12 @@
+package cz.crcs.ectester.common.test;
+
+import java.util.function.Function;
+
+/**
+ *
+ * @author Jan Jancar johny@neuromancer.sk
+ * @param <T>
+ */
+public abstract class TestCallback<T extends Testable> implements Function<T, Result> {
+
+}
diff --git a/src/cz/crcs/ectester/common/test/TestException.java b/src/cz/crcs/ectester/common/test/TestException.java
new file mode 100644
index 0000000..008e9f6
--- /dev/null
+++ b/src/cz/crcs/ectester/common/test/TestException.java
@@ -0,0 +1,13 @@
+package cz.crcs.ectester.common.test;
+
+/**
+ * A TestException is an Exception that can be thrown during the running of a Testable,
+ * or a TestSuite. It means that the Testable/TestSuite encountered an unexpected error
+ * during it's run which points to an error in ECTester or it's runtime environment.cd
+ * @author Jan Jancar johny@neuromancer.sk
+ */
+public class TestException extends Exception {
+    public TestException(Throwable e) {
+        super(e);
+    }
+}
diff --git a/src/cz/crcs/ectester/common/test/TestSuite.java b/src/cz/crcs/ectester/common/test/TestSuite.java
new file mode 100644
index 0000000..f4f30ee
--- /dev/null
+++ b/src/cz/crcs/ectester/common/test/TestSuite.java
@@ -0,0 +1,56 @@
+package cz.crcs.ectester.common.test;
+
+import cz.crcs.ectester.common.output.TestWriter;
+import cz.crcs.ectester.data.EC_Store;
+
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author Jan Jancar johny@neuromancer.sk
+ */
+public abstract class TestSuite {
+    protected String name;
+    protected String description;
+    protected TestWriter writer;
+
+    public TestSuite(TestWriter writer, String name, String description) {
+        this.writer = writer;
+        this.name = name;
+        this.description = description;
+    }
+
+    public void run() throws TestException {
+        writer.begin(this);
+        try {
+            runTests();
+        } catch (Exception e) {
+            throw new TestException(e);
+        }
+        writer.end();
+    }
+
+    protected Test runTest(Test t) throws TestException {
+        t.run();
+        return t;
+    }
+
+    protected Test doTest(Test t) throws TestException {
+        t.run();
+        writer.outputTest(t);
+        return t;
+    }
+
+    protected abstract void runTests() throws Exception;
+
+    public String getName() {
+        return name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+}
diff --git a/src/cz/crcs/ectester/common/test/Testable.java b/src/cz/crcs/ectester/common/test/Testable.java
new file mode 100644
index 0000000..33c9485
--- /dev/null
+++ b/src/cz/crcs/ectester/common/test/Testable.java
@@ -0,0 +1,33 @@
+package cz.crcs.ectester.common.test;
+
+/**
+ * @author Jan Jancar johny@neuromancer.sk
+ */
+public interface Testable {
+    /**
+     * @return Whether this Testable was OK.
+     */
+    boolean ok();
+
+    /**
+     * @return Whether an error happened.
+     */
+    boolean error();
+
+    /**
+     * @return Whether this runnable was run.
+     */
+    boolean hasRun();
+
+    /**
+     *
+     */
+    void reset();
+
+    /**
+     * Run this Runnable.
+     *
+     * @throws TestException If an unexpected exception/error is encountered.
+     */
+    void run() throws TestException;
+}