import org.gradle.api.specs.Spec;
import org.gradle.plugins.ide.internal.resolver.model.IdeExtendedRepoFileDependency;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * TODO only here because Kotlin DSL uses this. Please remove once that is fixed.
 */
public class DefaultIdeDependencyResolver {

    private static final Spec<ComponentIdentifier> IS_A_MODULE_ID = new Spec<ComponentIdentifier>() {

import javax.annotation.Nullable;
import java.util.List;

public interface ProblemStream {
    /**
     * Returns diagnostics based on the state of the calling thread.
     *
     * <p>This method is here because stack trace sanitizing is currently performed by the caller.
     * However, each caller does this in a different way and they all do this in a different way
     * to the services used by this type.
     * </p>
     *

                dirName = layout.buildDirectory.file('dirName.txt')
            }

            tasks.register('answer', Consumer) {
                // TODO:configuration should this `dependsOn` be necessary here?
                dependsOn 'producer'

                Provider<String> computedDirName = computeDirName.flatMap { it.dirName }.map { it.asFile.text }
                def file = layout.buildDirectory.$provider

        return false;
    }

    /**
     * Returns the project which the action belongs to. This is used to determine the services to expose to {@link #run(NodeExecutionContext)} via the context.
     * Returning non-null here does not imply any kind of exclusive access to the project, unless {@link #usesMutableProjectState()} returns true.
     */
    @Nullable
    default Project getOwningProject() {
        return null;
    }

Here, we add an additional source set _integrationTest_ with a `module-info.java`.

```
src
└── integrationTest
    └── java
        └── module-info.java
```

public class JavaHomeBasedJavaCompilerFactory implements Factory<ContextAwareJavaCompiler>, Serializable {
    private final List<File> compilerPluginsClasspath;
    // We use a static cache here because we want to reuse classloaders in compiler workers as
    // it has a huge impact on performance. Previously there was a single, JdkTools.current()

 * which implements the module and an example class name, which if loaded, signals the existence of the module.
 *
 * <p>The complexity here is necessary to determine if test framework dependencies are already present on the
 * application classpath, and thus do not need to be loaded from the Gradle distribution. The behavior of loading

Root project 'test'
------------------------------------------------------------
""" + normalised + """
Note: currently not all plugins register their components, so some components may not be visible here."""
        return formatter.transform(raw).readLines().findAll { !it.isEmpty() }.join('\n')
    }

    AvailableToolChains.InstalledToolChain getToolChain() {
        return AvailableToolChains.defaultToolChain
    }

public interface DomainObjectCollectionFactory {
    /**
     * Creates a {@link NamedDomainObjectContainer} for managing named objects of the specified type.
     *
     * Note that this method is here because {@link org.gradle.api.Project#container(Class)} cannot decorate the elements because of backwards compatibility.
     */
    <T> NamedDomainObjectContainer<T> newNamedDomainObjectContainerUndecorated(Class<T> elementType);

        settingsFile << """
            include 'a', 'b'
        """

        expect:
        fails("a:foo", "b:foo", "--parallel")

        // We just need to assert that the build fails with the right error message here, it doesn't matter which task is the first to fail,
        // allowing either failure to pass the test should reduce flakiness on CI.

        def docLinkMessage = getDocLinkMessage()