Update the titles for SimpleFailedThenTest and SimpleGivenWhenThenTest.

build.gradle

@@ -12,6 +12,10 @@ java {
     }
 }
 
+compileJava {
+    options.encoding = 'UTF-8'
+}
+
 repositories {
   // Spock releases are available from Maven Central
   mavenCentral()
@@ -19,6 +23,7 @@ repositories {
 
 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

@@ -84,6 +84,11 @@
       <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

@@ -0,0 +1,24 @@
+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/test_examples/tests/SimpleFailedThenTest.java

@@ -5,7 +5,7 @@ import space.kklochko.simple_jbdd.annotations.Title;
 import space.kklochko.simple_jbdd.tests.Test;
 
 
-@Title("A Simple Failed GivenWhenTest for Sum")
+@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

@@ -0,0 +1,51 @@
+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

@@ -7,7 +7,7 @@ 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 GivenWhenTest for Sum")
+@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/tests/factories/TestCommandFactory.java

@@ -11,37 +11,48 @@ import space.kklochko.simple_jbdd.tests.commands.decorators.BlockDecorator;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
-import java.util.Map;
-import java.util.TreeMap;
+import java.util.*;
 
 public class TestCommandFactory {
     public AbstractTestCommand create(Test input) {
 	    Class<?> aClass = input.getClass();
-	    Map<String, Method> test_methods = this.getTestMethods(aClass);
+	    Map<String, ArrayList<Method>> test_methods = this.getTestMethods(aClass);
 
         AbstractTestCommand<Test> aTestCommand = createTest(aClass, input);
 
         if(test_methods.containsKey("Then")) {
-            Method then = test_methods.get("Then");
-            String label = then.getAnnotation(Then.class).value();
-            aTestCommand = new BlockDecorator<Test>(label, aTestCommand, then, "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")) {
-            Method when = test_methods.get("When");
-            String label = when.getAnnotation(When.class).value();
-            aTestCommand = new BlockDecorator<Test>(label, aTestCommand, when, "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")) {
-            Method when = test_methods.get("Given");
-            String label = when.getAnnotation(Given.class).value();
-            aTestCommand = new BlockDecorator<Test>(label, aTestCommand, when, "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) {
+        ArrayList<Method> methods = test_methods.get(key);
+        Collections.reverse(methods);
+        return methods;
+    }
+
     protected AbstractTestCommand<Test> createTest(Class<?> aClass, Test input) {
         Title aTitle = aClass.getAnnotation(Title.class);
         String title = aClass.getName();
@@ -52,8 +63,8 @@ public class TestCommandFactory {
         return new SimpleTestCommand<Test>(title, input);
     }
 
-    protected <T extends Test> Map<String, Method> getTestMethods(Class<?> aClass) {
-        Map<String, Method> test_methods = new TreeMap<String, Method>();
+    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();
@@ -62,15 +73,21 @@ public class TestCommandFactory {
                 continue;
 
             if(method.isAnnotationPresent(Given.class))
-                test_methods.put("Given", method);
+                addMethodTo(test_methods, "Given", method);
 
             if(method.isAnnotationPresent(When.class))
-                test_methods.put("When", method);
+                addMethodTo(test_methods, "When", method);
 
             if(method.isAnnotationPresent(Then.class))
-                test_methods.put("Then", method);
+                addMethodTo(test_methods, "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

@@ -9,6 +9,11 @@ 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);

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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -5,45 +5,30 @@ import space.kklochko.simple_jbdd.tests.Test;
 import java.util.AbstractMap;
 import java.util.ArrayList;
 
-public class SimpleTestReportFormatter {
-    private ArrayList<AbstractMap.SimpleEntry<String, String>> testMetaData;
-    private boolean isPassed;
+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) {
-        setTestMetaData(testMetaData);
-        setPassed(isPassed);
+        super(testMetaData, isPassed);
     }
 
     public String format() {
-        String status = (isPassed) ? getPassedIcon() : getFailedIcon();
+        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());
+            result += String.format("\t%s: %s\n", pair.getKey(), pair.getValue());
         }
 
-        return result;
-    }
-
-    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;
+        return result + '\n';
     }
 
     public String getPassedIcon() {

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

@@ -0,0 +1,102 @@
+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/test/groovy/space/kklochko/simple_jbdd/tests/factories/TestCommandFactorySpec.groovy

@@ -1,5 +1,6 @@
 package space.kklochko.simple_jbdd.tests.factories
 
+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
@@ -14,19 +15,27 @@ those tests check if factory generate them right.
 """)
 @Title("Unit tests for TestCommandFactory")
 class TestCommandFactorySpec extends Specification {
-    def "If the map of methods have one test block."() {
+    def "The command have the same block count."() {
         given: "I have a TestCommandFactory object"
         @Subject
         def factory = new TestCommandFactory();
 
-        and: "I also have a SimpleThenTest object"
-        def simpleThenTest = new SimpleThenTest()
+        when: "If a test command have blocks"
+        def map = factory.getTestMethods(testClass.getClass())
 
-        when: "If a test have only one block"
-        def map = factory.getTestMethods(simpleThenTest.getClass())
+        def count = map.values()
+                .stream()
+                .map {it.size()}
+                .reduce(0) { acc, num -> acc + num }
 
-        then: "the map size is 1 method"
-        1 == map.size()
+        then: "the command have the expected block count"
+        expectedBlockCount == count
+
+        where:
+        testClass                                  || expectedBlockCount
+        new SimpleThenTest()                       || 1
+        new SimpleGivenWhenThenTest()              || 3
+        new SimpleGivenGivenWhenWhenThenThenTest() || 6
     }
 
     def "createTest() sets the title to a class name if no Title annotation."() {
@@ -63,34 +72,22 @@ class TestCommandFactorySpec extends Specification {
         title == test.getLabels()['Title']
     }
 
-    def "createTest() build a Test with only Then."() {
+    def "createTest() build a TestCommand that contains the expected blocks."() {
         given: "I have a test factory"
         @Subject
         def factory = new TestCommandFactory()
 
-        and: "I have a test class with Title"
-        def testClass = new SimpleThenTest()
-
         when: "I build a test"
         def test = factory.create(testClass)
 
-        then: "The test have title and then method"
-        ['Title', 'Then'].toSet() == test.getLabels().keySet()
-    }
+        then: "The test have the expected blocks"
+        expectedBlocks.toSet() == test.getLabels().keySet()
 
-    def "createTest() build a Test with Given-When-Then."() {
-        given: "I have a test factory"
-        @Subject
-        def factory = new TestCommandFactory()
-
-        and: "I have a test class with Title and Given-When-Then"
-        def testClass = new SimpleGivenWhenThenTest()
-
-        when: "I build a test"
-        def test = factory.create(testClass)
-
-        then: "The test have title and then method"
-        ['Title', 'Given', 'When', 'Then'].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/loaders/IntegratedClassLoader.groovy

@@ -22,7 +22,7 @@ class IntegratedClassLoader extends Specification {
         def classes = loader.load()
 
         then: "Checking that the test result is expected"
-        3 == classes.size()
+        4 == classes.size()
     }
 
     def "The classes must be represent the Test interface."() {

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

@@ -19,7 +19,7 @@ class IntegratedNameClassLoader extends Specification {
         def classNames = loader.load()
 
         then: "Checking that the test result is expected"
-        3 == classNames.size()
+        4 == classNames.size()
     }
 }
 

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

@@ -9,7 +9,7 @@ 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 ClassLoader.")
+@Title("Integrated tests for SingleClassLoader.")
 class IntegratedSingleClassLoader extends Specification {
     def "The class has been loaded."() {
         given: "I have a class loader"

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -36,8 +36,8 @@ class SimpleTestReportFormatterSpec extends Specification {
 
         where: "Possible variants of tests"
         isPassed || expectedFormat
-        true     || "✓ A simple test\n\tThen Then block\n"
-        false    || "⨯ A simple test\n\tThen Then block\n"
+        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."() {
@@ -61,8 +61,8 @@ class SimpleTestReportFormatterSpec extends Specification {
 
         where: "Possible variants of tests"
         isPassed || expectedFormat
-        true     || "✓ A simple test\n\tGiven Given block\n\tWhen When block\n\tThen Then block\n"
-        false    || "⨯ A simple test\n\tGiven Given block\n\tWhen When block\n\tThen Then block\n"
+        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,6 +1,7 @@
 package space.kklochko.simple_jbdd.tests.runners
 
 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
@@ -33,10 +34,11 @@ class IntegratedSimpleTestRunnerSpec extends Specification {
         result == expectedResult
 
         where: "Possible variants of tests"
-        testObject                       || expectedResult
-        new SimpleThenTest()             || true
-        new SimpleGivenWhenThenTest()    || true
-        new SimpleThenTestWithoutTitle() || true
-        new SimpleFailedThenTest()       || false
+        testObject                                 || expectedResult
+        new SimpleThenTest()                       || true
+        new SimpleGivenWhenThenTest()              || true
+        new SimpleThenTestWithoutTitle()           || true
+        new SimpleFailedThenTest()                 || false
+        new SimpleGivenGivenWhenWhenThenThenTest() || true
     }
 }