import io.github.olib963.javatest.Assertion;
import static io.github.olib963.javatest.JavaTest.that;

public class MyAssertions {
    Assertion simpleAssertion = that(1 + 1 == 2, "Expected one add one to be two");

    public Assertion multilineFormattedAssertion() {
        var two = 2;
        var ten = 10;
        var twenty = 20;
        var expected = String.format("Expected %d times %d to be %d", two, ten, twenty);
        return that(two * ten == twenty, expected);
    }
}

import io.github.olib963.javatest.Assertion;
import static io.github.olib963.javatest.JavaTest.*;

public class MyComposedAssertions {
    Assertion orAssertion = that(1 + 1 == 3, "Expected one add one to be three")
            .or(that(2 + 2 == 4, "Expected two add two to be four"));

    Assertion andAssertion = that(1 + 1 == 2, "Expected one add one to be two").and(orAssertion);

    Assertion xorAssertion = that(true, "Expected to hold").xor(that(false, "Expected not to hold"));
}

import io.github.olib963.javatest.Assertion;
import static io.github.olib963.javatest.JavaTest.*;

public class MyAllAssertions {
    Assertion allAssertion = all(
            that(1 + 1 == 2, "Expected one add one to be two"),
            that(2 + 2 == 4, "Expected two add two to be four"),
            that(3 + 3 == 6, "Expected three add three to be six"),
            that(4 + 4 == 8, "Expected four add four to be eight"),
            that(5 + 5 == 10, "Expected five add five to be ten")
    );
}

import io.github.olib963.javatest.Testable.Test;
import static io.github.olib963.javatest.JavaTest.*;

public class MyTests {
    Test myFirstTest = test("Simple Test", () -> that(true, "Expected test to pass"));
}

import io.github.olib963.javatest.Testable.TestSuite;

import java.util.List;

import static io.github.olib963.javatest.JavaTest.*;

public class MyFirstTestSuite {

    public static TestSuite mySuite() {
        return suite("MyTests", List.of(
                test("Simple Test", () -> that(true, "Expected test to pass"))
        ));
    }
}

import io.github.olib963.javatest.TestSuiteClass;
import io.github.olib963.javatest.Testable;

import java.util.Collection;
import java.util.List;

import static io.github.olib963.javatest.JavaTest.*;

public class MyPendingTests implements TestSuiteClass {
    @Override
    public Collection<Testable> testables() {
        return List.of(
                test("Addition", () -> that(1 + 1 == 2, "Expected one add one to be two")),
                test("Multiplication", () -> pending()),
                test("Division by Zero",
                        () -> pending("I am not yet sure if this should throw an exception or return a failure value"))
        );
    }
}

import java.util.Collections;
import java.util.List;
import io.github.olib963.javatest.*;

import static io.github.olib963.javatest.JavaTest.*;

public class MyRunners {

    public TestRunner singleTestRunner = testableRunner(List.of(
            test("Simple test", () -> pending())));

    public TestRunner suiteTests = testableRunner(
            List.of(MyFirstTestSuite.mySuite(), new ClassAsSuite())
    );
}

import io.github.olib963.javatest.RunConfiguration;
import io.github.olib963.javatest.TestCompletionObserver;

public class RunConfigurations {

    // Configuration that logs individual tests in colour and the full results of the run
    public RunConfiguration defaultConfig = RunConfiguration.defaultConfig();

    // Configuration that logs individual tests with no colour and logs a warning
    // if there are any pending tests at all in the run.
    public RunConfiguration customConfig = RunConfiguration.empty()
            .addTestObserver(TestCompletionObserver.plainLogger())
            .addRunObserver(results -> {
                if (results.pendingCount != 0) {
                    System.err.println("!!You still have unwritten tests!!");
                }
            });
}

import io.github.olib963.javatest.*;

import java.util.List;

import static io.github.olib963.javatest.JavaTest.*;

public class MyEntrypoint {
    public static void main(String... args) {
        var results = runTests(List.of(
                test("Addition", () -> that(1 + 1 == 2, "Expected one add one to be two")),
                test("String lower case", () ->
                        that("HELLO".toLowerCase().equals("hello"), "Expected lowercase 'HELLO' to be 'hello'"))
        ));

        var customResults = run(new MyCustomRunner());
        if(results.succeeded && customResults.succeeded) {
            System.out.println("Yay tests passed! :)");
        } else {
            throw new RuntimeException("Boo tests failed! :(");
        }
    }
}

package my.awesome.app;

import io.github.olib963.javatest.*;
import io.github.olib963.javatest.fixtures.Fixtures;
import io.github.olib963.javatest.javafire.TestRunners;

import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static io.github.olib963.javatest.JavaTest.*;

public class MyRunners implements TestRunners {

    @Override
    public Collection<TestRunner> runners() {
        // Define a runner for unit tests in parallel
        List<Testable> tests = List.of(new MyFirstUnitTestSuite(), new MySecondUnitTestSuite());
        var unitTests = lazyTestableRunner(tests.parallelStream());

        // Define integration tests with an executor fixture
        var executorDefinition = Fixtures.definitionFromThrowingFunctions(
                Executors::newSingleThreadExecutor, ExecutorService::shutdown);

        var integrationTests = Fixtures.fixtureRunner("executor",
                executorDefinition,
                es -> testableRunner(new MyIntegrationTestSuite(es)));
        // Run both
        return List.of(unitTests, integrationTests);
    }

}