Implement default method for AbstractJctCompiler#getFileManagerFactory

Author: ascopes

java-compiler-testing/src/main/java/io/github/ascopes/jct/compilers/AbstractJctCompiler.java

@@ -23,6 +23,7 @@
 import io.github.ascopes.jct.ex.JctCompilerException;
 import io.github.ascopes.jct.filemanagers.AnnotationProcessorDiscovery;
 import io.github.ascopes.jct.filemanagers.JctFileManagerFactory;
+import io.github.ascopes.jct.filemanagers.JctFileManagers;
 import io.github.ascopes.jct.filemanagers.LoggingMode;
 import io.github.ascopes.jct.workspaces.Workspace;
 import java.io.IOException;
@@ -432,9 +433,15 @@ public final String toString() {
   /**
    * Get the file manager factory to use for building AbstractJctCompiler file manager during compilation.
    *
+   * <p>Since v1.1.0, this method has provided a default implementation. Before this, it was
+   * abstract. The default implementation calls
+   * {@link JctFileManagers#newJctFileManagerFactory(JctCompiler)}.
+   *
    * @return the factory.
    */
-  public abstract JctFileManagerFactory getFileManagerFactory();
+  public JctFileManagerFactory getFileManagerFactory() {
+    return JctFileManagers.newJctFileManagerFactory(this);
+  }
 
   /**
    * Get the compilation factory to use for building a compilation.
@@ -444,7 +451,9 @@ public final String toString() {
    *
    * <p>Some obscure compiler implementations with potentially satanic rituals for initialising
    * and configuring components correctly may need to provide a custom implementation here instead.
-   * In this case, this method should be overridden.
+   * In this case, this method should be overridden. Base classes are not provided for you to
+   * extend in this case as this is usually not something you want to be doing. Instead, you should
+   * implement {@link JctCompilationFactory} directly.
    *
    * @return the compilation factory.
    */

java-compiler-testing/src/test/java/io/github/ascopes/jct/tests/unit/compilers/AbstractJctCompilerTest.java

@@ -29,6 +29,7 @@
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockConstruction;
+import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -47,6 +48,7 @@
 import io.github.ascopes.jct.filemanagers.AnnotationProcessorDiscovery;
 import io.github.ascopes.jct.filemanagers.JctFileManager;
 import io.github.ascopes.jct.filemanagers.JctFileManagerFactory;
+import io.github.ascopes.jct.filemanagers.JctFileManagers;
 import io.github.ascopes.jct.filemanagers.LoggingMode;
 import io.github.ascopes.jct.workspaces.Workspace;
 import java.io.IOException;
@@ -85,6 +87,7 @@
 import org.mockito.Mock;
 import org.mockito.MockedConstruction;
 import org.mockito.MockedConstruction.Context;
+import org.mockito.MockedStatic;
 import org.mockito.junit.jupiter.MockitoExtension;
 
 /**
@@ -103,9 +106,6 @@ class AbstractJctCompilerTest {
   @Mock(answer = Answers.RETURNS_MOCKS)
   Jsr199CompilerFactory jsr199CompilerFactory;
 
-  @Mock(answer = Answers.RETURNS_MOCKS)
-  JctFileManagerFactory fileManagerFactory;
-
   String name;
   String defaultRelease;
   CompilerImpl compiler;
@@ -309,14 +309,20 @@ void constructorInitialisesAnnotationProcessorDiscoveryToDefaultValue() {
   }
 
   @ExtendWith(MockitoExtension.class)
-  @SuppressWarnings("unused")
+  @SuppressWarnings({"unused", "JUnitMalformedDeclaration" /* IDEA-326883 */})
   abstract class AbstractCompileTestTemplate {
 
     @Mock
     Workspace workspace;
 
     List<String> flags;
 
+    @Mock
+    MockedStatic<JctFileManagers> fileManagers;
+
+    @Mock
+    JctFileManagerFactory fileManagerFactory;
+
     @Mock
     JctFileManager fileManager;
 
@@ -345,6 +351,8 @@ void setUp() {
 
       when(flagBuilderFactory.createFlagBuilder()).thenReturn(flagBuilder);
       when(jsr199CompilerFactory.createCompiler()).thenReturn(jsr199Compiler);
+      fileManagers.when(() -> JctFileManagers.newJctFileManagerFactory(any()))
+            .thenReturn(fileManagerFactory);
       when(fileManagerFactory.createFileManager(any())).thenReturn(fileManager);
 
       // Default implementation. We can override this to make it throw exceptions, etc.
@@ -1558,6 +1566,24 @@ void toStringShouldReturnTheName() {
     assertThat(compiler).hasToString(name);
   }
 
+  @DisplayName(".getFileManagerFactory() should build a new file manager factory impl")
+  @Test
+  void getFileManagerFactoryShouldBuildNewFileManagerFactoryImpl() {
+    // Given
+    try (var fileManagersCls = mockStatic(JctFileManagers.class)) {
+      var expectedFactory = mock(JctFileManagerFactory.class);
+      fileManagersCls.when(() -> JctFileManagers.newJctFileManagerFactory(any()))
+          .thenReturn(expectedFactory);
+
+      // When
+      var actualFactory = compiler.getFileManagerFactory();
+
+      // Then
+      fileManagersCls.verify(() -> JctFileManagers.newJctFileManagerFactory(compiler));
+      assertThat(actualFactory).isSameAs(expectedFactory);
+    }
+  }
+
   @DisplayName(".getCompilationFactory() should build a new compilation factory impl")
   @Test
   void getCompilationFactoryBuildsCompilationFactoryImpl() {
@@ -1668,11 +1694,6 @@ public Jsr199CompilerFactory getCompilerFactory() {
       return jsr199CompilerFactory;
     }
 
-    @Override
-    public JctFileManagerFactory getFileManagerFactory() {
-      return fileManagerFactory;
-    }
-
     @Override
     public List<String> buildFlags(JctFlagBuilder flagBuilder) {
       // Promote this method to be public for testing.