Alias for functions which compare two tests, used for sorting tests in test plan.

Alias for functions which filter tests. Should return true if the given test should be run, or false if it should be excluded.

Alias for program elements which can be used as a source for discovering tests.

Marks a function which will be run after each test in its scope. It allow to place common initialization logic into separate place.

class StarshipTest() {

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

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

Marks a toplevel function which will be executed once after all tests, after the test run is finished.

afterTestRun
void stopEmbeddedDatabase() { ... }

Marks a function which will be run before each test in its scope. It allow to place common initialization logic into separate place.

class StarshipTest() {

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

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

Marks a toplevel function which will be executed once before all tests, before the test run starts.

beforeTestRun
void startEmbeddedDatabase() { ... }

Marks a test or group of tests which should not be executed, which will be skipped during test run. 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() {

Annotations to specify source of argument values for parameterized tests, can be used for whole function or individually for each parameter. As a source, can be used toplevel value or function, which type is compatible with parameters of test function.

A test function may have multiple parameters, each with own value source. The test engine will execute it for each combination of provided values. For example, a function with one parameter whose argument provider yields two values, and second parameter whose argument provider yields three values, will be executed six times.

Example:

shared {[Integer, Integer]*} fibonnaciNumbers => {[1, 1], [2, 1], [3, 2], [4, 3], [5, 5], [6, 8] ...};

test
parameters(`value fibonnaciNumbers`)
shared void shouldCalculateFibonacciNumber(Integer input, Integer result) {
    assert(fibonacciNumber(input) == result);
}

Marks a test or group of tests with one or more tags, tags can be used for filtering, which tests will be executed.

For example test, which is failing often, but from unknow reasons, can be marked as unstable …

test
tag("unstable")
shared void shouldSucceedWithLittleLuck() { ... }

… and then excluded from test execution

$ceylon test --tag=!unstable com.acme.mymodule

… or visa versa, we can execute only tests with this tag

$ceylon test --tag=unstable com.acme.mymodule

Marks a function as being a 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 various TestExtension implementation, 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.

testExtension(`class DependencyInjectionInstancePostProcessor`,
              `class TransactionTestListener`)
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() {}

Verify all given assertions and any failures will be reported together.

Example:

assertAll([
    () => assertEquals(agent.id, "007"),
    () => assertEquals(agent.firstName, "James"),
    () => assertEquals(agent.lastName, "Bond")]);

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.

Example:

assertThatException(() => gandalf.castLightnings()).hasType(`NotEnoughMagicPowerException`);

Fails the test if the condition is false.

Abort test execution if the assumption condition is true.

Example:

test
shared void shouldUseNetwork() {
    assumeFalse(isDisconnected);
    ...
}

Abort test execution if the assumption condition is false.

Example:

test
shared void shouldUseDatabase() {
    assumeTrue(isDatabaseAvailable);
    ...
}

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.

Throws an AssertionError to fail a test.

Run function used by ceylon test and ceylon test-js tools, it is not supposed to be call directly from code.

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`];
    extensions = [RingingListener()];};

… or better declaratively with usage of testExtension() annotation

testExtension(`class RingingListener`)
module com.acme;

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.