class JavaCompileProblemsIntegrationTest extends AbstractIntegrationSpec implements JavaToolchainFixture {

    /**
     * A map of all possible file locations, and the number of occurrences we expect to find in the problems.
     */
    private final Map<String, Integer> possibleFileLocations = [:]

    /**
     * A map of all visited file locations, and the number of occurrences we have found in the problems.
     * <p>

│   └── 4.9
├── init.d // <5>
│   └── my-setup.gradle
├── jdks // <6>
│   ├── ⋮
│   └── jdk-14.0.2+12
├── wrapper
│   └── dists // <7>
│       ├── ⋮
│       ├── gradle-4.8-bin
│       ├── gradle-4.9-all
│       └── gradle-4.9-bin
└── gradle.properties // <8>
----
<1> Global cache directory (for everything that is not project-specific).
<2> Version-specific caches (e.g., to support incremental builds).

We expect that developers will not be allowed to populate the remote build cache, and all continuous integration builds populate the build cache after running the `clean` task.

For your build to play well with task output caching it must work well with the <<incremental_build#incremental_build,incremental build>> feature.
For example, when running your build twice in a row all tasks with outputs should be `UP-TO-DATE`.

    protected TestFile getDefaultTmpDir() {
        // File.createTempFile sets the location of the temp directory to a static variable on the first call.  This prevents future
        // changes to java.io.tmpdir from having any effect in the same process.  We set this to use a common tmp directory for all
        // tests running in the same process so that we don't have a situation where one process initializes with a tmp directory

        override fun runCompileBuildOperation(scriptPath: String, stage: String, action: () -> String): String =

            buildOperationRunner.call(object : CallableBuildOperation<String> {

                override fun call(context: BuildOperationContext): String =
                    action().also {
                        context.setResult(object : Result {})
                    }

                public void execute() {}
            }
        """

        when:
        succeeds("doWork")

        then:
        nativeDir.exists() == initialized

        where:
        // Works for all cases except -D$NATIVE_SERVICES_OPTION=false
        description       | systemProperties                    | initialized
        "initialized"     | ["-D$NATIVE_SERVICES_OPTION=true"]  | true

            contextualLabel == 'Problem: In version catalog testLibs, you can only call the \'from\' method a single time.'
            details == 'The method was called more than once'
            solutions == [ 'Remove further usages of the method call' ]
        }
    }

    @Issue("https://github.com/gradle/gradle/issues/20060")
    def "no name conflicting of accessors"() {

        def pluginDir = new File(testDirectory, "typed-attributes-plugin-$version")
        pluginDir.deleteDir()
        pluginDir.mkdirs()
        def builder = new FileTreeBuilder(pluginDir)
        builder.call {
            'settings.gradle'('rootProject.name="com.acme.typed-attributes.gradle.plugin"')
            'build.gradle'("""
                apply plugin: 'groovy'
                apply plugin: 'maven-publish'

                    file('file3.txt').text = 'original'
                }
            }
        }

        and: "a settings script which edits the zip archive and then verifies that all files contain the same content"
        settingsFile << """
            ${server.callFromBuild('wait')}

            void update() {
                FileTree tree = zipTree(new File(settings.rootDir, 'test.zip'))

    }

    public JvmOptions(FileCollectionFactory fileCollectionFactory) {
        this(fileCollectionFactory, new DefaultJavaDebugOptions());
    }

    /**
     * @return all jvm args including system properties
     */
    public List<String> getAllJvmArgs() {
        List<String> args = new ArrayList<>();
        formatSystemProperties(getMutableSystemProperties(), args);