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);
   }
 }
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, boolean modules, 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.
      modules - whether the compiler version must support modules.
      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

      protected abstract int minSupportedVersion(boolean modules)
      Get the minimum supported compiler version.
      Parameters:
      modules - whether to require module support or not.
      Returns:
      the minimum supported compiler version.

    • maxSupportedVersion

      protected abstract int maxSupportedVersion(boolean modules)
      Get the maximum supported compiler version.
      Parameters:
      modules - whether to require module support or not.
      Returns:
      the minimum supported compiler version.