org.xenei.junit.contract

Interface Dynamic

public interface Dynamic

Interface that defines a test suite as being dynamic. Dynamic test suites generate the list of test classes after they are instantiated Dynamic test suites implementations must have a method that is annotated with Dynamic.Inject and specifies the base injector method.

Tests that extend Dynamic alter the requirements of the ContractSuite. The suite must:

1. Have a ContractImpl annotation specifying the implementation being tested
2. Include a @Dynamic.Inject annotated getter that returns an IProducer<x> where "x" is the class specified in the ContractImpl
3. Each @RunWith(ContractSuite) annotated class listed in getSuiteClasses() must:
   1. Include a @Contract.Inject annotated setter that accepts the producer returned by the Dynamic.Inject annotated method above.
   2. Include a @Contract.Inject annotated getter that returns the producer required for the test.
   In general these classes convert the @Dynamic.Inject annotated producer into a producer that the underlying test can use.

The ContractSuite will:

1. Instantiate the class annotated with @RunWith( ContractSuite.class )
2. Find all the suites tests for the class specified by getSuiteClasses() and add them to the test suite. If any of those are annotated with ContractSuite the contract suite actions as described above will be executed. All other tests should run as expected.
3. execute all of the tests

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	Dynamic.Inject The Dynamic.Inject annotation specifies the getter to be called to retrieve an instance of a producer for the suite under test.

Method Summary

Modifier and Type	Method and Description
Collection<Class<?>>	getSuiteClasses() Get the set of set of classes in the test suite.

Method Detail

getSuiteClasses

Collection<Class<?>> getSuiteClasses()

Get the set of set of classes in the test suite.

Returns:

The set of classes in the test suite.