Add the CI/CD configuration for Gradle and Maven build.

build.gradle

@@ -12,18 +12,12 @@ java {
     }
 }
 
-compileJava {
-    options.encoding = 'UTF-8'
-}
-
 repositories {
   // Spock releases are available from Maven Central
   mavenCentral()
 }
 
 dependencies {
-  implementation 'com.google.guava:guava:32.1.2-jre'
-  implementation 'org.apache.commons:commons-lang3:3.13.0'
   // mandatory dependencies for using Spock
   implementation platform('org.apache.groovy:groovy-bom:4.0.15')
   implementation 'org.apache.groovy:groovy'

pom.xml

@@ -12,8 +12,6 @@
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
     <groovy.version>4.0.15</groovy.version>
-    <maven.compiler.source>17</maven.compiler.source>
-    <maven.compiler.target>17</maven.compiler.target>
   </properties>
 
   <build>
@@ -79,16 +77,6 @@
   </dependencyManagement>
 
   <dependencies>
-    <dependency>
-      <groupId>com.google.guava</groupId>
-      <artifactId>guava</artifactId>
-      <version>32.1.2-jre</version>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.commons</groupId>
-      <artifactId>commons-lang3</artifactId>
-      <version>3.13.0</version>
-    </dependency>
     <!-- Mandatory dependencies for using Spock -->
     <dependency>
       <groupId>org.spockframework</groupId>

src/main/java/space/kklochko/simple_jbdd/Main.java

@@ -1,24 +0,0 @@
-package space.kklochko.simple_jbdd;
-
-import space.kklochko.simple_jbdd.tests.factories.AbstractTestRunnerFactory;
-import space.kklochko.simple_jbdd.tests.factories.SimpleTestRunnerFactory;
-import space.kklochko.simple_jbdd.tests.loaders.NameClassLoader;
-import space.kklochko.simple_jbdd.tests.reports.AbstractReporter;
-import space.kklochko.simple_jbdd.tests.reports.CLIReporter;
-import space.kklochko.simple_jbdd.tests.reports.fmt.SimpleTestReportFormatter;
-import space.kklochko.simple_jbdd.tests.runners.CLITestRunner;
-
-public class Main {
-    public static void main(String[] args) {
-        NameClassLoader loader = new NameClassLoader();
-        AbstractTestRunnerFactory testRunnerFactory = new SimpleTestRunnerFactory();
-        AbstractReporter reporter = new CLIReporter(new SimpleTestReportFormatter());
-
-        CLITestRunner runner = new CLITestRunner(loader, testRunnerFactory, reporter);
-
-        boolean status = runner.run();
-
-        System.exit(status ? 0 : 1);
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/annotations/Title.java

@@ -1,13 +0,0 @@
-package space.kklochko.simple_jbdd.annotations;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
-public @interface Title {
-    String value() default "Title";
-}
-

src/main/java/space/kklochko/simple_jbdd/test_examples/tests/SimpleEmptyTest.java

@@ -1,12 +0,0 @@
-package space.kklochko.simple_jbdd.test_examples.tests;
-
-import space.kklochko.simple_jbdd.annotations.Title;
-import space.kklochko.simple_jbdd.tests.Test;
-
-@Title("A Simple Empty Test for Sum")
-public class SimpleEmptyTest extends Test {
-    public void check() {
-        assert 30 == 10 + 20 + 1;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/test_examples/tests/SimpleFailedThenTest.java

@@ -1,11 +1,8 @@
 package space.kklochko.simple_jbdd.test_examples.tests;
 
 import space.kklochko.simple_jbdd.annotations.Then;
-import space.kklochko.simple_jbdd.annotations.Title;
 import space.kklochko.simple_jbdd.tests.Test;
 
-
-@Title("A Simple Failed Then Test for Sum")
 public class SimpleFailedThenTest extends Test {
     @Then
     public void check() {

src/main/java/space/kklochko/simple_jbdd/test_examples/tests/SimpleGivenGivenWhenWhenThenThenTest.java

@@ -1,51 +0,0 @@
-package space.kklochko.simple_jbdd.test_examples.tests;
-
-import space.kklochko.simple_jbdd.annotations.Given;
-import space.kklochko.simple_jbdd.annotations.Then;
-import space.kklochko.simple_jbdd.annotations.Title;
-import space.kklochko.simple_jbdd.annotations.When;
-import space.kklochko.simple_jbdd.test_examples.samples.Sum;
-import space.kklochko.simple_jbdd.tests.Test;
-
-@Title("A Simple GivenGivenWhenWhenThenThen Test for Sum")
-public class SimpleGivenGivenWhenWhenThenThenTest extends Test {
-    private Sum sum;
-    private int a;
-    private int b;
-    private int c;
-    private int resultAB;
-    private int resultCB;
-
-    @Given("Create the Sum object")
-    void setup() {
-        sum = new Sum();
-    }
-
-    @Given("Setup the arguments")
-    void setupArgs() {
-        a = 10;
-        b = 20;
-        c = 30;
-    }
-
-    @When("Call the .sum(10, 20)")
-    void triggerAB() {
-        resultAB = sum.sum(a, b);
-    }
-
-    @When("Call the .sum(30, 20)")
-    void triggerCB() {
-        resultCB = sum.sum(c, b);
-    }
-
-    @Then("10 + 20 is 30")
-    void checkAB() {
-        assert 30 == resultAB;
-    }
-
-    @Then("30 + 20 is 50")
-    void checkCB() {
-        assert 50 == resultCB;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/test_examples/tests/SimpleGivenWhenThenTest.java

@@ -2,12 +2,10 @@ package space.kklochko.simple_jbdd.test_examples.tests;
 
 import space.kklochko.simple_jbdd.annotations.Given;
 import space.kklochko.simple_jbdd.annotations.Then;
-import space.kklochko.simple_jbdd.annotations.Title;
 import space.kklochko.simple_jbdd.annotations.When;
 import space.kklochko.simple_jbdd.test_examples.samples.Sum;
 import space.kklochko.simple_jbdd.tests.Test;
 
-@Title("A Simple GivenWhenThen Test for Sum")
 public class SimpleGivenWhenThenTest extends Test {
     private Sum sum;
     private int a;

src/main/java/space/kklochko/simple_jbdd/test_examples/tests/SimpleThenTest.java

@@ -1,12 +1,10 @@
 package space.kklochko.simple_jbdd.test_examples.tests;
 
 import space.kklochko.simple_jbdd.annotations.Then;
-import space.kklochko.simple_jbdd.annotations.Title;
 import space.kklochko.simple_jbdd.tests.Test;
 
-@Title("Simple test")
 public class SimpleThenTest extends Test {
-    @Then("The sum of 10 and 20 is 30.")
+    @Then
     public void check() {
         assert 30 == 10 + 20;
     }

src/main/java/space/kklochko/simple_jbdd/test_examples/tests/SimpleThenTestWithoutTitle.java

@@ -1,13 +0,0 @@
-package space.kklochko.simple_jbdd.test_examples.tests;
-
-import space.kklochko.simple_jbdd.annotations.Then;
-import space.kklochko.simple_jbdd.annotations.Title;
-import space.kklochko.simple_jbdd.tests.Test;
-
-public class SimpleThenTestWithoutTitle extends Test {
-    @Then("The sum of 10 and 20 is 30.")
-    public void check() {
-        assert 30 == 10 + 20;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/commands/AbstractTestCommand.java

@@ -1,43 +0,0 @@
-package space.kklochko.simple_jbdd.tests.commands;
-
-import space.kklochko.simple_jbdd.tests.Test;
-import java.util.Map;
-import java.util.TreeMap;
-
-public abstract class AbstractTestCommand<T extends Test> {
-    protected String type;
-    protected String label;
-
-    public AbstractTestCommand(String label) {
-        setLabel(label);
-    }
-
-    public abstract boolean test();
-
-    public Map<String, String> getLabels() {
-        Map<String, String> labels = new TreeMap<String, String>();
-        labels.put(getType(), this.getLabel());
-        return labels;
-    }
-
-    public String getType() {
-        return type;
-    }
-
-    public void setType(String type) {
-        this.type = type;
-    }
-
-    public void setLabel(String label) {
-        this.label = label;
-    }
-
-    public String getLabel() {
-        return label;
-    }
-
-    public abstract void setObject(T object);
-
-    public abstract T getObject();
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/commands/SimpleTestCommand.java

@@ -1,27 +0,0 @@
-package space.kklochko.simple_jbdd.tests.commands;
-
-import space.kklochko.simple_jbdd.tests.Test;
-
-public class SimpleTestCommand<T extends Test> extends AbstractTestCommand<T> {
-    protected T object;
-
-    public SimpleTestCommand(String label, T object) {
-        super(label);
-        setObject(object);
-        setType("Title");
-    }
-
-    @Override
-    public boolean test() {
-        return true;
-    }
-
-    public void setObject(T object) {
-        this.object = object;
-    }
-
-    public T getObject() {
-        return object;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/commands/decorators/AbstractDecorator.java

@@ -1,55 +0,0 @@
-package space.kklochko.simple_jbdd.tests.commands.decorators;
-
-import space.kklochko.simple_jbdd.tests.Test;
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
-
-import java.lang.reflect.Method;
-import java.util.Map;
-
-public abstract class AbstractDecorator<T extends Test> extends AbstractTestCommand<T> {
-    protected AbstractTestCommand<T> command;
-
-    protected Method method;
-
-    public AbstractDecorator(String label, AbstractTestCommand<T> command) {
-        super(label);
-        setCommand(command);
-    }
-
-    public abstract boolean test();
-
-    public Map<String, String> getLabels() {
-        Map<String, String> labels = getCommand().getLabels();
-        labels.put(getType(), this.getLabel());
-        return labels;
-    }
-
-    public abstract boolean runMethod();
-
-    public void setMethod(Method method) {
-        this.method = method;
-    }
-
-    public Method getMethod() {
-        return method;
-    }
-
-    @Override
-    public void setObject(T object) {
-        command.setObject(object);
-    }
-
-    @Override
-    public T getObject() {
-        return command.getObject();
-    }
-
-    public AbstractTestCommand<T> getCommand() {
-        return command;
-    }
-
-    public void setCommand(AbstractTestCommand<T> command) {
-        this.command = command;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/commands/decorators/BlockDecorator.java

@@ -1,44 +0,0 @@
-package space.kklochko.simple_jbdd.tests.commands.decorators;
-
-import space.kklochko.simple_jbdd.tests.Test;
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-public class BlockDecorator<T extends Test> extends AbstractDecorator<T> {
-    public BlockDecorator(String label, AbstractTestCommand<T> command, Method method, String type) {
-        super(label, command);
-        setType(type);
-        setMethod(method);
-    }
-
-    public boolean test() {
-        boolean result = runMethod();
-
-        if(!result)
-            return false;
-
-        return getCommand().test();
-    }
-
-    public boolean runMethod() {
-        try {
-            method.setAccessible(true);
-            method.invoke(getCommand().getObject());
-            return true;
-        } catch (InvocationTargetException e) {
-            Throwable exception = e.getCause();
-
-            if(exception instanceof AssertionError)
-                throw (AssertionError) exception;
-
-            System.err.println(e.getMessage());
-            throw new RuntimeException(e);
-        } catch (IllegalAccessException e) {
-            System.err.println("Check access modifiers.");
-            throw new RuntimeException(e);
-        }
-    };
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/commands/decorators/ErrorDecorator.java

@@ -1,20 +0,0 @@
-package space.kklochko.simple_jbdd.tests.commands.decorators;
-
-import space.kklochko.simple_jbdd.tests.Test;
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
-
-public class ErrorDecorator<T extends Test> extends AbstractDecorator<T> {
-    public ErrorDecorator(String error_label, AbstractTestCommand<T> command, String type) {
-        super(error_label, command);
-        setType(type);
-    }
-
-    public boolean test() {
-        return false;
-    }
-
-    public boolean runMethod() {
-        return false;
-    };
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/factories/AbstractTestRunnerFactory.java

@@ -1,10 +0,0 @@
-package space.kklochko.simple_jbdd.tests.factories;
-
-import space.kklochko.simple_jbdd.tests.Test;
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
-import space.kklochko.simple_jbdd.tests.runners.AbstractTestRunner;
-
-public abstract class AbstractTestRunnerFactory {
-    public abstract AbstractTestRunner create(AbstractTestCommand<Test> command);
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/factories/SimpleTestRunnerFactory.java

@@ -1,13 +0,0 @@
-package space.kklochko.simple_jbdd.tests.factories;
-
-import space.kklochko.simple_jbdd.tests.Test;
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
-import space.kklochko.simple_jbdd.tests.runners.AbstractTestRunner;
-import space.kklochko.simple_jbdd.tests.runners.SimpleTestRunner;
-
-public class SimpleTestRunnerFactory extends AbstractTestRunnerFactory {
-    public AbstractTestRunner create(AbstractTestCommand<Test> command) {
-        return new SimpleTestRunner(command);
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/factories/TestCommandFactory.java

@@ -2,73 +2,22 @@ package space.kklochko.simple_jbdd.tests.factories;
 
 import space.kklochko.simple_jbdd.annotations.Given;
 import space.kklochko.simple_jbdd.annotations.Then;
-import space.kklochko.simple_jbdd.annotations.Title;
 import space.kklochko.simple_jbdd.annotations.When;
 import space.kklochko.simple_jbdd.tests.Test;
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
-import space.kklochko.simple_jbdd.tests.commands.SimpleTestCommand;
-import space.kklochko.simple_jbdd.tests.commands.decorators.BlockDecorator;
-import space.kklochko.simple_jbdd.tests.commands.decorators.ErrorDecorator;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
-import java.util.*;
+import java.util.Map;
+import java.util.TreeMap;
 
 public class TestCommandFactory {
-    public AbstractTestCommand create(Test input) {
+    public <T extends Test> void create(T input) {
-	    Class<?> aClass = input.getClass();
+	Class<?> aClass = input.getClass();
-	    Map<String, ArrayList<Method>> test_methods = this.getTestMethods(aClass);
+	Map<String, Method> test_methods = this.getTestMethods(aClass);
-
-        AbstractTestCommand<Test> aTestCommand = createTest(aClass, input);
-
-        if(test_methods.size() == 0)
-            return new ErrorDecorator("ERROR!!! No blocks!!!", aTestCommand, "Error");
-
-        if(test_methods.containsKey("Then")) {
-            ArrayList<Method> thens = getMethodsInReverseOrder(test_methods, "Then");
-            for(Method then : thens) {
-                String label = then.getAnnotation(Then.class).value();
-                aTestCommand = new BlockDecorator<Test>(label, aTestCommand, then, "Then");
-            }
-        }
-
-        if(test_methods.containsKey("When")) {
-            ArrayList<Method> whens = getMethodsInReverseOrder(test_methods, "When");
-            for(Method when : whens) {
-                String label = when.getAnnotation(When.class).value();
-                aTestCommand = new BlockDecorator<Test>(label, aTestCommand, when, "When");
-            }
-        }
-
-        if(test_methods.containsKey("Given")) {
-            ArrayList<Method> givens = getMethodsInReverseOrder(test_methods, "Given");
-            for(Method given : givens) {
-                String label = given.getAnnotation(Given.class).value();
-                aTestCommand = new BlockDecorator<Test>(label, aTestCommand, given, "Given");
-            }
-        }
-
-        return aTestCommand;
     }
 
-    private ArrayList<Method> getMethodsInReverseOrder(Map<String, ArrayList<Method>> test_methods, String key) {
+    protected <T extends Test> Map<String, Method> getTestMethods(Class<?> aClass) {
-        ArrayList<Method> methods = test_methods.get(key);
+        Map<String, Method> test_methods = new TreeMap<String, Method>();
-        Collections.reverse(methods);
-        return methods;
-    }
-
-    protected AbstractTestCommand<Test> createTest(Class<?> aClass, Test input) {
-        Title aTitle = aClass.getAnnotation(Title.class);
-        String title = aClass.getName();
-
-        if(aTitle != null)
-            title = aTitle.value();
-
-        return new SimpleTestCommand<Test>(title, input);
-    }
-
-    protected <T extends Test> Map<String, ArrayList<Method>> getTestMethods(Class<?> aClass) {
-        Map<String, ArrayList<Method>> test_methods = new TreeMap<>();
 
         for(Method method : aClass.getDeclaredMethods()) {
             Annotation[] annotations = method.getAnnotations();
@@ -77,21 +26,15 @@ public class TestCommandFactory {
                 continue;
 
             if(method.isAnnotationPresent(Given.class))
-                addMethodTo(test_methods, "Given", method);
+                test_methods.put("Given", method);
 
             if(method.isAnnotationPresent(When.class))
-                addMethodTo(test_methods, "When", method);
+                test_methods.put("When", method);
 
             if(method.isAnnotationPresent(Then.class))
-                addMethodTo(test_methods, "Then", method);
+                test_methods.put("Then", method);
         }
 
         return test_methods;
     }
-
-    private void addMethodTo(Map<String, ArrayList<Method>> test_methods, String key, Method method) {
-        ArrayList<Method> methods = test_methods.getOrDefault(key, new ArrayList<>());
-        methods.add(method);
-        test_methods.put(key, methods);
-    }
 }

src/main/java/space/kklochko/simple_jbdd/tests/factories/TestCommandQueueFactory.java

@@ -1,49 +0,0 @@
-package space.kklochko.simple_jbdd.tests.factories;
-
-import space.kklochko.simple_jbdd.tests.Test;
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
-
-import java.util.*;
-
-public class TestCommandQueueFactory {
-    private ArrayList<Test> tests;
-    private TestCommandFactory factory;
-
-    public TestCommandQueueFactory(ArrayList<Test> tests) {
-        setTests(tests);
-        setFactory(new TestCommandFactory());
-    }
-
-    public TestCommandQueueFactory(ArrayList<Test> tests, TestCommandFactory factory) {
-        setTests(tests);
-        setFactory(factory);
-    }
-
-    public ArrayList<AbstractTestCommand<Test>> create() {
-        ArrayList<AbstractTestCommand<Test>> commands = new ArrayList<AbstractTestCommand<Test>>();
-
-        for(Test test : getTests()) {
-            AbstractTestCommand<Test> command = getFactory().create(test);
-            commands.add(command);
-        }
-
-        return commands;
-    }
-
-    public ArrayList<Test> getTests() {
-        return tests;
-    }
-
-    public void setTests(ArrayList<Test> tests) {
-        this.tests = tests;
-    }
-
-    public TestCommandFactory getFactory() {
-        return factory;
-    }
-
-    public void setFactory(TestCommandFactory factory) {
-        this.factory = factory;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/factories/meta/AbstractTestCommandMetaDataFactory.java

@@ -1,9 +0,0 @@
-package space.kklochko.simple_jbdd.tests.factories.meta;
-
-import java.util.AbstractMap;
-import java.util.ArrayList;
-
-public abstract class AbstractTestCommandMetaDataFactory {
-    abstract public ArrayList<AbstractMap.SimpleEntry<String, String>> create();
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/factories/meta/TestCommandMetaDataFactory.java

@@ -1,34 +0,0 @@
-package space.kklochko.simple_jbdd.tests.factories.meta;
-
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
-import space.kklochko.simple_jbdd.tests.commands.decorators.AbstractDecorator;
-
-import java.util.AbstractMap;
-import java.util.ArrayList;
-
-public class TestCommandMetaDataFactory extends AbstractTestCommandMetaDataFactory {
-    private AbstractTestCommand command;
-
-    public TestCommandMetaDataFactory(AbstractTestCommand command) {
-        this.command = command;
-    }
-
-    public ArrayList<AbstractMap.SimpleEntry<String, String>> create() {
-        ArrayList<AbstractMap.SimpleEntry<String, String>> blocks = new ArrayList<>();
-        AbstractTestCommand currentCommand = command;
-        Class<?> aClass = command.getClass();
-
-        while(AbstractDecorator.class.isAssignableFrom(aClass)) {
-            AbstractDecorator block = (AbstractDecorator) currentCommand;
-            blocks.add(new AbstractMap.SimpleEntry<>(block.getType(), block.getLabel()));
-
-            currentCommand = block.getCommand();
-            aClass = currentCommand.getClass();
-        }
-
-        blocks.add(0, (new AbstractMap.SimpleEntry<>(currentCommand.getType(), currentCommand.getLabel())));
-
-        return blocks;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/loaders/AbstractNameClassLoader.java

@@ -1,8 +0,0 @@
-package space.kklochko.simple_jbdd.tests.loaders;
-
-import java.util.Set;
-
-public abstract class AbstractNameClassLoader {
-    public abstract Set<Class<?>> load();
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/loaders/ClassLoader.java

@@ -1,26 +0,0 @@
-package space.kklochko.simple_jbdd.tests.loaders;
-
-import java.util.ArrayList;
-import java.util.Set;
-
-public class ClassLoader<T> {
-
-    AbstractNameClassLoader nameLoader;
-
-    public ClassLoader(AbstractNameClassLoader nameLoader) {
-        this.nameLoader = nameLoader;
-    }
-
-    public ArrayList<T> load() {
-        Set<Class<?>> names = nameLoader.load();
-        ArrayList<T> classes = new ArrayList<>();
-
-        for(Class<?> name : names) {
-            SingleClassLoader loader = new SingleClassLoader(name.getName());
-            classes.add((T) loader.load());
-        }
-
-        return classes;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/loaders/NameClassLoader.java

@@ -1,28 +0,0 @@
-package space.kklochko.simple_jbdd.tests.loaders;
-
-import com.google.common.reflect.ClassPath;
-
-import java.io.IOException;
-import java.util.stream.Collectors;
-import java.util.Set;
-
-public class NameClassLoader extends AbstractNameClassLoader {
-    public Set<Class<?>> load() {
-        try {
-            return ClassPath.from(java.lang.ClassLoader.getSystemClassLoader())
-                        .getAllClasses()
-                        .stream()
-		        // exclude the Test class, which indicate a Test class
-                        .filter(aClass -> !aClass.getName().endsWith(".Test"))
-                        .filter(aClass -> aClass.getName().endsWith("Test"))
-		        // include classes which extends the Test class
-                        .filter(aClass -> space.kklochko.simple_jbdd.tests.Test.class.isAssignableFrom(aClass.load()))
-                        .filter(aClass -> aClass.getName().startsWith("space"))
-                        .map(aClass -> aClass.load())
-                        .collect(Collectors.toSet());
-        } catch (IOException e) {
-            return null;
-        }
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/loaders/SingleClassLoader.java

@@ -1,26 +0,0 @@
-package space.kklochko.simple_jbdd.tests.loaders;
-
-public class SingleClassLoader {
-    String className;
-
-    public SingleClassLoader(String className) {
-        setClassName(className);
-    }
-
-    public Class<?> load() {
-        try {
-            return Class.forName(getClassName());
-        } catch (ClassNotFoundException e) {
-            return null;
-        }
-    }
-
-    public String getClassName() {
-        return className;
-    }
-
-    public void setClassName(String className) {
-        this.className = className;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/loaders/SingleTestLoader.java

@@ -1,50 +0,0 @@
-package space.kklochko.simple_jbdd.tests.loaders;
-
-import space.kklochko.simple_jbdd.tests.Test;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-
-public class SingleTestLoader {
-    String className;
-
-    public SingleTestLoader(String className) {
-        setClassName(className);
-    }
-
-    public Test load() {
-        SingleClassLoader loader = new SingleClassLoader(getClassName());
-        Class<?> aClass = loader.load();
-
-        if(aClass == null)
-            return null;
-
-        Constructor defaultConstructor = null;
-
-        for(Constructor constructor : aClass.getDeclaredConstructors()) {
-            if(constructor.getParameterCount() == 0) {
-                defaultConstructor = constructor;
-                break;
-            }
-        }
-
-        try {
-            return (Test) defaultConstructor.newInstance();
-        } catch (InstantiationException e) {
-            throw new RuntimeException(e);
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException(e);
-        } catch (InvocationTargetException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    public String getClassName() {
-        return className;
-    }
-
-    public void setClassName(String className) {
-        this.className = className;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/reports/AbstractReporter.java

@@ -1,40 +0,0 @@
-package space.kklochko.simple_jbdd.tests.reports;
-
-import space.kklochko.simple_jbdd.tests.factories.meta.AbstractTestCommandMetaDataFactory;
-import space.kklochko.simple_jbdd.tests.reports.fmt.AbstractTestReportFormatter;
-
-import java.util.AbstractMap;
-import java.util.ArrayList;
-
-public abstract class AbstractReporter {
-    ArrayList<AbstractMap.SimpleEntry<AbstractTestCommandMetaDataFactory, Boolean>> Metadata;
-    AbstractTestReportFormatter formatter;
-
-    public AbstractReporter(ArrayList<AbstractMap.SimpleEntry<AbstractTestCommandMetaDataFactory, Boolean>> metadata, AbstractTestReportFormatter formatter) {
-        setMetadata(metadata);
-        setFormatter(formatter);
-    }
-
-    abstract public void report();
-
-    public ArrayList<AbstractMap.SimpleEntry<AbstractTestCommandMetaDataFactory, Boolean>> getMetadata() {
-        return Metadata;
-    }
-
-    public void setMetadata(ArrayList<AbstractMap.SimpleEntry<AbstractTestCommandMetaDataFactory, Boolean>> metadata) {
-        Metadata = metadata;
-    }
-
-    public void addMetadata(AbstractTestCommandMetaDataFactory testMetaData, boolean isPassed) {
-        getMetadata().add(new AbstractMap.SimpleEntry<>(testMetaData, isPassed));
-    }
-
-    public AbstractTestReportFormatter getFormatter() {
-        return formatter;
-    }
-
-    public void setFormatter(AbstractTestReportFormatter formatter) {
-        this.formatter = formatter;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/reports/CLIReporter.java

@@ -1,99 +0,0 @@
-package space.kklochko.simple_jbdd.tests.reports;
-
-import space.kklochko.simple_jbdd.tests.factories.meta.AbstractTestCommandMetaDataFactory;
-import space.kklochko.simple_jbdd.tests.reports.fmt.AbstractTestReportFormatter;
-
-import java.util.AbstractMap;
-import java.util.ArrayList;
-import org.apache.commons.lang3.StringUtils;
-
-public class CLIReporter extends AbstractReporter {
-    final int terminalWidth = 80;
-
-    public CLIReporter(AbstractTestReportFormatter formatter) {
-        super(null, formatter);
-    }
-
-    public CLIReporter(ArrayList<AbstractMap.SimpleEntry<AbstractTestCommandMetaDataFactory, Boolean>> metadata, AbstractTestReportFormatter formatter) {
-        super(metadata, formatter);
-    }
-
-    public void report() {
-        ArrayList<AbstractMap.SimpleEntry<String, Boolean>> testData = format();
-        ArrayList<AbstractMap.SimpleEntry<String, Boolean>> failedTestData = getFailedTests(testData);
-        int passed = count(testData, true);
-        int failed = count(testData, false);
-
-        System.out.printf("%s\n\n", center(" Tests "));
-        printTests(testData);
-
-        if(failed != 0) {
-            System.out.printf("%s\n\n", center(" Errors "));
-            printTests(failedTestData);
-        }
-
-        System.out.printf("%s\n", center(" Summary "));
-        System.out.print(summary(passed, failed));
-    }
-
-    public ArrayList<AbstractMap.SimpleEntry<String, Boolean>> format() {
-        ArrayList<AbstractMap.SimpleEntry<String, Boolean>> data = new ArrayList<>();
-
-        for(var pair : getMetadata()) {
-            boolean isPassed = pair.getValue();
-
-            getFormatter().setTestMetaData(pair.getKey().create());
-            getFormatter().setPassed(isPassed);
-
-            data.add(new AbstractMap.SimpleEntry<>(getFormatter().format(), isPassed));
-        }
-
-        return data;
-    }
-
-    public ArrayList<AbstractMap.SimpleEntry<String, Boolean>> getFailedTests(ArrayList<AbstractMap.SimpleEntry<String, Boolean>> testData) {
-        ArrayList<AbstractMap.SimpleEntry<String, Boolean>> failed = new ArrayList<>();
-
-        for(var pair : testData) {
-            boolean isPassed = pair.getValue();
-
-            if(isPassed) continue;
-
-            failed.add(pair);
-        }
-
-        return failed;
-    }
-
-    public int count(ArrayList<AbstractMap.SimpleEntry<String, Boolean>> testData, boolean isPassedStatus) {
-        int count = 0;
-
-        for(var pair : testData) {
-            boolean isPassed = pair.getValue();
-
-            if(isPassed == isPassedStatus)
-                count++;
-        }
-
-        return count;
-    }
-
-    public void printTests(ArrayList<AbstractMap.SimpleEntry<String, Boolean>> testData) {
-        for(var pair : testData) {
-            System.out.print(pair.getKey());
-        }
-    }
-
-    public String center(String content) {
-        return StringUtils.center(content, 80, '=');
-    }
-
-    public String summary(int passed, int failed) {
-        int all = passed + failed;
-        double passedPercent = (double) passed / (double) all * 100.0;
-        double failedPercent = (double) failed / (double) all * 100.0;
-
-        return String.format("Ran %d tests.\nPassed: %d (%.2f%%)\nFailed: %d (%.2f%%)\n", all, passed, passedPercent, failed, failedPercent);
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/reports/fmt/AbstractTestReportFormatter.java

@@ -1,33 +0,0 @@
-package space.kklochko.simple_jbdd.tests.reports.fmt;
-
-import java.util.AbstractMap;
-import java.util.ArrayList;
-
-abstract public class AbstractTestReportFormatter {
-    private ArrayList<AbstractMap.SimpleEntry<String, String>> testMetaData;
-    private boolean isPassed;
-
-    public AbstractTestReportFormatter(ArrayList<AbstractMap.SimpleEntry<String, String>> testMetaData, boolean isPassed) {
-        setTestMetaData(testMetaData);
-        setPassed(isPassed);
-    }
-
-    public abstract String format();
-
-    public ArrayList<AbstractMap.SimpleEntry<String, String>> getTestMetaData() {
-        return testMetaData;
-    }
-
-    public void setTestMetaData(ArrayList<AbstractMap.SimpleEntry<String, String>> testMetaData) {
-        this.testMetaData = testMetaData;
-    }
-
-    public boolean isPassed() {
-        return isPassed;
-    }
-
-    public void setPassed(boolean passed) {
-        isPassed = passed;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/reports/fmt/SimpleTestReportFormatter.java

@@ -1,42 +0,0 @@
-package space.kklochko.simple_jbdd.tests.reports.fmt;
-
-import space.kklochko.simple_jbdd.tests.Test;
-
-import java.util.AbstractMap;
-import java.util.ArrayList;
-
-public class SimpleTestReportFormatter extends AbstractTestReportFormatter {
-    final private String passedIcon = "✓";
-    final private String failedIcon = "⨯";
-
-    public SimpleTestReportFormatter() {
-        super(null, false);
-    }
-
-    public SimpleTestReportFormatter(ArrayList<AbstractMap.SimpleEntry<String, String>> testMetaData, boolean isPassed) {
-        super(testMetaData, isPassed);
-    }
-
-    public String format() {
-        String status = (isPassed()) ? getPassedIcon() : getFailedIcon();
-        String title = getTestMetaData().get(0).getValue();
-
-        String result = String.format("%s %s\n", status, title);
-
-        for(int i=1; i<getTestMetaData().size(); ++i) {
-            AbstractMap.SimpleEntry<String, String> pair = getTestMetaData().get(i);
-            result += String.format("\t%s: %s\n", pair.getKey(), pair.getValue());
-        }
-
-        return result + '\n';
-    }
-
-    public String getPassedIcon() {
-        return passedIcon;
-    }
-
-    public String getFailedIcon() {
-        return failedIcon;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/runners/AbstractTestRunner.java

@@ -1,6 +0,0 @@
-package space.kklochko.simple_jbdd.tests.runners;
-
-public abstract class AbstractTestRunner {
-    public abstract boolean run();
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/runners/CLITestRunner.java

@@ -1,102 +0,0 @@
-package space.kklochko.simple_jbdd.tests.runners;
-
-import space.kklochko.simple_jbdd.tests.Test;
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
-import space.kklochko.simple_jbdd.tests.factories.AbstractTestRunnerFactory;
-import space.kklochko.simple_jbdd.tests.factories.TestCommandQueueFactory;
-import space.kklochko.simple_jbdd.tests.factories.meta.AbstractTestCommandMetaDataFactory;
-import space.kklochko.simple_jbdd.tests.factories.meta.TestCommandMetaDataFactory;
-import space.kklochko.simple_jbdd.tests.loaders.AbstractNameClassLoader;
-import space.kklochko.simple_jbdd.tests.loaders.SingleTestLoader;
-import space.kklochko.simple_jbdd.tests.reports.AbstractReporter;
-
-import java.util.AbstractMap;
-import java.util.ArrayList;
-import java.util.Set;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-
-public class CLITestRunner extends AbstractTestRunner {
-    private ArrayList<AbstractTestCommand<Test>> commands;
-    private AbstractNameClassLoader classLoader;
-    private AbstractTestRunnerFactory runnerFactory;
-    private AbstractReporter reporter;
-
-    public CLITestRunner(AbstractNameClassLoader classLoader, AbstractTestRunnerFactory runnerFactory, AbstractReporter reporter) {
-        setClassLoader(classLoader);
-        setRunnerFactory(runnerFactory);
-        setReporter(reporter);
-    }
-
-    public boolean run() {
-        commands = createCommands(load());
-        ArrayList<Boolean> testStatuses = runTests(commands);
-        report(createMetadata(commands, testStatuses));
-
-        return isFailed(testStatuses);
-    }
-
-    public ArrayList<Test> load() {
-        Set<Class<?>> classes = this.classLoader.load();
-        ArrayList<Test> tests = new ArrayList();
-
-        for(var aClass : classes) {
-            tests.add((new SingleTestLoader(aClass.getName())).load());
-        }
-
-        return tests;
-    }
-
-    public ArrayList<AbstractTestCommand<Test>> createCommands(ArrayList<Test> tests) {
-        TestCommandQueueFactory factory = new TestCommandQueueFactory(tests);
-        return factory.create();
-    }
-
-    public ArrayList<Boolean> runTests(ArrayList<AbstractTestCommand<Test>> commands) {
-        return commands.stream()
-                       .map(c -> runnerFactory.create(c).run())
-                       .collect(Collectors.toCollection(ArrayList::new));
-    }
-
-    public ArrayList<AbstractMap.SimpleEntry<AbstractTestCommandMetaDataFactory, Boolean>> createMetadata(ArrayList<AbstractTestCommand<Test>> commands, ArrayList<Boolean> testStatuses) {
-        return IntStream.range(0, commands.size())
-                        .mapToObj(i -> new AbstractMap.SimpleEntry<AbstractTestCommandMetaDataFactory, Boolean>(
-                                            new TestCommandMetaDataFactory(commands.get(i)),
-                                            testStatuses.get(i)))
-                        .collect(Collectors.toCollection(ArrayList::new));
-    }
-
-    public void report(ArrayList<AbstractMap.SimpleEntry<AbstractTestCommandMetaDataFactory, Boolean>> metadata) {
-        reporter.setMetadata(metadata);
-        reporter.report();
-    }
-
-    public boolean isFailed(ArrayList<Boolean> testStatuses) {
-        return !testStatuses.stream().anyMatch(b -> b == false);
-    }
-
-    public AbstractNameClassLoader getClassLoader() {
-        return classLoader;
-    }
-
-    public void setClassLoader(AbstractNameClassLoader classLoader) {
-        this.classLoader = classLoader;
-    }
-
-    public AbstractTestRunnerFactory getRunnerFactory() {
-        return runnerFactory;
-    }
-
-    public void setRunnerFactory(AbstractTestRunnerFactory runnerFactory) {
-        this.runnerFactory = runnerFactory;
-    }
-
-    public AbstractReporter getReporter() {
-        return reporter;
-    }
-
-    public void setReporter(AbstractReporter reporter) {
-        this.reporter = reporter;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/tests/runners/SimpleTestRunner.java

@@ -1,29 +0,0 @@
-package space.kklochko.simple_jbdd.tests.runners;
-
-import space.kklochko.simple_jbdd.tests.Test;
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
-
-public class SimpleTestRunner extends AbstractTestRunner {
-    private AbstractTestCommand<Test> command;
-
-    public SimpleTestRunner(AbstractTestCommand<Test> command) {
-        setCommand(command);
-    }
-
-    public boolean run() {
-        try {
-            return getCommand().test();
-        }catch (AssertionError e) {
-            return false;
-        }
-    }
-
-    public AbstractTestCommand<Test> getCommand() {
-        return command;
-    }
-
-    public void setCommand(AbstractTestCommand<Test> command) {
-        this.command = command;
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/factories/IntegratedTestCommandQueueFactorySpec.groovy

@@ -1,54 +0,0 @@
-package space.kklochko.simple_jbdd.tests.factories
-
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenWhenThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTestWithoutTitle
-import space.kklochko.simple_jbdd.tests.Test
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The factory must generate a queue of the test commands, so
-those tests check if factory generate them right.
-""")
-@Title("Integrated tests for TestCommandQueueFactory")
-class IntegratedTestCommandQueueFactorySpec extends Specification {
-    def "Factory generate the queue and its size is 2."() {
-        given: "I have a list of tests"
-        def tests = [new SimpleThenTest(), new SimpleThenTestWithoutTitle()]
-
-        and: "I have a test factory"
-        def testFactory = new TestCommandFactory()
-
-        and: "I have a factory"
-        @Subject
-        def factory = new TestCommandQueueFactory(tests, testFactory)
-
-        when: "Factory build the queue"
-        def queue = factory.create()
-
-        then: "the size is 2"
-        2 == queue.size()
-    }
-
-    def "Factory generate the queue and the commands and test order is the same."() {
-        given: "I have a list of tests with first methods [check, setup]"
-        def tests = [new SimpleThenTest(), new SimpleGivenWhenThenTest()]
-
-        and: "I have a test factory"
-        def testFactory = new TestCommandFactory()
-
-        and: "I have a factory"
-        @Subject
-        def factory = new TestCommandQueueFactory(tests, testFactory)
-
-        when: "Factory build the queue"
-        def queue = factory.create()
-
-        then: "the order is the same"
-        queue[0].method.getName() == "check"
-        queue[1].method.getName() == "setup"
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/factories/TestCommandFactorySpec.groovy

@@ -1,95 +1,22 @@
 package space.kklochko.simple_jbdd.tests.factories
 
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleEmptyTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenGivenWhenWhenThenThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenWhenThenTest
 import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTestWithoutTitle
+import space.kklochko.simple_jbdd.tests.factories.TestCommandFactory;
-import space.kklochko.simple_jbdd.tests.factories.TestCommandFactory
-import spock.lang.Narrative;
 import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
 
-@Narrative("""The factory must generate a test command, so
-those tests check if factory generate them right.
-""")
-@Title("Unit tests for TestCommandFactory")
 class TestCommandFactorySpec extends Specification {
-    def "The command have the same block count."() {
+    def "If the map of methods have one test block."() {
         given: "I have a TestCommandFactory object"
-        @Subject
         def factory = new TestCommandFactory();
 
-        when: "If a test command have blocks"
+        and: "I also have a SimpleThenTest object"
-        def map = factory.getTestMethods(testClass.getClass())
+        def simpleThenTest = new SimpleThenTest()
 
-        def count = map.values()
+        when: "If a test have only one block"
-                .stream()
+        def map = factory.getTestMethods(simpleThenTest.getClass())
-                .map {it.size()}
-                .reduce(0) { acc, num -> acc + num }
 
-        then: "the command have the expected block count"
+        then: "the map size is 1 method"
-        expectedBlockCount == count
+        1 == map.size()
-
-        where:
-        testClass                                  || expectedBlockCount
-        new SimpleEmptyTest()                      || 0
-        new SimpleThenTest()                       || 1
-        new SimpleGivenWhenThenTest()              || 3
-        new SimpleGivenGivenWhenWhenThenThenTest() || 6
-    }
-
-    def "createTest() sets the title to a class name if no Title annotation."() {
-        given: "I have a test factory"
-        @Subject
-        def factory = new TestCommandFactory()
-
-        and: "I have a test class without Title"
-        def testClass = new SimpleThenTestWithoutTitle()
-
-        when: "I build a test"
-        def test = factory.create(testClass)
-
-        then: "The test have title as the test class"
-        testClass.class.getName() == test.getLabels()['Title']
-    }
-
-    def "createTest() sets the title to a value of the Title annotation."() {
-        given: "I have a test factory"
-        @Subject
-        def factory = new TestCommandFactory()
-
-        and: "I have a test class with Title"
-        def testClass = new SimpleThenTest()
-
-        and: "and the title of the annotation"
-        def titleClass = space.kklochko.simple_jbdd.annotations.Title.class
-        def title = testClass.getClass().getAnnotation(titleClass).value()
-
-        when: "I build a test"
-        def test = factory.create(testClass)
-
-        then: "The test have title as the test class"
-        title == test.getLabels()['Title']
-    }
-
-    def "createTest() build a TestCommand that contains the expected blocks."() {
-        given: "I have a test factory"
-        @Subject
-        def factory = new TestCommandFactory()
-
-        when: "I build a test"
-        def test = factory.create(testClass)
-
-        then: "The test have the expected blocks"
-        expectedBlocks.toSet() == test.getLabels().keySet()
-
-        where:
-        testClass                                  || expectedBlocks
-        new SimpleThenTest()                       || ['Title', 'Then']
-        new SimpleGivenWhenThenTest()              || ['Title', 'Given', 'When', 'Then']
-        new SimpleGivenGivenWhenWhenThenThenTest() || ['Title', 'Given', 'When', 'Then']
     }
 }
 

src/test/groovy/space/kklochko/simple_jbdd/tests/factories/TestCommandQueueFactorySpec.groovy

@@ -1,36 +0,0 @@
-package space.kklochko.simple_jbdd.tests.factories
-
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTestWithoutTitle
-import space.kklochko.simple_jbdd.tests.Test
-import space.kklochko.simple_jbdd.tests.commands.decorators.BlockDecorator
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The factory must generate a queue of the test commands, so
-those tests check if factory generate them right.
-""")
-@Title("Unit tests for TestCommandQueueFactory")
-class TestCommandQueueFactorySpec extends Specification {
-    def "Factory generate the queue and its size is 2."() {
-        given: "I have a list of tests"
-        def tests = [Mock(SimpleThenTest), Mock(SimpleThenTestWithoutTitle)]
-
-        and: "I have a test factory"
-        def testFactory = Stub(TestCommandFactory)
-        testFactory.create() >>> [Mock(BlockDecorator<Test>)]*2
-
-        and: "I have the factory"
-        @Subject
-        def factory = new TestCommandQueueFactory(tests, testFactory)
-
-        when: "Factory build the queue"
-        def queue = factory.create()
-
-        then: "the size is 2"
-        2 == queue.size()
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/factories/meta/IntegratedTestCommandMetaDataFactorySpec.groovy

@@ -1,46 +0,0 @@
-package space.kklochko.simple_jbdd.tests.factories.meta
-
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleFailedThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenWhenThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTestWithoutTitle
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand
-import space.kklochko.simple_jbdd.tests.commands.decorators.BlockDecorator
-import space.kklochko.simple_jbdd.tests.factories.TestCommandFactory
-import space.kklochko.simple_jbdd.tests.runners.SimpleTestRunner
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The factory must generate a test command metadata, so
-those tests check if the factory generate it right.
-""")
-@Title("Integrated tests for TestCommandMetaDataFactory")
-class IntegratedTestCommandMetaDataFactorySpec extends Specification {
-    def "Metadata have  the map of methods have one test block."() {
-        given: "I have a command factory"
-        def commandFactory = new TestCommandFactory();
-
-        and: "I have a command of a test"
-        def command = commandFactory.create(testObject)
-
-        and: "I have a TestCommandMetaDataFactory object"
-        @Subject
-        def factory = new TestCommandMetaDataFactory(command)
-
-        when: "Parse the command to get metadata"
-        def metadata = factory.create()
-
-        then: "the metadata have only two labels for Title and Then"
-        expectedCount == metadata.size()
-
-        where: "Possible variants of tests"
-        testObject                       || expectedCount
-        new SimpleThenTest()             || 2
-        new SimpleGivenWhenThenTest()    || 4
-        new SimpleThenTestWithoutTitle() || 2
-        new SimpleFailedThenTest()       || 2
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/factories/meta/TestCommandMetaDataFactorySpec.groovy

@@ -1,93 +0,0 @@
-package space.kklochko.simple_jbdd.tests.factories.meta
-
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenWhenThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand
-import space.kklochko.simple_jbdd.tests.commands.decorators.BlockDecorator
-import space.kklochko.simple_jbdd.tests.factories.TestCommandFactory
-import spock.lang.Narrative;
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The factory must generate a test command metadata, so
-those tests check if the factory generate it right.
-""")
-@Title("Unit tests for TestCommandMetaDataFactory")
-class TestCommandMetaDataFactorySpec extends Specification {
-    def "If the map of methods have one test block."() {
-        given: "I have a simple test with only Then block and its command."
-        def test = Mock(AbstractTestCommand) {
-            getType() >> "Title"
-            getLabel() >> "A simple test"
-        }
-
-        def command = GroovyMock(BlockDecorator) {
-            getType() >> "Then"
-            getLabel() >> "Then block"
-            getCommand() >> test
-        }
-
-        and: "I have a TestCommandMetaDataFactory object"
-        @Subject
-        def factory = new TestCommandMetaDataFactory(command)
-
-        when: "Parse the command to get metadata"
-        def metadata = factory.create()
-
-        then: "The metadata have only two labels for Title and Then"
-        2 == metadata.size()
-
-        and: "The format and the order must be the same"
-        metadata == [
-                new AbstractMap.SimpleEntry<>("Title", "A simple test"),
-                new AbstractMap.SimpleEntry<>("Then", "Then block")
-        ]
-    }
-
-    def "If the map of methods have GivenWhenThen blocks."() {
-        given: "I have a simple test with only Then block and its command."
-        def test = Mock(AbstractTestCommand) {
-            getType() >> "Title"
-            getLabel() >> "A simple test"
-        }
-
-        and: "Bootstrapping the test command"
-        def then = GroovyMock(BlockDecorator) {
-            getType() >> "Then"
-            getLabel() >> "Then block"
-            getCommand() >> test
-        }
-
-        def when = GroovyMock(BlockDecorator) {
-            getType() >> "When"
-            getLabel() >> "When block"
-            getCommand() >> then
-        }
-
-        def command = GroovyMock(BlockDecorator) {
-            getType() >> "Given"
-            getLabel() >> "Given block"
-            getCommand() >> when
-        }
-
-        and: "I have a TestCommandMetaDataFactory object"
-        @Subject
-        def factory = new TestCommandMetaDataFactory(command)
-
-        when: "Parse the command to get metadata"
-        def metadata = factory.create()
-
-        then: "The metadata have only two labels for Title and Then"
-        4 == metadata.size()
-
-        and: "The format and the order must be the same"
-        metadata == [
-                new AbstractMap.SimpleEntry<>("Title", "A simple test"),
-                new AbstractMap.SimpleEntry<>("Given", "Given block"),
-                new AbstractMap.SimpleEntry<>("When", "When block"),
-                new AbstractMap.SimpleEntry<>("Then", "Then block")
-        ]
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/loaders/IntegratedClassLoader.groovy

@@ -1,43 +0,0 @@
-package space.kklochko.simple_jbdd.tests.loaders
-
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The loader must return a test classes or null, so
-those tests check if responses are right.
-""")
-@Title("Integrated tests for ClassLoader.")
-class IntegratedClassLoader extends Specification {
-    def "The classes have been loaded."() {
-        given: "I have a name class loader"
-        def nameLoader = new NameClassLoader()
-
-        and: "I have a loader for classes"
-        @Subject
-        def loader = new ClassLoader(nameLoader)
-
-        when: "The classes were loaded"
-        def classes = loader.load()
-
-        then: "Checking that the test result is expected"
-        5 == classes.size()
-    }
-
-    def "The classes must be represent the Test interface."() {
-        given: "I have a name class loader"
-        def nameLoader = new NameClassLoader()
-
-        and: "I have a loader for classes"
-        @Subject
-        def loader = new ClassLoader(nameLoader)
-
-        when: "The classes were loaded"
-        def classes = loader.load()
-
-        then: "Checking that the test result is expected"
-        classes.every({ space.kklochko.simple_jbdd.tests.Test.class.isAssignableFrom(it) })
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/loaders/IntegratedNameClassLoader.groovy

@@ -1,25 +0,0 @@
-package space.kklochko.simple_jbdd.tests.loaders
-
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The loader must return a test class names or null, so
-those tests check if responses are right.
-""")
-@Title("Integrated tests for NameClassLoader.")
-class IntegratedNameClassLoader extends Specification {
-    def "The class names have been loaded."() {
-        given: "I have a class loader"
-        @Subject
-        def loader = new NameClassLoader()
-
-        when: "The class names were loaded"
-        def classNames = loader.load()
-
-        then: "Checking that the test result is expected"
-        5 == classNames.size()
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/loaders/IntegratedSingleClassLoader.groovy

@@ -1,31 +0,0 @@
-package space.kklochko.simple_jbdd.tests.loaders
-
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The loader must return a class or null, so
-those tests check if responses are right.
-""")
-@Title("Integrated tests for SingleClassLoader.")
-class IntegratedSingleClassLoader extends Specification {
-    def "The class has been loaded."() {
-        given: "I have a class loader"
-        @Subject
-        def loader = new SingleClassLoader(className)
-
-        when: "The class was loaded"
-        def aClass = loader.load()
-
-        then: "Checking that the test result is expected"
-        aClass == expectedClass
-
-        where: "Possible variants of tests"
-        className                                                       || expectedClass
-        "fourHundredFour"                                               || null
-        "space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest" || SimpleThenTest
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/loaders/IntegratedSingleTestLoader.groovy

@@ -1,31 +0,0 @@
-package space.kklochko.simple_jbdd.tests.loaders
-
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The loader must return a class or null, so
-those tests check if responses are right.
-""")
-@Title("Integrated tests for SingleTestLoader.")
-class IntegratedSingleTestLoader extends Specification {
-    def "The class has been loaded."() {
-        given: "I have a class loader"
-        @Subject
-        def loader = new SingleTestLoader(className)
-
-        when: "The class was loaded"
-        def aClass = loader.load()
-
-        then: "Checking that the test result is expected"
-        aClass?.class == expectedClass
-
-        where: "Possible variants of tests"
-        className                                                       || expectedClass
-        "fourHundredFour"                                               || null
-        "space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest" || SimpleThenTest
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/reports/CLIReporterFormatMethodSpec.groovy

@@ -1,72 +0,0 @@
-package space.kklochko.simple_jbdd.tests.reports
-
-import space.kklochko.simple_jbdd.tests.factories.meta.AbstractTestCommandMetaDataFactory
-import space.kklochko.simple_jbdd.tests.reports.fmt.AbstractTestReportFormatter
-import space.kklochko.simple_jbdd.tests.reports.fmt.SimpleTestReportFormatter
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The reporter must generate a report in the same format, so
-those tests check if the reporter generate it right.
-""")
-@Title("Unit tests for CLIReporter.format()")
-class CLIReporterFormatMethodSpec extends Specification {
-    private metaData
-
-    def setup() {
-        def factory = Mock(AbstractTestCommandMetaDataFactory) {
-            create() >> [
-                    new AbstractMap.SimpleEntry<>("Title", "A simple test"),
-                    new AbstractMap.SimpleEntry<>("Then", "Then block")
-            ]
-        }
-
-        def metaData = [
-                new AbstractMap.SimpleEntry<>(factory, true),
-                new AbstractMap.SimpleEntry<>(factory, false)
-        ]
-
-        this.metaData = metaData
-    }
-
-    def "Format function use formatter twice."() {
-        given: "I have a formatter"
-        def formatter = Mock(AbstractTestReportFormatter)
-
-        and: "I have a reporter"
-        @Subject
-        def reporter = new CLIReporter(metaData, formatter)
-
-        when: "Generate the summary format"
-        def formattedTestData = reporter.format()
-
-        then: "The methods must called 2 times"
-        2 * formatter.format()
-        2 * formatter.setPassed(_)
-        2 * formatter.setTestMetaData(_)
-
-        and: "The data must have 2 elements"
-        2 == formattedTestData.size()
-    }
-
-    def "Format function returns the formatted data."() {
-        given: "I have a formatter"
-        def formatter = new SimpleTestReportFormatter()
-
-        and: "I have a reporter"
-        @Subject
-        def reporter = new CLIReporter(metaData, formatter)
-
-        when: "Generate the summary format"
-        def formattedTestData = reporter.format()
-
-        then: "The format must have not null values"
-        formattedTestData.every({ it.getKey() != null })
-
-        and: "The data must have 2 elements"
-        2 == formattedTestData.size()
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/reports/CLIReporterSpec.groovy

@@ -1,77 +0,0 @@
-package space.kklochko.simple_jbdd.tests.reports
-
-import space.kklochko.simple_jbdd.tests.factories.meta.AbstractTestCommandMetaDataFactory
-import space.kklochko.simple_jbdd.tests.reports.fmt.AbstractTestReportFormatter
-import space.kklochko.simple_jbdd.tests.reports.fmt.SimpleTestReportFormatter
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The reporter must generate a report in the same format, so
-those tests check if the reporter generate it right.
-""")
-@Title("Unit tests for CLIReporter")
-class CLIReporterSpec extends Specification {
-    def "Function, getFailedTest, returns the data of failed tests."() {
-        given: "I have a reporter"
-        @Subject
-        def reporter = new CLIReporter(null, null)
-
-        and: "I have a testData"
-        def passedTestPair = new AbstractMap.SimpleEntry<>("Passed", true)
-        def failedTestPair = new AbstractMap.SimpleEntry<>("Failed", false)
-        def testData = Collections.nCopies(countPassed, passedTestPair) + Collections.nCopies(countFailed, failedTestPair)
-
-        when: "Generate the summary format"
-        def failedTestData = reporter.getFailedTests(testData)
-
-        then: "The format must be the same"
-        failedTestData.every({ it.getKey() == "Failed" && it.getValue() == false})
-        expectedFailedCount == failedTestData.size()
-
-        where: "Possible variants of tests"
-        countPassed | countFailed || expectedFailedCount
-        5           | 10          || 10
-    }
-
-    def "Count function returns the count of passed or failed tests."() {
-        given: "I have a reporter"
-        @Subject
-        def reporter = new CLIReporter(null, null)
-
-        and: "I have a testData"
-        def passedTestPair = new AbstractMap.SimpleEntry<>("Passed", true)
-        def failedTestPair = new AbstractMap.SimpleEntry<>("Failed", false)
-        def testData = Collections.nCopies(countPassed, passedTestPair) + Collections.nCopies(countFailed, failedTestPair)
-
-        when: "Generate the summary format"
-        def count = reporter.count(testData, isPassed)
-
-        then: "The format must be the same"
-        expectedCount == count
-
-        where: "Possible variants of tests"
-        countPassed | countFailed | isPassed || expectedCount
-        10          | 20          | true     || 10
-        10          | 20          | false    || 20
-    }
-
-    def "Summary format."() {
-        given: "I have a reporter"
-        @Subject
-        def reporter = new CLIReporter(null, null)
-
-        when: "Generate the summary format"
-        def format = reporter.summary(passed, failed)
-
-        then: "The format must be the same"
-        expectedFormat == format
-
-        where: "Possible variants of tests"
-        passed | failed || expectedFormat
-        10     | 20     || "Ran 30 tests.\nPassed: 10 (33.33%)\nFailed: 20 (66.67%)\n"
-        10     | 10     || "Ran 20 tests.\nPassed: 10 (50.00%)\nFailed: 10 (50.00%)\n"
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/reports/fmt/SimpleTestReportFormatterSpec.groovy

@@ -1,68 +0,0 @@
-package space.kklochko.simple_jbdd.tests.reports.fmt
-
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleFailedThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenWhenThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTestWithoutTitle
-import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand
-import space.kklochko.simple_jbdd.tests.commands.decorators.BlockDecorator
-import space.kklochko.simple_jbdd.tests.factories.meta.TestCommandMetaDataFactory
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The formatter must generate a format for the test command metadata, so
-those tests check if the formatter generate it right.
-""")
-@Title("Unit tests for SimpleTestReportFormatter")
-class SimpleTestReportFormatterSpec extends Specification {
-    def "If the map of methods have one test block."() {
-        given: "I have a metaData"
-        def metaData = [
-            new AbstractMap.SimpleEntry<>("Title", "A simple test"),
-            new AbstractMap.SimpleEntry<>("Then", "Then block")
-        ]
-
-        and: "I have the formatter object"
-        @Subject
-        def formatter = new SimpleTestReportFormatter(metaData, isPassed)
-
-        when: "Generate the format"
-        def format = formatter.format()
-
-        then: "The format must be the same"
-        expectedFormat == format
-
-        where: "Possible variants of tests"
-        isPassed || expectedFormat
-        true     || "✓ A simple test\n\tThen: Then block\n\n"
-        false    || "⨯ A simple test\n\tThen: Then block\n\n"
-    }
-
-    def "If the map of methods have GivenWhenThen blocks."() {
-        given: "I have a metaData"
-        def metaData = [
-            new AbstractMap.SimpleEntry<>("Title", "A simple test"),
-            new AbstractMap.SimpleEntry<>("Given", "Given block"),
-            new AbstractMap.SimpleEntry<>("When", "When block"),
-            new AbstractMap.SimpleEntry<>("Then", "Then block")
-        ]
-
-        and: "I have the formatter object"
-        @Subject
-        def formatter = new SimpleTestReportFormatter(metaData, isPassed)
-
-        when: "Generate the format"
-        def format = formatter.format()
-
-        then: "The format must be the same"
-        expectedFormat == format
-
-        where: "Possible variants of tests"
-        isPassed || expectedFormat
-        true     || "✓ A simple test\n\tGiven: Given block\n\tWhen: When block\n\tThen: Then block\n\n"
-        false    || "⨯ A simple test\n\tGiven: Given block\n\tWhen: When block\n\tThen: Then block\n\n"
-    }
-}
-

src/test/groovy/space/kklochko/simple_jbdd/tests/runners/IntegratedSimpleTestRunnerSpec.groovy

@@ -1,46 +0,0 @@
-package space.kklochko.simple_jbdd.tests.runners
-
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleEmptyTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleFailedThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenGivenWhenWhenThenThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenWhenThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
-import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTestWithoutTitle
-import space.kklochko.simple_jbdd.tests.factories.TestCommandFactory
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The runner must return a result of test, so
-those tests check if passed and failed test generate the right result.
-""")
-@Title("Integrated tests for SimpleTestRunner with TestCommandFactory and test examples")
-class IntegratedSimpleTestRunnerSpec extends Specification {
-    def "The real test has been run."() {
-        given: "I have a factory"
-        def factory = new TestCommandFactory();
-
-        and: "I have a testCommand created from a test object"
-        def test = factory.create(testObject)
-
-        and: "I have a test runner"
-        @Subject
-        def runner = new SimpleTestRunner(test)
-
-        when: "The testCommand has been run"
-        def result = runner.run()
-
-        then: "Checking that the test result is expected"
-        result == expectedResult
-
-        where: "Possible variants of tests"
-        testObject                                 || expectedResult
-        new SimpleThenTest()                       || true
-        new SimpleGivenWhenThenTest()              || true
-        new SimpleThenTestWithoutTitle()           || true
-        new SimpleFailedThenTest()                 || false
-        new SimpleGivenGivenWhenWhenThenThenTest() || true
-        new SimpleEmptyTest()                      || false
-    }
-}

src/test/groovy/space/kklochko/simple_jbdd/tests/runners/SimpleTestRunnerSpec.groovy

@@ -1,47 +0,0 @@
-package space.kklochko.simple_jbdd.tests.runners
-
-import space.kklochko.simple_jbdd.tests.commands.SimpleTestCommand
-import space.kklochko.simple_jbdd.tests.factories.TestCommandFactory
-import spock.lang.Narrative
-import spock.lang.Specification
-import spock.lang.Subject
-import spock.lang.Title
-
-@Narrative("""The runner must return a result of test, so
-those tests check if passed and failed test generate the right result.
-""")
-@Title("Unit tests for SimpleTestRunner")
-class SimpleTestRunnerSpec extends Specification {
-    def "The test with then has been passed."() {
-        given: "I have a testCommand"
-        def test = Stub(SimpleTestCommand)
-        test.test() >>> [true]
-
-        and: "I have a test runner"
-        @Subject
-        def runner = new SimpleTestRunner(test)
-
-        when: "The testCommand has been run"
-        def result = runner.run()
-
-        then: "The result is true"
-        result
-    }
-
-    def "The test with then that has not been passed."() {
-        given: "I have a failed testCommand"
-        def test = Stub(SimpleTestCommand)
-        test.test() >> { assert 1 == 0 }
-
-        and: "I have a test runner"
-        @Subject
-        def runner = new SimpleTestRunner(test)
-
-        when: "The testCommand has been run"
-        def result = runner.run()
-
-        then: "The result is false"
-        !result
-    }
-}
-