Add the tests for test validators.

.drone.yaml

@@ -0,0 +1,24 @@
+---
+kind: pipeline
+type: docker
+name: gradle
+
+steps:
+  - name: test
+    image: gradle:8.3.0-jdk17-graal
+    commands:
+      - gradle assemble
+      - gradle check
+
+---
+kind: pipeline
+type: docker
+name: maven
+
+steps:
+  - name: test
+    image: maven:3.9.4-eclipse-temurin-17-alpine
+    commands:
+      - mvn install -DskipTests=true -Dmaven.javadoc.skip=true -B -V
+      - mvn test -B
+

CHANGELOG.md

@@ -0,0 +1,291 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.12.7] - 2023-30-16
+
+### Added
+- Add the CHANGELOG.
+
+## [0.12.6] - 2023-30-16
+
+### Fixed
+- Fix the project name for the gradle build.
+
+## [0.12.5] - 2023-30-15
+
+### Changed
+- Update the build configuration to make the JAR file.
+
+## [0.12.4] - 2023-30-15
+
+### Added
+- Add SimpleEmptyTest and its tests.
+
+## [0.12.3] - 2023-30-15
+
+### Added
+- Add the error for an empty test.
+
+## [0.12.2] - 2023-30-15
+
+### Changed
+- Update the titles for SimpleFailedThenTest and SimpleGivenWhenThenTest.
+
+## [0.12.1] - 2023-30-15
+
+### Added
+- Add a multi-block test.
+
+### Changed
+- Update the tests to test the multi-block test.
+
+## [0.12.0] - 2023-30-15
+
+### Added
+- Add the multi-block tests support.
+
+## [0.11.2] - 2023-30-10
+
+### Added
+- Add the main entry point.
+
+## [0.11.1] - 2023-30-10
+
+### Added
+- Add a constructor to set only a formatter for CLIReporter.
+
+## [0.11.0] - 2023-30-10
+
+### Added
+- Add the CLITestRunner to run tests and to report the result.
+
+## [0.10.1] - 2023-30-10
+
+### Changed
+- Update the CLI test formatting.
+
+## [0.10.0] - 2023-30-8
+
+### Added
+- Add the SingleTestLoader to create an object of a loaded Test class.
+
+## [0.9.2] - 2023-30-8
+
+### Added
+- Add a constructor with a default factory for TestCommandQueueFactory.
+
+## [0.9.1] - 2023-30-8
+
+### Fixed
+- Fix the test title for SingleTestClassLoader.
+
+## [0.9.0] - 2023-30-7
+
+### Added
+- Add the AbstractReporter.
+- Add the CLIReporter and its tests.
+
+## [0.8.3] - 2023-30-7
+
+### Added
+- Add Apache Commons Lang library.
+- Add default constructor for SimpleTestReportFormatter.
+
+## [0.8.2] - 2023-30-6
+
+### Added
+- Add the AbstractTestReportFormatter.
+
+### Changed
+- Refactor the SimpleTestReportFormatter to use the interface.
+
+## [0.8.1] - 2023-30-6
+
+### Fixed
+- Fix the encoding issue.
+
+## [0.8.0] - 2023-30-4
+
+### Added
+- Add the SimpleTestReportFormatter.
+
+## [0.7.0] - 2023-30-3
+
+### Added
+- Add the TestCommandMetaDataFactory to generate the metadata.
+
+## [0.6.3] - 2023-30-1
+
+### Added
+- Add the ClassLoader.
+
+## [0.6.2] - 2023-30-1
+
+### Fixed
+- Fix typos and improve description in the tests.
+
+## [0.6.1] - 2023-09-30
+
+### Added
+- Add the com.google.guava as a dependency.
+- Add the NameClassLoader.
+
+## [0.6.0] - 2023-09-29
+
+### Added
+- Add the single class loader.
+
+## [0.5.4] - 2023-09-27
+
+### Added
+- Add the queue factory for test commands.
+
+## [0.5.3] - 2023-09-26
+
+### Added
+- Add Abstract and Simple factories to create a test runner.
+
+## [0.5.2] - 2023-09-26
+
+### Changed
+- Refactor tests for the SimpleTestRunner.
+- Refactor the SimpleTestRunner and its test.
+
+## [0.5.1] - 2023-09-24
+
+### Fixed
+- Fix the BlockDecorator to throw the AsssertionError, if any.
+
+## [0.5.0] - 2023-09-24
+
+### Added
+- Add SimpleTestRunner as a test runner.
+
+## [0.4.1] - 2023-09-23
+
+### Added
+- Add the CI/CD configuration for Gradle and Maven build.
+
+## [0.4.0] - 2023-09-23
+
+### Added
+- Add the create method for the TestCommandFactory.
+
+## [0.3.1] - 2023-09-23
+
+### Added
+- Add the test block decorator.
+
+## [0.3.0] - 2023-09-23
+
+### Added
+- Add abstract and simple test commands.
+
+## [0.2.7] - 2023-09-23
+
+### Added
+- Add a test example without a title annotation.
+
+## [0.2.6] - 2023-09-23
+
+### Changed
+- Update test examples to have annotations with values.
+
+## [0.2.5] - 2023-09-23
+
+### Added
+- Add the Title annotation.
+
+## [0.2.4] - 2023-09-20
+
+### Added
+- Add the TestCommandFactory with a getTestMethods.
+
+## [0.2.3] - 2023-09-20
+
+### Added
+- Add the Test class as ABC.
+
+## [0.2.2] - 2023-09-20
+
+### Added
+- Add test examples.
+
+## [0.2.1] - 2023-09-20
+
+### Changed
+- Refactor the Sum class to be moved into the samples package.
+
+## [0.2.0] - 2023-09-19
+
+### Added
+- Add the Given-When-Then annotations.
+
+## [0.1.2] - 2023-09-19
+
+### Removed
+- Remove the test examples.
+
+## [0.1.1] - 2023-09-19
+
+### Added
+- Add the Sum class to test as an example.
+
+## [0.1.0] - 2023-09-19
+
+### Added
+- Project initialization.
+
+[Unreleased]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.5.3...main?from_project_id=50218541&straight=false
+: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.12.7...main?from_project_id=50536015&straight=false
+[0.12.7]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.12.6...0.12.7?from_project_id=50536015&straight=false
+[0.12.6]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.12.5...0.12.6?from_project_id=50536015&straight=false
+[0.12.5]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.12.4...0.12.5?from_project_id=50536015&straight=false
+[0.12.4]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.12.3...0.12.4?from_project_id=50536015&straight=false
+[0.12.3]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.12.2...0.12.3?from_project_id=50536015&straight=false
+[0.12.2]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.12.1...0.12.2?from_project_id=50536015&straight=false
+[0.12.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.12.0...0.12.1?from_project_id=50536015&straight=false
+[0.12.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.11.2...0.12.0?from_project_id=50536015&straight=false
+[0.11.2]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.11.1...0.11.2?from_project_id=50536015&straight=false
+[0.11.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.11.0...0.11.1?from_project_id=50536015&straight=false
+[0.11.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.10.1...0.11.0?from_project_id=50536015&straight=false
+[0.10.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.10.0...0.10.1?from_project_id=50536015&straight=false
+[0.10.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.9.2...0.10.0?from_project_id=50536015&straight=false
+[0.9.2]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.9.1...0.9.2?from_project_id=50536015&straight=false
+[0.9.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.9.0...0.9.1?from_project_id=50536015&straight=false
+[0.9.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.8.3...0.9.0?from_project_id=50536015&straight=false
+[0.8.3]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.8.2...0.8.3?from_project_id=50536015&straight=false
+[0.8.2]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.8.1...0.8.2?from_project_id=50536015&straight=false
+[0.8.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.8.0...0.8.1?from_project_id=50536015&straight=false
+[0.8.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.7.0...0.8.0?from_project_id=50536015&straight=false
+[0.7.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.6.3...0.7.0?from_project_id=50536015&straight=false
+[0.6.3]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.6.2...0.6.3?from_project_id=50536015&straight=false
+[0.6.2]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.6.1...0.6.2?from_project_id=50536015&straight=false
+[0.6.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.6.0...0.6.1?from_project_id=50536015&straight=false
+[0.6.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.5.4...0.6.0?from_project_id=50536015&straight=false
+[0.5.4]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.5.3...0.5.4?from_project_id=50536015&straight=false
+[0.5.3]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.5.2...0.5.3?from_project_id=50536015&straight=false
+[0.5.2]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.5.1...0.5.2?from_project_id=50536015&straight=false
+[0.5.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.5.0...0.5.1?from_project_id=50536015&straight=false
+[0.5.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.4.1...0.5.0?from_project_id=50536015&straight=false
+[0.4.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.4.0...0.4.1?from_project_id=50536015&straight=false
+[0.4.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.3.1...0.4.0?from_project_id=50536015&straight=false
+[0.3.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.3.0...0.3.1?from_project_id=50536015&straight=false
+[0.3.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.2.7...0.3.0?from_project_id=50536015&straight=false
+[0.2.7]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.2.6...0.2.7?from_project_id=50536015&straight=false
+[0.2.6]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.2.5...0.2.6?from_project_id=50536015&straight=false
+[0.2.5]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.2.4...0.2.5?from_project_id=50536015&straight=false
+[0.2.4]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.2.3...0.2.4?from_project_id=50536015&straight=false
+[0.2.3]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.2.2...0.2.3?from_project_id=50536015&straight=false
+[0.2.2]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.2.1...0.2.2?from_project_id=50536015&straight=false
+[0.2.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.2.0...0.2.1?from_project_id=50536015&straight=false
+[0.2.0]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.1.2...0.2.0?from_project_id=50536015&straight=false
+[0.1.2]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.1.1...0.1.2?from_project_id=50536015&straight=false
+[0.1.1]: https://gitlab.com/KKlochko/simple-jbdd/-/compare/0.1.0...0.1.1?from_project_id=50536015&straight=false
+[0.1.0]: https://gitlab.com/KKlochko/simple-jbdd/-/commit/dabb09c518cdfad4aa05ac9d86c857833b8db41c

build.gradle

@@ -1,23 +1,39 @@
 plugins {
     id('groovy')
+    id('application')
+    id 'com.github.johnrengelman.shadow' version '7.1.2'
 }
 
 version = "1.0"
 description = "simple-jbdd is a simple BDD testing framework for Java."
 
-// Spock works with Java 1.8 and above
+application {
+    mainClassName = 'space.kklochko.simple_jbdd.Main'
+}
+
+shadowJar {
+    mergeServiceFiles()
+    minimize()
+}
+
 java {
     toolchain {
         languageVersion.set(JavaLanguageVersion.of(17))
     }
 }
 
+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,10 +12,38 @@
     <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>
     <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>3.2.2</version>
+        <configuration>
+          <archive>
+            <manifest>
+              <mainClass>space.kklochko.simple_jbdd.Main</mainClass>
+              <addClasspath>true</addClasspath>
+            </manifest>
+          </archive>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.4.1</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
       <!-- Mandatory plugins for using Spock -->
       <plugin>
         <!-- The gmavenplus plugin is used to compile Groovy code. To learn more about this plugin,
@@ -77,6 +105,16 @@
   </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>
@@ -112,16 +150,5 @@
       <version>2.2</version>
       <scope>test</scope>
     </dependency>
-    <!-- Dependencies used by examples in this project (not required for using Spock) -->
-    <dependency>
-      <groupId>com.h2database</groupId>
-      <artifactId>h2</artifactId>
-      <version>2.2.222</version>
-    </dependency>
-    <dependency>
-      <groupId>org.apache.groovy</groupId>
-      <artifactId>groovy-sql</artifactId>
-      <version>${groovy.version}</version>
-    </dependency>
   </dependencies>
 </project>

settings.gradle

@@ -1 +1 @@
-rootProject.name = "simple_bdd"
+rootProject.name = "simple_jbdd"

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/annotations/Given.java

@@ -0,0 +1,13 @@
+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.METHOD)
+public @interface Given {
+    String value() default "Given";
+}
+

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

@@ -0,0 +1,13 @@
+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.METHOD)
+public @interface Then {
+    String value() default "Then";
+}
+

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

@@ -0,0 +1,13 @@
+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/annotations/When.java

@@ -0,0 +1,13 @@
+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.METHOD)
+public @interface When {
+    String value() default "When";
+}
+

src/main/java/space/kklochko/simple_jbdd/test_examples/samples/Calculator.java

@@ -0,0 +1,16 @@
+package space.kklochko.simple_jbdd.test_examples.samples;
+
+public class Calculator {
+    public int plus(int a, int b) {
+        return a + b;
+    }
+
+    public int subtract(int a, int b) {
+        return a - b;
+    }
+
+    public int multiply(int a, int b) {
+        return a * b + 1;
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/test_examples/samples/Sum.java

@@ -0,0 +1,8 @@
+package space.kklochko.simple_jbdd.test_examples.samples;
+
+public class Sum {
+    public static int sum(int a, int b) {
+        return a + b;
+    }
+}
+

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

@@ -0,0 +1,38 @@
+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.Calculator;
+import space.kklochko.simple_jbdd.tests.Test;
+
+@Title("3*3 must be 9")
+public class CalculatorMultiplyTest extends Test {
+    Calculator calculator;
+    int a;
+    int b;
+    int result;
+
+    @Given("Set up the calculator")
+    public void given() {
+        calculator = new Calculator();
+    }
+
+    @Given("Set up the arguments")
+    public void setupArguments() {
+        a = 3;
+        b = 3;
+    }
+
+    @When("Invoke the multiply method")
+    public void when() {
+        result = calculator.multiply(a, b);
+    }
+
+    @Then("3*3 must be 9")
+    public void then() {
+        assert result == 9;
+    }
+}
+

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

@@ -0,0 +1,37 @@
+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.Calculator;
+import space.kklochko.simple_jbdd.tests.Test;
+
+@Title("2+2 must be 4")
+public class CalculatorPlusTest extends Test {
+    Calculator calculator;
+    int a;
+    int b;
+    int result;
+
+    @Given("Set up the calculator")
+    public void given() {
+        calculator = new Calculator();
+    }
+
+    @Given("Set up the arguments")
+    public void setupArguments() {
+        a = b = 2;
+    }
+
+    @When("Invoke the plus method")
+    public void when() {
+        result = calculator.plus(a, b);
+    }
+
+    @Then("2+2 must be 4")
+    public void then() {
+        assert result == 4;
+    }
+}
+

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

@@ -0,0 +1,38 @@
+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.Calculator;
+import space.kklochko.simple_jbdd.tests.Test;
+
+@Title("4-2 must be 2")
+public class CalculatorSubtractTes extends Test {
+    Calculator calculator;
+    int a;
+    int b;
+    int result;
+
+    @Given("Set up the calculator")
+    public void given() {
+        calculator = new Calculator();
+    }
+
+    @Given("Set up the arguments")
+    public void setupArguments() {
+        a = 4;
+        b = 2;
+    }
+
+    @When("Invoke the subtract method")
+    public void when() {
+        result = calculator.subtract(a, b);
+    }
+
+    @Then("4-2 must be 2")
+    public void then() {
+        assert result == 2;
+    }
+}
+

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

@@ -0,0 +1,38 @@
+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.Calculator;
+import space.kklochko.simple_jbdd.tests.Test;
+
+@Title("4-2 must be 2")
+public class CalculatorSubtractTest extends Test {
+    Calculator calculator;
+    int a;
+    int b;
+    int result;
+
+    @Given("Set up the calculator")
+    public void given() {
+        calculator = new Calculator();
+    }
+
+    @Given("Set up the arguments")
+    public void setupArguments() {
+        a = 4;
+        b = 2;
+    }
+
+    @When("Invoke the subtract method")
+    public void when() {
+        result = calculator.subtract(a, b);
+    }
+
+    @Then("4-2 must be 2")
+    public void then() {
+        assert result == 2;
+    }
+}
+

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

@@ -0,0 +1,38 @@
+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.Calculator;
+import space.kklochko.simple_jbdd.tests.Test;
+
+@Title("Test that has method arguments")
+public class HasMethodArgumentsTest extends Test {
+    Calculator calculator;
+    int a;
+    int b;
+    int result;
+
+    @Given("Set up the calculator in a private method")
+    public void given(int a, int b) {
+        calculator = new Calculator();
+    }
+
+    @Given("Set up the arguments with arguments")
+    public void setupArguments(int a, int b) {
+        this.a = 4;
+        this.b = 2;
+    }
+
+    @When("Invoke the subtract method")
+    public void when() {
+        result = calculator.subtract(a, b);
+    }
+
+    @Then("4-2 must be 2 and return Bool value")
+    public void then() {
+        assert result == 2;
+    }
+}
+

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

@@ -0,0 +1,39 @@
+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.Calculator;
+import space.kklochko.simple_jbdd.tests.Test;
+
+@Title("Test with a method that return boolean")
+public class HasNonVoidMethodTest extends Test {
+    Calculator calculator;
+    int a;
+    int b;
+    int result;
+
+    @Given("Set up the calculator in a private method")
+    public void given() {
+        calculator = new Calculator();
+    }
+
+    @Given("Set up the arguments")
+    public void setupArguments() {
+        this.a = 4;
+        this.b = 2;
+    }
+
+    @When("Invoke the subtract method")
+    public void when() {
+        result = calculator.subtract(a, b);
+    }
+
+    @Then("4-2 must be 2 and return result")
+    public boolean then() {
+        assert result == 2;
+        return result != 2;
+    }
+}
+

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

@@ -0,0 +1,38 @@
+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.Calculator;
+import space.kklochko.simple_jbdd.tests.Test;
+
+@Title("Test with a private method")
+public class HasPrivateMethodTest extends Test {
+    Calculator calculator;
+    int a;
+    int b;
+    int result;
+
+    @Given("Set up the calculator in a private method")
+    private void given() {
+        calculator = new Calculator();
+    }
+
+    @Given("Set up the arguments")
+    public void setupArguments() {
+        this.a = 4;
+        this.b = 2;
+    }
+
+    @When("Invoke the subtract method")
+    public void when() {
+        result = calculator.subtract(a, b);
+    }
+
+    @Then("4-2 must be 2")
+    public void then() {
+        assert result == 2;
+    }
+}
+

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

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

@@ -0,0 +1,15 @@
+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() {
+        assert 30 == 10 + 20 + 1;
+    }
+}
+

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")
+    public void setup() {
+        sum = new Sum();
+    }
+
+    @Given("Setup the arguments")
+    public void setupArgs() {
+        a = 10;
+        b = 20;
+        c = 30;
+    }
+
+    @When("Call the .sum(10, 20)")
+    public void triggerAB() {
+        resultAB = sum.sum(a, b);
+    }
+
+    @When("Call the .sum(30, 20)")
+    public void triggerCB() {
+        resultCB = sum.sum(c, b);
+    }
+
+    @Then("10 + 20 is 30")
+    public void checkAB() {
+        assert 30 == resultAB;
+    }
+
+    @Then("30 + 20 is 50")
+    public void checkCB() {
+        assert 50 == resultCB;
+    }
+}
+

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

@@ -0,0 +1,32 @@
+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;
+    private int b;
+
+    @Given
+    public void setup() {
+        sum = new Sum();
+    }
+
+    @When
+    public void trigger() {
+        a = 10;
+        b = 20;
+    }
+
+    @Then
+    public void check() {
+        assert 30 == sum.sum(a, b);
+    }
+}
+

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

@@ -0,0 +1,14 @@
+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.")
+    public void check() {
+        assert 30 == 10 + 20;
+    }
+}
+

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

@@ -0,0 +1,13 @@
+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/Test.java

@@ -0,0 +1,6 @@
+package space.kklochko.simple_jbdd.tests;
+
+public abstract class Test {
+
+}
+

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

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

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

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

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

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

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

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

@@ -0,0 +1,108 @@
+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 space.kklochko.simple_jbdd.tests.factories.validators.*;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.*;
+
+public class TestCommandFactory {
+    public AbstractTestCommand create(Test input) {
+	    Class<?> aClass = input.getClass();
+	    Map<String, ArrayList<Method>> test_methods = this.getTestMethods(aClass);
+
+        AbstractTestCommand<Test> aTestCommand = createTest(aClass, input);
+
+        ArrayList<Validator> validators = new ArrayList<>();
+        validators.add(new EmptyValidator());
+        validators.add(new HasMethodsWithArgumentsValidator());
+        validators.add(new HasNonVoidMethodsValidator());
+        validators.add(new HasPrivateMethodsValidator());
+
+        for(var validator : validators) {
+            if(validator.validate(test_methods)) {
+                String name = validator.getMessage();
+                return new ErrorDecorator(name, aTestCommand, validator.getErrorType());
+            }
+        }
+
+        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) {
+        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();
+
+        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();
+
+            if (annotations.length == 0)
+                continue;
+
+            if(method.isAnnotationPresent(Given.class))
+                addMethodTo(test_methods, "Given", method);
+
+            if(method.isAnnotationPresent(When.class))
+                addMethodTo(test_methods, "When", method);
+
+            if(method.isAnnotationPresent(Then.class))
+                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

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

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

@@ -0,0 +1,34 @@
+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/factories/validators/EmptyValidator.java

@@ -0,0 +1,32 @@
+package space.kklochko.simple_jbdd.tests.factories.validators;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Map;
+
+public class EmptyValidator extends Validator {
+    private boolean isInvalid;
+
+    @Override
+    public boolean validate(Map<String, ArrayList<Method>> methods) {
+        isInvalid = (methods.size() == 0);
+        return isInvalid;
+    }
+
+    @Override
+    public String getErrorType() {
+        if(!isInvalid)
+            return "ok";
+
+        return "Error";
+    }
+
+    @Override
+    public String getMessage() {
+        if(!isInvalid)
+            return "ok";
+
+        return "ERROR!!! No blocks!!!";
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/factories/validators/HasMethodsWithArgumentsValidator.java

@@ -0,0 +1,19 @@
+package space.kklochko.simple_jbdd.tests.factories.validators;
+
+import java.lang.reflect.Method;
+
+public class HasMethodsWithArgumentsValidator extends MethodValidator {
+    @Override
+    protected boolean isMethodInvalid(Method method) {
+        return method.getParameterCount() != 0;
+    }
+
+    @Override
+    public String getMessage() {
+        if(!isInvalid)
+            return "ok";
+
+        return String.format("ERROR!!! Methods must have no arguments!!! Check methods: %s!!!", getMethodListAsString());
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/factories/validators/HasNonVoidMethodsValidator.java

@@ -0,0 +1,19 @@
+package space.kklochko.simple_jbdd.tests.factories.validators;
+
+import java.lang.reflect.Method;
+
+public class HasNonVoidMethodsValidator extends MethodValidator {
+    @Override
+    protected boolean isMethodInvalid(Method method) {
+        return !method.getReturnType().equals(void.class);
+    }
+
+    @Override
+    public String getMessage() {
+        if(!isInvalid)
+            return "ok";
+
+        return String.format("ERROR!!! Methods must have the void type!!! Check methods: %s!!!", getMethodListAsString());
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/factories/validators/HasPrivateMethodsValidator.java

@@ -0,0 +1,20 @@
+package space.kklochko.simple_jbdd.tests.factories.validators;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+public class HasPrivateMethodsValidator extends MethodValidator {
+    @Override
+    protected boolean isMethodInvalid(Method method) {
+        return !Modifier.isPublic(method.getModifiers());
+    }
+
+    @Override
+    public String getMessage() {
+        if(!isInvalid)
+            return "ok";
+
+        return String.format("ERROR!!! Methods must be public!!! Check method: %s!!!", getMethodListAsString());
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/factories/validators/MethodValidator.java

@@ -0,0 +1,48 @@
+package space.kklochko.simple_jbdd.tests.factories.validators;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+abstract public class MethodValidator extends Validator{
+    protected boolean isInvalid;
+
+    protected ArrayList<Method> invalidMethods;
+
+    protected String getMethodListAsString() {
+        return invalidMethods.stream()
+                .map(m -> m.getName())
+                .collect(Collectors.joining(", "));
+    }
+
+    abstract protected boolean isMethodInvalid(Method method);
+
+    @Override
+    public boolean validate(Map<String, ArrayList<Method>> methods) {
+        isInvalid = false;
+        invalidMethods = new ArrayList<>();
+
+        for(var key : methods.keySet()) {
+            for(var method : methods.get(key)) {
+                if(isMethodInvalid(method)) {
+                    isInvalid = true;
+                    invalidMethods.add(method);
+                }
+            }
+        }
+
+        return isInvalid;
+    }
+
+    @Override
+    public String getErrorType() {
+        if(!isInvalid)
+            return "ok";
+
+        return "Error";
+    }
+
+    abstract public String getMessage();
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/factories/validators/Validator.java

@@ -0,0 +1,11 @@
+package space.kklochko.simple_jbdd.tests.factories.validators;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Map;
+
+public abstract class Validator {
+    abstract public boolean validate(Map<String, ArrayList<Method>> methods);
+    abstract public String getErrorType();
+    abstract public String getMessage();
+}

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

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

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

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

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

@@ -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

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

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

@@ -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/main/java/space/kklochko/simple_jbdd/tests/runners/SimpleTestRunner.java

@@ -0,0 +1,29 @@
+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/DataDrivenSpec.groovy

@@ -1,57 +0,0 @@
-/*
- * Copyright 2009 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import spock.lang.*
-
-class DataDrivenSpec extends Specification {
-  def "maximum of two numbers"() {
-    expect:
-    Math.max(a, b) == c
-
-    where:
-    a << [3, 5, 9]
-    b << [7, 4, 9]
-    c << [7, 5, 9]
-  }
-
-  def "minimum of #a and #b is #c"() {
-    expect:
-    Math.min(a, b) == c
-
-    where:
-    a | b || c
-    3 | 7 || 3
-    5 | 4 || 4
-    9 | 9 || 9
-  }
-
-  def "#person.name is a #sex.toLowerCase() person"() {
-    expect:
-    person.getSex() == sex
-
-    where:
-    person                    || sex
-    new Person(name: "Fred")  || "Male"
-    new Person(name: "Wilma") || "Female"
-  }
-
-  static class Person {
-    String name
-    String getSex() {
-      name == "Fred" ? "Male" : "Female"
-    }
-  }
-}

src/test/groovy/DatabaseDrivenSpec.groovy

@@ -1,37 +0,0 @@
-/*
- * Copyright 2009 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import groovy.sql.Sql
-import spock.lang.Shared
-import spock.lang.Specification
-
-class DatabaseDrivenSpec extends Specification {
-  @Shared sql = Sql.newInstance("jdbc:h2:mem:", "org.h2.Driver")
-
-  // insert data (usually the database would already contain the data)
-  def setupSpec() {
-    sql.execute("create table maxdata (id int primary key, a int, b int, c int)")
-    sql.execute("insert into maxdata values (1, 3, 7, 7), (2, 5, 4, 5), (3, 9, 9, 9), (4, 2, -3, 2)")
-  }
-
-  def "Maximum of #a and #b is #c"() {
-    expect:
-    Math.max(a, b) == c
-
-    where:
-    [a, b, c] << sql.rows("select a, b, c from maxdata")
-  }
-}

src/test/groovy/HamcrestMatchersSpec.groovy

@@ -1,35 +0,0 @@
-/*
- * Copyright 2010 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *     http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import spock.lang.Specification
-
-import static spock.util.matcher.HamcrestMatchers.closeTo
-
-/**
- * Hamcrest matchers are deeply integrated with Spock's condition mechanism.
- * The syntax for using a matcher in a condition is simple:
- * {@code <expected-value> <matcher>}. If the condition fails, both the usual
- * condition output and the matcher's output will be shown.
- *
- * @author Peter Niederwiser
- * @since 0.5
- */
-class HamcrestMatchersSpec extends Specification {
-  def "comparing two decimal numbers"() {
-    def myPi = 3.14
-
-    expect:
-    myPi closeTo(Math.PI, 0.01)
-  }
-}

src/test/groovy/HelloSpockSpec.groovy

@@ -1,30 +0,0 @@
-/*
- * Copyright 2009 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import spock.lang.Specification
-
-class HelloSpockSpec extends Specification {
-  def "length of Spock's and his friends' names"() {
-    expect:
-    name.size() == length
-
-    where:
-    name     | length
-    "Spock"  | 5
-    "Kirk"   | 4
-    "Scotty" | 6
-  }
-}  

src/test/groovy/IncludeExcludeExtensionSpec.groovy

@@ -1,74 +0,0 @@
-/*
- * Copyright 2010 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *     http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import java.lang.annotation.*
-
-import spock.lang.Specification
-
-/**
- * Shows how methods can be included and excluded from a spec run. For
- * demonstration purposes, the configuration script's location is set
- * programmatically in a static initializer. Usually, the configuration
- * script's location would be set externally (via the same system property),
- * or the configuration script would reside in one of the two default locations:
- * <li>
- * <ul><tt>SpockConfig.groovy</tt> on the class path</ul>
- * <ul><tt>$user_home/.spock/SpockConfig.groovy</tt> on the file system</ul>
- * </li>
- *
- * <p>Note that the configuration script referenced by the system property
- * may either reside on the class path or on the file system (make sure to
- * include the whole path).
- *
- * <p>What's not shown here is that filtering also works for classes.
- * Whereas methods can only be filtered based on annotations, classes can
- * also be filtered based on their base class.
- *
- * <p>If you directly want to see the effect of different Spock configurations,
- * just run this spec from your IDE with an additional VM parameter
- * <li>
- * <ul><tt>-Dspock.configuration=IncludeFastConfig.groovy</tt> or</ul>
- * <ul><tt>-Dspock.configuration=ExcludeSlowConfig.groovy</tt></ul>
- * </li>
- *
- * <p>See also the two corresponding resource files provided with this spec.
- *
- * @since 0.4
- */
-class IncludeExcludeExtensionSpec extends Specification {
-  @Fast
-  def "a fast method"() {
-    println "fast"
-    expect: true
-  }
-
-  @Slow
-  def "a slow method"() {
-    println "slow"
-    expect: true
-  }
-
-  def "a neither fast nor slow method"() {
-    println "neither fast nor slow"
-    expect: true
-  }
-}
-
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.METHOD)
-@interface Fast {}
-
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.METHOD)
-@interface Slow {}

src/test/groovy/OrderedInteractionsSpec.groovy

@@ -1,45 +0,0 @@
-/*
- * Copyright 2010 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *     http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import spock.lang.*
-
-/**
- * The expected order of interactions can now be specified by using multiple
- * then-blocks. Interactions in a later then-block must take place after
- * interactions in an earlier then-block. The order of interactions within
- * the same then-block is unspecified.
- *
- * @since 0.4
- */
-class OrderedInteractionsSpec extends Specification {
-  def "collaborators must be invoked in order"() {
-    def coll1 = Mock(Collaborator)
-    def coll2 = Mock(Collaborator)
-
-    when:
-    // try to reverse the order of these invocations and see what happens
-    coll1.collaborate()
-    coll2.collaborate()
-
-    then:
-    1 * coll1.collaborate()
-
-    then:
-    1 * coll2.collaborate()
-  }
-}
-
-interface Collaborator {
-  def collaborate()
-}

src/test/groovy/PublisherSubscriberSpec.groovy

@@ -1,64 +0,0 @@
-/*
- * Copyright 2009 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import spock.lang.Specification
-
-class Publisher {
-  def subscribers = []
-
-  def send(event) {
-    subscribers.each {
-      try {
-        it.receive(event)
-      } catch (Exception e) {}
-    }
-  }
-}
-
-interface Subscriber {
-  def receive(event)
-}
-
-class PublisherSpec extends Specification {
-  def pub = new Publisher()
-  def sub1 = Mock(Subscriber)
-  def sub2 = Mock(Subscriber)
-
-  def setup() {
-    pub.subscribers << sub1 << sub2
-  }
-
-  def "delivers events to all subscribers"() {
-    when:
-    pub.send("event")
-
-    then:
-    1 * sub1.receive("event")
-    1 * sub2.receive("event")
-  }
-
-  def "can cope with misbehaving subscribers"() {
-    sub1.receive(_) >> { throw new Exception() }
-
-    when:
-    pub.send("event1")
-    pub.send("event2")
-
-    then:
-    1 * sub2.receive("event1")
-    1 * sub2.receive("event2")
-  }
-}

src/test/groovy/SpecInheritanceSpec.groovy

@@ -1,41 +0,0 @@
-/*
- * Copyright 2009 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */  
-
-import spock.lang.*
-
-abstract class BaseSpec extends Specification {
-  def x = { println 'base field initializer' }()
-
-  def setupSpec() { println 'base setupSpec()' }
-  def cleanupSpec() { println 'base cleanupSpec()' }
-
-  def setup() { println 'base setup()' }
-  def cleanup() { println 'base cleanup()' }
-
-  def baseSpecMethod() { setup: println 'base spec method' }
-}
-
-class DerivedSpec extends BaseSpec {
-  def y = { println 'derived field initializer' }()
-
-  def setupSpec() { println 'derived setupSpec()' }
-  def cleanupSpec() { println 'derived cleanupSpec()' }
-
-  def setup() { println 'derived setup()' }
-  def cleanup() { println 'derived cleanup()' }
-
-  def derivedSpecMethod() { setup: println 'derived spec method' }
-}

src/test/groovy/StackSpec.groovy

@@ -1,120 +0,0 @@
-/*
- * Copyright 2009 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import spock.lang.Specification
-
-class EmptyStackSpec extends Specification {
-  def stack = new Stack()
-
-  def "size"() {
-    expect: stack.size() == 0
-  }
-
-  def "pop"() {
-    when: stack.pop()
-    then: thrown(EmptyStackException)
-  }
-
-  def "peek"() {
-    when: stack.peek()
-    then: thrown(EmptyStackException)
-  }
-
-  def "push"() {
-    when:
-    stack.push("elem")
-
-    then:
-    stack.size() == old(stack.size()) + 1
-    stack.peek() == "elem"
-  }
-}
-
-class StackWithOneElementSpec extends Specification {
-  def stack = new Stack()
-
-  def setup() {
-    stack.push("elem")
-  }
-
-  def "size"() {
-    expect: stack.size() == 1
-  }
-
-  def "pop"() {
-    when:
-    def x = stack.pop()
-
-    then:
-    x == "elem"
-    stack.size() == 0
-  }
-
-  def "peek"() {
-    when:
-    def x = stack.peek()
-
-    then:
-    x == "elem"
-    stack.size() == 1
-  }
-
-  def "push"() {
-    when:
-    stack.push("elem2")
-
-    then:
-    stack.size() == 2
-    stack.peek() == "elem2"
-  }
-}
-
-class StackWithThreeElementsSpec extends Specification {
-  def stack = new Stack()
-
-  def setup() {
-    ["elem1", "elem2", "elem3"].each { stack.push(it) }
-  }
-
-  def "size"() {
-    expect: stack.size() == 3
-  }
-
-  def "pop"() {
-    expect:
-    stack.pop() == "elem3"
-    stack.pop() == "elem2"
-    stack.pop() == "elem1"
-    stack.size() == 0
-  }
-
-  def "peek"() {
-    expect:
-    stack.peek() == "elem3"
-    stack.peek() == "elem3"
-    stack.peek() == "elem3"
-    stack.size() == 3
-  }
-
-  def "push"() {
-    when:
-    stack.push("elem4")
-
-    then:
-    stack.size() == 4
-    stack.peek() == "elem4"
-  }
-}

src/test/groovy/StepwiseExtensionSpec.groovy

@@ -1,42 +0,0 @@
-/*
- * Copyright 2010 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *     http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import spock.lang.*
-
-/**
- * Demonstrates how {@code @Stepwise} causes a spec to be run in incremental steps.
- * Change a step's condition from {@literal true} to {@literal false}, and observe
- * how the remaining steps will be skipped automatically on the next run.
- * Also notice that if you run a single step (e.g. from the IDE's context menu),
- * all prior steps will also be run.
- *
- * <p>{@code @Stepwise} is particularly useful for higher-level specs whose
- * methods have logical dependencies.
- *
- * @since 0.4
- */
-@Stepwise
-class StepwiseExtensionSpec extends Specification {
-  def "step 1"() {
-    expect: true // try to change this to 'false'
-  }
-
-  def "step 2"() {
-    expect: true
-  }
-
-  def "step 3"() {
-    expect: true
-  }
-}

src/test/groovy/UsingJUnitRulesSpec.groovy

@@ -1,27 +0,0 @@
-/*
- * Copyright 2009 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *     http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import org.junit.Rule
-import org.junit.rules.TestName
-import spock.lang.Specification
-
-class UsingJUnitRulesSpec extends Specification {
-  @Rule TestName name
-
-  def "retrieve test name at runtime"() {
-    println "entering '$name.methodName'"
-    expect: 1 + 1 == 2
-    println "leaving '$name.methodName'"
-  }
-}

src/test/groovy/space/kklochko/simple_jbdd/test_examples/samples/SumSpec.groovy

@@ -0,0 +1,12 @@
+package space.kklochko.simple_jbdd.test_examples.samples
+
+import space.kklochko.simple_jbdd.test_examples.samples.Sum
+import spock.lang.Specification
+
+class SumSpec extends Specification {
+    def "Adding two numbers"() {
+        expect: "Two plus three is five."
+        5 == Sum.sum(2, 3);
+    }
+}
+

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

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

@@ -0,0 +1,95 @@
+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 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."() {
+        given: "I have a TestCommandFactory object"
+        @Subject
+        def factory = new TestCommandFactory();
+
+        when: "If a test command have blocks"
+        def map = factory.getTestMethods(testClass.getClass())
+
+        def count = map.values()
+                .stream()
+                .map {it.size()}
+                .reduce(0) { acc, num -> acc + num }
+
+        then: "the command have the expected block count"
+        expectedBlockCount == count
+
+        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

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

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

@@ -0,0 +1,93 @@
+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/factories/validators/IntegratedValidatorsSpec.groovy

@@ -0,0 +1,66 @@
+package space.kklochko.simple_jbdd.tests.factories.validators
+
+import space.kklochko.simple_jbdd.test_examples.tests.HasMethodArgumentsTest
+import space.kklochko.simple_jbdd.test_examples.tests.HasNonVoidMethodTest
+import space.kklochko.simple_jbdd.test_examples.tests.HasPrivateMethodTest
+import space.kklochko.simple_jbdd.test_examples.tests.SimpleEmptyTest
+import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenWhenThenTest
+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 validators must return true if a test class is invalid, so
+those tests check if validators return the right result.
+""")
+@Title("Integrated tests for Validators")
+class IntegratedValidatorsSpec extends Specification {
+    def "Validator return isInvalid"() {
+        given: "I have a factory and metadata"
+        def factory = new TestCommandFactory()
+        def metaData = factory.getTestMethods(testClass)
+
+        when: "Validating the test"
+        def isInvalid = validator.validate(metaData)
+
+        then: "The status must be expected"
+        isInvalid == expectedStatus
+
+        where: "Possible variants of tests"
+        validator                              | testClass                     || expectedStatus
+        new HasMethodsWithArgumentsValidator() | HasMethodArgumentsTest.class  || true
+        new HasMethodsWithArgumentsValidator() | SimpleGivenWhenThenTest.class || false
+        new HasNonVoidMethodsValidator()       | HasNonVoidMethodTest.class    || true
+        new HasMethodsWithArgumentsValidator() | SimpleGivenWhenThenTest.class || false
+        new HasPrivateMethodsValidator()       | HasPrivateMethodTest.class    || true
+        new HasMethodsWithArgumentsValidator() | SimpleGivenWhenThenTest.class || false
+        new EmptyValidator()                   | SimpleEmptyTest.class         || true
+        new HasMethodsWithArgumentsValidator() | SimpleGivenWhenThenTest.class || false
+    }
+
+    def "Validator return the error message"() {
+        given: "I have a factory and metadata"
+        def factory = new TestCommandFactory()
+        def metaData = factory.getTestMethods(testClass)
+
+        when: "Validating the test and checking the message"
+        validator.validate(metaData)
+        def message = validator.getMessage()
+
+        then: "The message must be expected"
+        message == expectedMessage
+
+        where: "Possible variants of tests"
+        validator                              | testClass                     || expectedMessage
+        new HasMethodsWithArgumentsValidator() | HasMethodArgumentsTest.class  || "ERROR!!! Methods must have no arguments!!! Check methods: given, setupArguments!!!"
+        new HasMethodsWithArgumentsValidator() | SimpleGivenWhenThenTest.class || "ok"
+        new HasNonVoidMethodsValidator()       | HasNonVoidMethodTest.class    || "ERROR!!! Methods must have the void type!!! Check methods: then!!!"
+        new HasMethodsWithArgumentsValidator() | SimpleGivenWhenThenTest.class || "ok"
+        new HasPrivateMethodsValidator()       | HasPrivateMethodTest.class    || "ERROR!!! Methods must be public!!! Check method: given!!!"
+        new HasMethodsWithArgumentsValidator() | SimpleGivenWhenThenTest.class || "ok"
+        new EmptyValidator()                   | SimpleEmptyTest.class         || "ERROR!!! No blocks!!!"
+        new HasMethodsWithArgumentsValidator() | SimpleGivenWhenThenTest.class || "ok"
+    }
+}
+

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

@@ -0,0 +1,43 @@
+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"
+        11 == 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

@@ -0,0 +1,25 @@
+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"
+        11 == classNames.size()
+    }
+}
+

src/test/groovy/space/kklochko/simple_jbdd/tests/loaders/IntegratedSingleClassLoader.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 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

@@ -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

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

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

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