Module io.github.ascopes.jct
Package io.github.ascopes.jct.junit

Class AbstractCompilersProvider

java.lang.Object
io.github.ascopes.jct.junit.AbstractCompilersProvider
All Implemented Interfaces:
ArgumentsProvider
Direct Known Subclasses:
JavacCompilersProvider
@API(since="0.0.1", status=STABLE) public abstract class AbstractCompilersProvider extends Object implements ArgumentsProvider
Base for defining a compiler-supplying arguments-provider for JUnit Jupiter parameterised test support.

An example annotation would look like the following: 


 @ArgumentsSource(MyCompilersProvider.class)
 @ParameterizedTest(name = "for {0}")
 @Retention(RetentionPolicy.RUNTIME)
 @Target({
     ElementType.ANNOTATION_TYPE,
     ElementType.METHOD,
     ElementType.TYPE,
 })
 public @interface MyCompilerTest {
     int minVersion() default Integer.MIN_VALUE;
     int maxVersion() default Integer.MAX_VALUE;
     Class<? extends JctSimpleCompilerConfigurer>[] configurers() default {};
     VersionStrategy versionStrategy() default VersionStrategy.RELEASE;
 }

...with the JUnit5 annotation provider being implemented as: 


 public final class MyCompilersProvider
     extends AbstractCompilersProvider
     implements AnnotationConsumer<MyCompilerTest> {

   @Override
   protected JctCompiler initializeNewCompiler() {
     return new MyCompilerImpl();
   }

   @Override
   protected int minSupportedVersion(boolean modules) {
     return 11;  // Support Java 11 as the minimum.
   }

   @Override
   protected int maxSupportedVersion(boolean modules) {
     return 19;  // Support Java 19 as the maximum.
   }

   @Override
   public void accept(MyCompilerTest annotation) {
     super.configure(
         annotation.minVersion(),
         annotation.maxVersion(),
         true,
         annotation.configurers(),
         annotation.versionStrategy(),
     );
   }
 }

This would enable you to define your test cases like so: 


 @MyCompilerTest(minVersion=13, maxVersion=17)
 void testSomething(JctCompiler compiler) {
   ...
 }

 @MyCompilerTest(configurers=WerrorConfigurer.class)
 void testSomethingElse(JctCompiler compiler) {
   ...
 }

 static class WerrorConfigurer implements JctCompilerConfigurer {
   @Override
   public void configure(JctCompiler compiler) {
     compiler.failOnErrors(true);
   }
 }

Note that if you are running your tests within a JPMS module, you will need to ensure that you declare your module to be open to io.github.ascopes.jct, otherwise this component will be unable to discover the constructor to initialise your configurer correctly, and may raise an exception as a result.

Since:
0.0.1
Author:
Ashley Scopes

  • Constructor Details

  • Method Details

    • provideArguments

      public Stream<? extends Arguments> provideArguments(ExtensionContext context)
      Specified by:
      provideArguments in interface ArgumentsProvider

    • configure

      protected final void configure(int min, int max, Class<? extends JctCompilerConfigurer<?>>[] configurerClasses, VersionStrategy versionStrategy)
      Configure this provider with parameters from annotations.
      Parameters:
      min - the inclusive minimum compiler version to use.
      max - the inclusive maximum compiler version to use.
      configurerClasses - the configurer classes to apply to each compiler.
      versionStrategy - the version strategy to use.

    • initializeNewCompiler

      protected abstract JctCompiler initializeNewCompiler()
      Initialise a new compiler.
      Returns:
      the compiler object.

    • minSupportedVersion

      @API(since="1.0.0", status=STABLE) protected abstract int minSupportedVersion()
      Get the minimum supported compiler version.
      Returns:
      the minimum supported compiler version.
      Since:
      1.0.0

    • maxSupportedVersion

      @API(since="1.0.0", status=STABLE) protected abstract int maxSupportedVersion()
      Get the maximum supported compiler version.
      Returns:
      the minimum supported compiler version.
      Since:
      1.0.0