Alias for functions which compare two tests.

Alias for functions which filter tests. Should return true if the given test should be run.

Alias for program elements from which tests can be run.

Marks a function which will be run after each test in its scope.

It allow to place common initialization logic into separate place. Only nullary functions should be annotated with afterTest.

class StarshipTest() {

    beforeTest 
    void init() => starship.chargePhasers();

    afterTest 
    void dispose() => starship.shutdownSystems();

Marks a function which will be run before each test in its scope.

It allow to place common initialization logic into separate place. Only nullary functions should be annotated with beforeTest.

class StarshipTest() {

    beforeTest 
    void init() => starship.chargePhasers();

    afterTest 
    void dispose() => starship.shutdownSystems();

Marks a test or group of tests which should not be executed.

It can be set on several places: on concrete test, on class which contains tests, on whole package or even module.

test
ignore("still not implemented")
void shouldBeFasterThanLight() {

Marks a function as being a test. Only nullary functions should be annotated with test.

Example of simplest test:

test
shared void shouldAlwaysSucceed() {}

Annotation to specify custom TestExecutor implementation, which will be used for running test.

It can be set on several places: on concrete test, on class which contains tests, on whole package or even module. If multiple occurrences will be found, the most closest will be used.

 testExecutor(`class ArquillianTestExecutor`)
 package com.acme;

Annotation to specify custom TestListeners, which will be used during running test.

It can be set on several places: on concrete test, on class which contains tests, on whole package or even module. If multiple occurrences will be found, all listeners will be used.

testListeners({`class DependencyInjectionTestListener`,
               `class TransactionalTestListener`})
package com.acme;

Annotation to specify test suite, which allow combine several tests or test suites and run them together.

testSuite({`class YodaTest`,
           `class DarthVaderTest`,
           `function starOfDeathTestSuite`})
shared void starwarsTestSuite() {}

Annotation class for afterTest().

Annotation class for beforeTest().

Annotation class for ignore().

Annotation class for test().

Annotation class for testExecutor().

Annotation class for testListeners().

Annotation class for testSuite()

A test state is error, if it propagates any exception which is not an AssertionError.

A test state is failure, if it propagates an AssertionError.

A test state is ignored, if it is marked with ignore() annotation.

A test state is success, if it complete normally (that is, does not throw an exception).

Fails the test if the given values are not equal according to the given compare function.

Fails the test if the condition is true.

Fails the test if the given values are equal according to the given compare function.

Fails the test if the given value is null.

Fails the test if the given value is not null.

Fails the test if expected exception isn't thrown.

Fails the test if the condition is false.

Create a new TestRunner for the given test sources and configures it according to the given parameters.

Default test comparator sort tests alphabetically.

Default test filter, always return true.

Compares two things. Returns true if both are null or both are non-null and are the same according to Object.equals().

Throws an AssertionError to fail a test.

Represent a strategy how to run test. During test execution notifies test mechanism about significant events via given TestRunContext.

Custom implementation can be specify via testExecutor() annotation. It should accept two parameters:

• the first parameter is own test function, represented like FunctionDeclaration
• the second parameter is class containg this test function, if exists, represented like ClassDeclaration?

Represents a listener which will be notified about events that occur during a test run.

Example of simple listener, which triggers alarm whenever test fails.

shared class RingingListener() satisfies TestListener {
    shared actual void testError(TestErrorEvent event) => alarm.ring();
}

… such listener can be used directly when creating TestRunner

TestRunner runner = createTestRunner{
    sources = [`module com.acme`];
    listeners = [RingingListener()];};

… or better declaratively with usage of testListeners() annotation

testListeners({`class RingingListener`})
module com.acme;

Represents a context in which a test is executed, it's used by TestExecutors.

Represents a summary result of the test run.

Represents a facade for running tests.

Instances are usually created via the createTestRunner() factory method. For running tests is more convenient to use command line tool ceylon test or use integration with IDE, so it is not necessary to use this API directly.

An assertions applicable to exceptions, see assertThatException().

Describes a test, or a group of tests, can be arranged in a tree.

Represents a detailed result of the execution of a particular test.

The result state of test execution.

A test state is error, if it propagates any exception which is not an AssertionError.

A test state is failure, if it propagates an AssertionError.

A test state is ignored, if it is marked with ignore() annotation.

A test state is success, if it complete normally (that is, does not throw an exception).

Thrown to indicate that two values which should have been “the same” (according to some comparison function) were in fact different.