src/test/java/org/apache/maven/plugin/compiler/CompilerMojoTestCase.java - maven-compiler-plugin - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.maven.plugin.compiler;

 import java.io.File;
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.net.URI;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.apache.maven.api.PathScope;
 import org.apache.maven.api.Project;
 import org.apache.maven.api.Session;
 import org.apache.maven.api.di.Inject;
 import org.apache.maven.api.di.Provides;
 import org.apache.maven.api.di.Singleton;
 import org.apache.maven.api.model.Build;
 import org.apache.maven.api.model.Model;
 import org.apache.maven.api.plugin.Log;
 import org.apache.maven.api.plugin.testing.Basedir;
 import org.apache.maven.api.plugin.testing.InjectMojo;
 import org.apache.maven.api.plugin.testing.MojoExtension;
 import org.apache.maven.api.plugin.testing.MojoParameter;
 import org.apache.maven.api.plugin.testing.MojoTest;
 import org.apache.maven.api.plugin.testing.stubs.ProducedArtifactStub;
 import org.apache.maven.api.plugin.testing.stubs.ProjectStub;
 import org.apache.maven.api.plugin.testing.stubs.SessionMock;
 import org.apache.maven.api.services.ArtifactManager;
 import org.apache.maven.api.services.MessageBuilderFactory;
 import org.apache.maven.api.services.ToolchainManager;
 import org.apache.maven.impl.DefaultMessageBuilderFactory;
 import org.apache.maven.impl.InternalSession;
 import org.apache.maven.plugin.compiler.stubs.CompilerStub;
 import org.junit.jupiter.api.Test;

 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.startsWith;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;

 @MojoTest
 public class CompilerMojoTestCase {

     private static final String LOCAL_REPO = "/target/local-repo";

     @Inject
     private Session session;

     /**
      * Verifies that the {@value CompilerStub#OUTPUT_FILE} file exists, then deletes it.
      * The deletion is necessary for preventing an {@link IndexOutOfBoundsException} in
      * {@code maven-dependency-plugin} version 3.8.1, because the output file is empty.
      *
      * @param mojo the tested mojo
      */
     private static void assertCompilerStubOutputFileExists(AbstractCompilerMojo mojo) {
         try {
             Files.delete(assertOutputFileExists(mojo, CompilerStub.OUTPUT_FILE));
         } catch (IOException e) {
             throw new UncheckedIOException(e);
         }
     }

     /**
      * Verifies that the given output file exists.
      *
      * @param mojo the tested mojo
      * @param first the first path element
      * @param more the other path elements, if any
      * @return the file
      */
     private static Path assertOutputFileExists(AbstractCompilerMojo mojo, String first, String... more) {
         Path file = mojo.getOutputDirectory().resolve(Path.of(first, more));
         assertTrue(Files.isRegularFile(file), () -> "File not found: " + file);
         return file;
     }

     /**
      * Verifies that the given output file does not exist.
      *
      * @param mojo the tested mojo
      * @param first the first path element
      * @param more the other path elements, if any
      */
     private static void assertOutputFileDoesNotExist(AbstractCompilerMojo mojo, String first, String... more) {
         Path file = mojo.getOutputDirectory().resolve(Path.of(first, more));
         assertFalse(Files.exists(file), () -> "File should not exist: " + file);
     }

     /**
      * Tests the ability of the plugin to compile a basic file.
      * This test does not declare a Java release version. Therefore, a warning should be emitted.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-basic-test")
     public void testCompilerBasic(
             @InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
             @InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
                     @MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
                     TestCompilerMojo testCompileMojo) {

         Log log = mock(Log.class);
         compileMojo.logger = log;
         compileMojo.execute();
         verify(log).warn(startsWith("No explicit value set for --release or --target."));
         assertOutputFileExists(compileMojo, "foo", "TestCompile0.class");
         assertTrue(
                 session.getArtifactPath(compileMojo.projectArtifact).isPresent(),
                 "MCOMPILER-94: artifact file should only be null if there is nothing to compile");

         testCompileMojo.execute();
         assertOutputFileExists(testCompileMojo, "foo", "TestCompile0Test.class");
         assertOutputFileDoesNotExist(compileMojo, "foo", "TestCompile0Test.class");
     }

     /**
      * A project with a source and target version specified.
      * No warning should be logged.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-basic-sourcetarget")
     public void testCompilerBasicSourceTarget(
             @InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo) {

         Log log = mock(Log.class);
         compileMojo.logger = log;
         compileMojo.execute();
         verify(log, never()).warn(startsWith("No explicit value set for --release or --target."));
     }

     /**
      * Tests the ability of the plugin to respond to empty source.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-empty-source-test")
     public void testCompilerEmptySource(
             @InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
             @InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
                     @MojoParameter(name = "compileSourceRoots", value = "${basedir}/src/test/java")
                     TestCompilerMojo testCompileMojo) {

         compileMojo.execute();
         assertFalse(Files.exists(compileMojo.getOutputDirectory()));
         assertNull(
                 session.getArtifactPath(compileMojo.projectArtifact).orElse(null),
                 "MCOMPILER-94: artifact file should be null if there is nothing to compile");

         testCompileMojo.execute();
         assertFalse(Files.exists(testCompileMojo.getOutputDirectory()));
     }

     /**
      * Tests the ability of the plugin to respond to includes and excludes correctly.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-includes-excludes-test")
     public void testCompilerIncludesExcludes(
             @InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
             @InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
                     @MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
                     TestCompilerMojo testCompileMojo) {

         compileMojo.execute();
         assertOutputFileDoesNotExist(compileMojo, "foo", "TestCompile2.class");
         assertOutputFileDoesNotExist(compileMojo, "foo", "TestCompile3.class");
         assertOutputFileExists(compileMojo, "foo", "TestCompile4.class");

         testCompileMojo.execute();
         assertOutputFileDoesNotExist(testCompileMojo, "foo", "TestCompile2TestCase.class");
         assertOutputFileDoesNotExist(testCompileMojo, "foo", "TestCompile3TestCase.class");
         assertOutputFileExists(testCompileMojo, "foo", "TestCompile4TestCase.class");
         assertOutputFileDoesNotExist(compileMojo, "foo", "TestCompile4TestCase.class");
     }

     /**
      * Tests the ability of the plugin to fork and successfully compile.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-fork-test")
     public void testCompilerFork(
             @InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
             @InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
                     @MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
                     TestCompilerMojo testCompileMojo) {

         // JAVA_HOME doesn't have to be on the PATH.
         String javaHome = System.getenv("JAVA_HOME");
         if (javaHome != null) {
             String command = new File(javaHome, "bin/javac").getPath();
             compileMojo.executable = command;
             testCompileMojo.executable = command;
         }
         compileMojo.execute();
         assertOutputFileExists(compileMojo, "foo", "TestCompile1.class");

         testCompileMojo.execute();
         assertOutputFileExists(testCompileMojo, "foo", "TestCompile1TestCase.class");
         assertOutputFileDoesNotExist(compileMojo, "foo", "TestCompile1TestCase.class");
     }

     /**
      * Tests the use of a custom compiler.
      * The dummy compiler used in this test generates only one file, despite having more than one source.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-one-output-file-test")
     public void testOneOutputFileForAllInput(
             @InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
             @InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
                     @MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
                     TestCompilerMojo testCompileMojo) {

         assertEquals(CompilerStub.COMPILER_ID, compileMojo.compilerId);
         compileMojo.execute();
         assertCompilerStubOutputFileExists(compileMojo);

         assertEquals(CompilerStub.COMPILER_ID, testCompileMojo.compilerId);
         testCompileMojo.execute();
         assertCompilerStubOutputFileExists(testCompileMojo);
     }

     /**
      * Verifies that the options in the {@code <compilerArgs>} elements are given to the compiler.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-args-test")
     public void testCompilerArgs(@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo) {

         assertEquals(CompilerStub.COMPILER_ID, compileMojo.compilerId);
         compileMojo.execute();

         assertCompilerStubOutputFileExists(compileMojo);
         assertArrayEquals(
                 new String[] {"key1=value1", "-Xlint", "-my&special:param-with+chars/not>allowed_in_XML_element_names"},
                 compileMojo.compilerArgs.toArray(String[]::new));

         List<String> options = CompilerStub.getOptions();
         assertArrayEquals(
                 new String[] {
                     "--module-version", // Added by the plugin
                     "1.0-SNAPSHOT",
                     "key1=value1", // Specified in <compilerArgs>
                     "-Xlint",
                     "-my&special:param-with+chars/not>allowed_in_XML_element_names",
                     "param", // Specified in <compilerArgument>
                     "value"
                 },
                 options.toArray(String[]::new));
     }

     /**
      * Tests the {@code <implicit>} option when set to "none".
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-implicit-test")
     public void testImplicitFlagNone(
             @InjectMojo(goal = "compile", pom = "plugin-config-none.xml") CompilerMojo compileMojo) {

         assertEquals("none", compileMojo.implicit);
         compileMojo.execute();
     }

     /**
      * Tests the {@code <implicit>} option when not set.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-implicit-test")
     public void testImplicitFlagNotSet(
             @InjectMojo(goal = "compile", pom = "plugin-config-not-set.xml") CompilerMojo compileMojo) {

         assertNull(compileMojo.implicit);
         compileMojo.execute();
     }

     /**
      * Tests the compilation of a project having a {@code module-info.java} file, together with its tests.
      * The compilation of tests requires a {@code --patch-module} option, otherwise compilation will fail.
      *
      * <h4>Requirements on Windows</h4>
      * Executing the tests on Windows requires the developer mode.
      * This is enabled with {@literal Settings > Update & Security > For Developers}.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-modular-project")
     public void testModularProject(
             @InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
             @InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
                     @MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
                     TestCompilerMojo testCompileMojo) {

         compileMojo.execute();
         assertOutputFileExists(compileMojo, SourceDirectory.MODULE_INFO + SourceDirectory.CLASS_FILE_SUFFIX);
         assertOutputFileExists(compileMojo, "foo", "TestModular.class");

         testCompileMojo.execute();
         assertOutputFileExists(testCompileMojo, "foo", "TestModularTestCase.class");
         assertOutputFileDoesNotExist(compileMojo, "foo", "TestModularTestCase.class");
     }

     /**
      * Tests a compilation task which is expected to fail.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-fail-test")
     public void testCompileFailure(@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo) {
         assertThrows(CompilationFailureException.class, compileMojo::execute, "Should throw an exception");
         assertOutputFileExists(compileMojo, "..", "javac.args"); // Command-line that user can execute.
     }

     /**
      * Tests a compilation task which is expected to fail, but where test failure are ignored.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-failonerror-test")
     public void testCompileFailOnError(
             @InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo) {

         try {
             compileMojo.execute();
         } catch (CompilationFailureException e) {
             fail("The compilation error should have been consumed because failOnError = false");
         }
         assertOutputFileExists(compileMojo, "..", "javac.args"); // Command-line that user can execute.
     }

     /**
      * Tests that setting {@code skipMain} to true skips compilation of the main Java source files,
      * but that test Java source files are still compiled.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-skip-main")
     public void testCompileSkipMain(
             @InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
             @InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
                     @MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
                     TestCompilerMojo testCompileMojo) {

         compileMojo.skipMain = true;
         compileMojo.execute();
         assertOutputFileDoesNotExist(compileMojo, "foo", "TestSkipMainCompile0.class");

         testCompileMojo.execute();
         assertOutputFileExists(testCompileMojo, "foo", "TestSkipMainCompile0Test.class");
         assertOutputFileDoesNotExist(compileMojo, "foo", "TestSkipMainCompile0Test.class");
     }

     /**
      * Tests that setting {@code skip} to true skips compilation of the test Java source files,
      * but that main Java source files are still compiled.
      */
     @Test
     @Basedir("${basedir}/target/test-classes/unit/compiler-skip-test")
     public void testCompileSkipTest(
             @InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
             @InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
                     @MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
                     TestCompilerMojo testCompileMojo) {

         compileMojo.execute();
         assertOutputFileExists(compileMojo, "foo/TestSkipTestCompile0.class");

         testCompileMojo.skip = true;
         testCompileMojo.execute();
         assertOutputFileDoesNotExist(testCompileMojo, "foo", "TestSkipTestCompile0Test.class");
         assertOutputFileDoesNotExist(compileMojo, "foo", "TestSkipTestCompile0Test.class");
     }

     @Provides
     @Singleton
     @SuppressWarnings("unused")
     private static InternalSession createSession() {
         InternalSession session = SessionMock.getMockSession(MojoExtension.getBasedir() + LOCAL_REPO);

         ToolchainManager toolchainManager = mock(ToolchainManager.class);
         doReturn(toolchainManager).when(session).getService(ToolchainManager.class);

         doAnswer(iom -> Instant.now().minus(200, ChronoUnit.MILLIS))
                 .when(session)
                 .getStartTime();

         var junit = new ProducedArtifactStub("junit", "junit", null, "3.8.1", "jar");

         MessageBuilderFactory messageBuilderFactory = new DefaultMessageBuilderFactory();
         doReturn(messageBuilderFactory).when(session).getService(MessageBuilderFactory.class);

         Map<String, String> props = new HashMap<>();
         props.put("basedir", MojoExtension.getBasedir());
         doReturn(props).when(session).getUserProperties();

         List<Path> artifacts = new ArrayList<>();
         try {
             Path artifactFile;
             String localRepository = System.getProperty("localRepository");
             if (localRepository != null) {
                 artifactFile = Path.of(
                         localRepository,
                         "org",
                         "junit",
                         "jupiter",
                         "junit-jupiter-api",
                         "5.10.2",
                         "junit-jupiter-api-5.10.2.jar");
             } else {
                 // for IDE
                 String junitURI = Test.class.getResource("Test.class").toURI().toString();
                 junitURI = junitURI.substring("jar:".length(), junitURI.indexOf('!'));
                 artifactFile = new File(URI.create(junitURI)).toPath();
             }
             ArtifactManager artifactManager = session.getService(ArtifactManager.class);
             artifactManager.setPath(junit, artifactFile);
             artifacts.add(artifactFile);
         } catch (Exception e) {
             throw new RuntimeException("Unable to setup junit jar path", e);
         }

         doAnswer(iom -> List.of()).when(session).resolveDependencies(any(), eq(PathScope.MAIN_COMPILE));
         doAnswer(iom -> artifacts).when(session).resolveDependencies(any(), eq(PathScope.TEST_COMPILE));

         return session;
     }

     @Provides
     @Singleton
     @SuppressWarnings("unused")
     private static Project createProject() {
         ProjectStub stub = new ProjectStub();
         var artifact = new ProducedArtifactStub("myGroupId", "myArtifactId", null, "1.0-SNAPSHOT", "jar");
         stub.setMainArtifact(artifact);
         stub.setModel(Model.newBuilder()
                 .groupId(artifact.getGroupId())
                 .artifactId(artifact.getArtifactId())
                 .version(artifact.getVersion().toString())
                 .build(Build.newBuilder()
                         .directory(MojoExtension.getBasedir() + "/target")
                         .outputDirectory(MojoExtension.getBasedir() + "/target/classes")
                         .sourceDirectory(MojoExtension.getBasedir() + "/src/main/java")
                         .testOutputDirectory(MojoExtension.getBasedir() + "/target/test-classes")
                         .build())
                 .build());
         stub.setBasedir(Path.of(MojoExtension.getBasedir()));
         return stub;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.maven.plugin.compiler;

	import java.io.File;
	import java.io.IOException;
	import java.io.UncheckedIOException;
	import java.net.URI;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.time.Instant;
	import java.time.temporal.ChronoUnit;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.apache.maven.api.PathScope;
	import org.apache.maven.api.Project;
	import org.apache.maven.api.Session;
	import org.apache.maven.api.di.Inject;
	import org.apache.maven.api.di.Provides;
	import org.apache.maven.api.di.Singleton;
	import org.apache.maven.api.model.Build;
	import org.apache.maven.api.model.Model;
	import org.apache.maven.api.plugin.Log;
	import org.apache.maven.api.plugin.testing.Basedir;
	import org.apache.maven.api.plugin.testing.InjectMojo;
	import org.apache.maven.api.plugin.testing.MojoExtension;
	import org.apache.maven.api.plugin.testing.MojoParameter;
	import org.apache.maven.api.plugin.testing.MojoTest;
	import org.apache.maven.api.plugin.testing.stubs.ProducedArtifactStub;
	import org.apache.maven.api.plugin.testing.stubs.ProjectStub;
	import org.apache.maven.api.plugin.testing.stubs.SessionMock;
	import org.apache.maven.api.services.ArtifactManager;
	import org.apache.maven.api.services.MessageBuilderFactory;
	import org.apache.maven.api.services.ToolchainManager;
	import org.apache.maven.impl.DefaultMessageBuilderFactory;
	import org.apache.maven.impl.InternalSession;
	import org.apache.maven.plugin.compiler.stubs.CompilerStub;
	import org.junit.jupiter.api.Test;

	import static org.junit.jupiter.api.Assertions.assertArrayEquals;
	import static org.junit.jupiter.api.Assertions.assertEquals;
	import static org.junit.jupiter.api.Assertions.assertFalse;
	import static org.junit.jupiter.api.Assertions.assertNull;
	import static org.junit.jupiter.api.Assertions.assertThrows;
	import static org.junit.jupiter.api.Assertions.assertTrue;
	import static org.junit.jupiter.api.Assertions.fail;
	import static org.mockito.ArgumentMatchers.any;
	import static org.mockito.ArgumentMatchers.eq;
	import static org.mockito.ArgumentMatchers.startsWith;
	import static org.mockito.Mockito.doAnswer;
	import static org.mockito.Mockito.doReturn;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.never;
	import static org.mockito.Mockito.verify;

	@MojoTest
	public class CompilerMojoTestCase {

	private static final String LOCAL_REPO = "/target/local-repo";

	@Inject
	private Session session;

	/**
	* Verifies that the {@value CompilerStub#OUTPUT_FILE} file exists, then deletes it.
	* The deletion is necessary for preventing an {@link IndexOutOfBoundsException} in
	* {@code maven-dependency-plugin} version 3.8.1, because the output file is empty.
	*
	* @param mojo the tested mojo
	*/
	private static void assertCompilerStubOutputFileExists(AbstractCompilerMojo mojo) {
	try {
	Files.delete(assertOutputFileExists(mojo, CompilerStub.OUTPUT_FILE));
	} catch (IOException e) {
	throw new UncheckedIOException(e);
	}
	}

	/**
	* Verifies that the given output file exists.
	*
	* @param mojo the tested mojo
	* @param first the first path element
	* @param more the other path elements, if any
	* @return the file
	*/
	private static Path assertOutputFileExists(AbstractCompilerMojo mojo, String first, String... more) {
	Path file = mojo.getOutputDirectory().resolve(Path.of(first, more));
	assertTrue(Files.isRegularFile(file), () -> "File not found: " + file);
	return file;
	}

	/**
	* Verifies that the given output file does not exist.
	*
	* @param mojo the tested mojo
	* @param first the first path element
	* @param more the other path elements, if any
	*/
	private static void assertOutputFileDoesNotExist(AbstractCompilerMojo mojo, String first, String... more) {
	Path file = mojo.getOutputDirectory().resolve(Path.of(first, more));
	assertFalse(Files.exists(file), () -> "File should not exist: " + file);
	}

	/**
	* Tests the ability of the plugin to compile a basic file.
	* This test does not declare a Java release version. Therefore, a warning should be emitted.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-basic-test")
	public void testCompilerBasic(
	@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
	@InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
	@MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
	TestCompilerMojo testCompileMojo) {

	Log log = mock(Log.class);
	compileMojo.logger = log;
	compileMojo.execute();
	verify(log).warn(startsWith("No explicit value set for --release or --target."));
	assertOutputFileExists(compileMojo, "foo", "TestCompile0.class");
	assertTrue(
	session.getArtifactPath(compileMojo.projectArtifact).isPresent(),
	"MCOMPILER-94: artifact file should only be null if there is nothing to compile");

	testCompileMojo.execute();
	assertOutputFileExists(testCompileMojo, "foo", "TestCompile0Test.class");
	assertOutputFileDoesNotExist(compileMojo, "foo", "TestCompile0Test.class");
	}

	/**
	* A project with a source and target version specified.
	* No warning should be logged.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-basic-sourcetarget")
	public void testCompilerBasicSourceTarget(
	@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo) {

	Log log = mock(Log.class);
	compileMojo.logger = log;
	compileMojo.execute();
	verify(log, never()).warn(startsWith("No explicit value set for --release or --target."));
	}

	/**
	* Tests the ability of the plugin to respond to empty source.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-empty-source-test")
	public void testCompilerEmptySource(
	@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
	@InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
	@MojoParameter(name = "compileSourceRoots", value = "${basedir}/src/test/java")
	TestCompilerMojo testCompileMojo) {

	compileMojo.execute();
	assertFalse(Files.exists(compileMojo.getOutputDirectory()));
	assertNull(
	session.getArtifactPath(compileMojo.projectArtifact).orElse(null),
	"MCOMPILER-94: artifact file should be null if there is nothing to compile");

	testCompileMojo.execute();
	assertFalse(Files.exists(testCompileMojo.getOutputDirectory()));
	}

	/**
	* Tests the ability of the plugin to respond to includes and excludes correctly.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-includes-excludes-test")
	public void testCompilerIncludesExcludes(
	@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
	@InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
	@MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
	TestCompilerMojo testCompileMojo) {

	compileMojo.execute();
	assertOutputFileDoesNotExist(compileMojo, "foo", "TestCompile2.class");
	assertOutputFileDoesNotExist(compileMojo, "foo", "TestCompile3.class");
	assertOutputFileExists(compileMojo, "foo", "TestCompile4.class");

	testCompileMojo.execute();
	assertOutputFileDoesNotExist(testCompileMojo, "foo", "TestCompile2TestCase.class");
	assertOutputFileDoesNotExist(testCompileMojo, "foo", "TestCompile3TestCase.class");
	assertOutputFileExists(testCompileMojo, "foo", "TestCompile4TestCase.class");
	assertOutputFileDoesNotExist(compileMojo, "foo", "TestCompile4TestCase.class");
	}

	/**
	* Tests the ability of the plugin to fork and successfully compile.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-fork-test")
	public void testCompilerFork(
	@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
	@InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
	@MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
	TestCompilerMojo testCompileMojo) {

	// JAVA_HOME doesn't have to be on the PATH.
	String javaHome = System.getenv("JAVA_HOME");
	if (javaHome != null) {
	String command = new File(javaHome, "bin/javac").getPath();
	compileMojo.executable = command;
	testCompileMojo.executable = command;
	}
	compileMojo.execute();
	assertOutputFileExists(compileMojo, "foo", "TestCompile1.class");

	testCompileMojo.execute();
	assertOutputFileExists(testCompileMojo, "foo", "TestCompile1TestCase.class");
	assertOutputFileDoesNotExist(compileMojo, "foo", "TestCompile1TestCase.class");
	}

	/**
	* Tests the use of a custom compiler.
	* The dummy compiler used in this test generates only one file, despite having more than one source.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-one-output-file-test")
	public void testOneOutputFileForAllInput(
	@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
	@InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
	@MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
	TestCompilerMojo testCompileMojo) {

	assertEquals(CompilerStub.COMPILER_ID, compileMojo.compilerId);
	compileMojo.execute();
	assertCompilerStubOutputFileExists(compileMojo);

	assertEquals(CompilerStub.COMPILER_ID, testCompileMojo.compilerId);
	testCompileMojo.execute();
	assertCompilerStubOutputFileExists(testCompileMojo);
	}

	/**
	* Verifies that the options in the {@code <compilerArgs>} elements are given to the compiler.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-args-test")
	public void testCompilerArgs(@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo) {

	assertEquals(CompilerStub.COMPILER_ID, compileMojo.compilerId);
	compileMojo.execute();

	assertCompilerStubOutputFileExists(compileMojo);
	assertArrayEquals(
	new String[] {"key1=value1", "-Xlint", "-my&special:param-with+chars/not>allowed_in_XML_element_names"},
	compileMojo.compilerArgs.toArray(String[]::new));

	List<String> options = CompilerStub.getOptions();
	assertArrayEquals(
	new String[] {
	"--module-version", // Added by the plugin
	"1.0-SNAPSHOT",
	"key1=value1", // Specified in <compilerArgs>
	"-Xlint",
	"-my&special:param-with+chars/not>allowed_in_XML_element_names",
	"param", // Specified in <compilerArgument>
	"value"
	},
	options.toArray(String[]::new));
	}

	/**
	* Tests the {@code <implicit>} option when set to "none".
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-implicit-test")
	public void testImplicitFlagNone(
	@InjectMojo(goal = "compile", pom = "plugin-config-none.xml") CompilerMojo compileMojo) {

	assertEquals("none", compileMojo.implicit);
	compileMojo.execute();
	}

	/**
	* Tests the {@code <implicit>} option when not set.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-implicit-test")
	public void testImplicitFlagNotSet(
	@InjectMojo(goal = "compile", pom = "plugin-config-not-set.xml") CompilerMojo compileMojo) {

	assertNull(compileMojo.implicit);
	compileMojo.execute();
	}

	/**
	* Tests the compilation of a project having a {@code module-info.java} file, together with its tests.
	* The compilation of tests requires a {@code --patch-module} option, otherwise compilation will fail.
	*
	* <h4>Requirements on Windows</h4>
	* Executing the tests on Windows requires the developer mode.
	* This is enabled with {@literal Settings > Update & Security > For Developers}.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-modular-project")
	public void testModularProject(
	@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
	@InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
	@MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
	TestCompilerMojo testCompileMojo) {

	compileMojo.execute();
	assertOutputFileExists(compileMojo, SourceDirectory.MODULE_INFO + SourceDirectory.CLASS_FILE_SUFFIX);
	assertOutputFileExists(compileMojo, "foo", "TestModular.class");

	testCompileMojo.execute();
	assertOutputFileExists(testCompileMojo, "foo", "TestModularTestCase.class");
	assertOutputFileDoesNotExist(compileMojo, "foo", "TestModularTestCase.class");
	}

	/**
	* Tests a compilation task which is expected to fail.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-fail-test")
	public void testCompileFailure(@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo) {
	assertThrows(CompilationFailureException.class, compileMojo::execute, "Should throw an exception");
	assertOutputFileExists(compileMojo, "..", "javac.args"); // Command-line that user can execute.
	}

	/**
	* Tests a compilation task which is expected to fail, but where test failure are ignored.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-failonerror-test")
	public void testCompileFailOnError(
	@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo) {

	try {
	compileMojo.execute();
	} catch (CompilationFailureException e) {
	fail("The compilation error should have been consumed because failOnError = false");
	}
	assertOutputFileExists(compileMojo, "..", "javac.args"); // Command-line that user can execute.
	}

	/**
	* Tests that setting {@code skipMain} to true skips compilation of the main Java source files,
	* but that test Java source files are still compiled.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-skip-main")
	public void testCompileSkipMain(
	@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
	@InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
	@MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
	TestCompilerMojo testCompileMojo) {

	compileMojo.skipMain = true;
	compileMojo.execute();
	assertOutputFileDoesNotExist(compileMojo, "foo", "TestSkipMainCompile0.class");

	testCompileMojo.execute();
	assertOutputFileExists(testCompileMojo, "foo", "TestSkipMainCompile0Test.class");
	assertOutputFileDoesNotExist(compileMojo, "foo", "TestSkipMainCompile0Test.class");
	}

	/**
	* Tests that setting {@code skip} to true skips compilation of the test Java source files,
	* but that main Java source files are still compiled.
	*/
	@Test
	@Basedir("${basedir}/target/test-classes/unit/compiler-skip-test")
	public void testCompileSkipTest(
	@InjectMojo(goal = "compile", pom = "plugin-config.xml") CompilerMojo compileMojo,
	@InjectMojo(goal = "testCompile", pom = "plugin-config.xml")
	@MojoParameter(name = "compileSourceRoots", value = "${project.basedir}/src/test/java")
	TestCompilerMojo testCompileMojo) {

	compileMojo.execute();
	assertOutputFileExists(compileMojo, "foo/TestSkipTestCompile0.class");

	testCompileMojo.skip = true;
	testCompileMojo.execute();
	assertOutputFileDoesNotExist(testCompileMojo, "foo", "TestSkipTestCompile0Test.class");
	assertOutputFileDoesNotExist(compileMojo, "foo", "TestSkipTestCompile0Test.class");
	}

	@Provides
	@Singleton
	@SuppressWarnings("unused")
	private static InternalSession createSession() {
	InternalSession session = SessionMock.getMockSession(MojoExtension.getBasedir() + LOCAL_REPO);

	ToolchainManager toolchainManager = mock(ToolchainManager.class);
	doReturn(toolchainManager).when(session).getService(ToolchainManager.class);

	doAnswer(iom -> Instant.now().minus(200, ChronoUnit.MILLIS))
	.when(session)
	.getStartTime();

	var junit = new ProducedArtifactStub("junit", "junit", null, "3.8.1", "jar");

	MessageBuilderFactory messageBuilderFactory = new DefaultMessageBuilderFactory();
	doReturn(messageBuilderFactory).when(session).getService(MessageBuilderFactory.class);

	Map<String, String> props = new HashMap<>();
	props.put("basedir", MojoExtension.getBasedir());
	doReturn(props).when(session).getUserProperties();

	List<Path> artifacts = new ArrayList<>();
	try {
	Path artifactFile;
	String localRepository = System.getProperty("localRepository");
	if (localRepository != null) {
	artifactFile = Path.of(
	localRepository,
	"org",
	"junit",
	"jupiter",
	"junit-jupiter-api",
	"5.10.2",
	"junit-jupiter-api-5.10.2.jar");
	} else {
	// for IDE
	String junitURI = Test.class.getResource("Test.class").toURI().toString();
	junitURI = junitURI.substring("jar:".length(), junitURI.indexOf('!'));
	artifactFile = new File(URI.create(junitURI)).toPath();
	}
	ArtifactManager artifactManager = session.getService(ArtifactManager.class);
	artifactManager.setPath(junit, artifactFile);
	artifacts.add(artifactFile);
	} catch (Exception e) {
	throw new RuntimeException("Unable to setup junit jar path", e);
	}

	doAnswer(iom -> List.of()).when(session).resolveDependencies(any(), eq(PathScope.MAIN_COMPILE));
	doAnswer(iom -> artifacts).when(session).resolveDependencies(any(), eq(PathScope.TEST_COMPILE));

	return session;
	}

	@Provides
	@Singleton
	@SuppressWarnings("unused")
	private static Project createProject() {
	ProjectStub stub = new ProjectStub();
	var artifact = new ProducedArtifactStub("myGroupId", "myArtifactId", null, "1.0-SNAPSHOT", "jar");
	stub.setMainArtifact(artifact);
	stub.setModel(Model.newBuilder()
	.groupId(artifact.getGroupId())
	.artifactId(artifact.getArtifactId())
	.version(artifact.getVersion().toString())
	.build(Build.newBuilder()
	.directory(MojoExtension.getBasedir() + "/target")
	.outputDirectory(MojoExtension.getBasedir() + "/target/classes")
	.sourceDirectory(MojoExtension.getBasedir() + "/src/main/java")
	.testOutputDirectory(MojoExtension.getBasedir() + "/target/test-classes")
	.build())
	.build());
	stub.setBasedir(Path.of(MojoExtension.getBasedir()));
	return stub;
	}
	}