Package org.opengis.test

Class TestCase

    • Field Detail

      • listener

        public final TestWatcher listener
        A JUnit rule for listening to test execution events. This rule forwards events to all registered listeners.

        This field is public because JUnit requires us to do so, but should be considered as an implementation details (it should have been a private field).

        Since:
        3.1

      • units

        protected final Units units
        Provider of units of measurement (degree, metre, second, etc), never null. The Units.degree(), metre() and other methods shall return Unit instances compatible with the units created by the Factory instances to be tested. Those Unit<?> instances depend on the Unit of Measurement (JSR-373) implementation used by the factories. If no units were explicitely specified, then the default units are used.
        Since:
        3.1

      • configurationTip

        protected transient Configuration.Key<Boolean> configurationTip
        A tip set by subclasses during the execution of some optional tests. In case of optional test failure, if this field is non-null, then a message will be logged at the Level.INFO for giving some tips to the developer about how he can disable the test.

        Example

        @Test
public void myTest() {
    if (isDerivativeSupported) {
        configurationTip = Configuration.Key.isDerivativeSupported;
        // Do some tests the require support of math transform derivatives.
    }
    configurationTip = null;
}
        Since:
        3.1

    • Constructor Detail

      • TestCase

        protected TestCase()
        Creates a new test without factory. This constructor is provided for subclasses that instantiate their test object directly, without using any factory.

    • Method Detail

      • factories

        @SafeVarargs
protected static List<Factory[]> factories​(Class<? extends Factory>... types)
        Returns factory instances for given factory interfaces. Each element in the returned list is the arguments to give to the subclass constructor. There is typically only one element in the list, but more elements could be included if many factory implementations are found for the same interface.

        This method is used by static methods having the Parameterized.Parameters annotation in subclasses. For example if a subclass constructor expects 3 factories of kind CRSFactory, CSFactory and DatumFactory in that order, then that subclass contains the following method:

        @Parameterized.Parameters
public static List<Factory[]> factories() {
    return factories(CRSFactory.class, CSFactory.class, DatumFactory.class);
}
        Note that the arrays may contain null elements if no factory implementation were found for a given interface. All GeoAPI test cases use Assume checks in order to disable any tests that require a missing factory.

        If many factory implementations were found for a given interface, then this method returns all possible combinations of those factories. For example if two instances of interface A are found (named A1 and A2), and two instances of interface B are also found (named B1 and B2), then this method returns a list containing:

        {A1, B1}
{A2, B1}
{A1, B2}
{A2, B2}
        The current implementation first checks the factories explicitely specified by calls to the TestSuite.setFactories(Class, Factory[]) method. In no factories were explicitely specified, then this method searches the classpath using ServiceLoader.
        Parameters:
        types - the kind of factories to fetch.
        Returns:
        all combinations of factories of the given kind. Each list element is an array having the same length than types.
        Since:
        3.1
        See Also:
        NameTest.factories(), ObjectFactoryTest.factories(), AuthorityFactoryTest.factories(), AffineTransformTest.factories(), ParameterizedTransformTest.factories()

      • factories

        @SafeVarargs
protected static List<Factory[]> factories​(FactoryFilter filter,
                                           Class<? extends Factory>... types)
        Returns factory instances for given factory interfaces, excluding the factories filtered by the given filter. This method performs the same work than factories(Class[]) except that the given filter is applied in addition to any filter found on the classpath.

        The main purpose of this method is to get AuthorityFactory instances for a given authority name.

        Parameters:
        filter - an optional factory filter to use in addition to any filter declared in the classpath, or null if none.
        types - the kind of factories to fetch.
        Returns:
        all combinations of factories of the given kind. Each list element is an array having the same length than types.
        Since:
        3.1

      • getEnabledFlags

        @SafeVarargs
protected final boolean[] getEnabledFlags​(Configuration.Key<Boolean>... properties)
        Returns booleans indicating whether the given operations are enabled. By default, every operations are enabled. However if any ImplementationDetails instance found on the classpath returns a configuration map having the value Boolean.FALSE for a given key, then the boolean value corresponding to that key is set to false.
        Parameters:
        properties - the key for which the flags are wanted.
        Returns:
        an array of the same length than properties in which each element at index i indicates whether the properties[i] test should be enabled.
        Since:
        3.1