// for us to not force the user's OS to allocate more page file space, so we'll use the commit limit here.
                windowsMemoryInfo.getCommitLimit(), availableCommitMemory(windowsMemoryInfo)
            );
        } else {
            return new OsMemoryStatusSnapshot(

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;
    }

 * <p>
 * This attribute is usually found on variants that have the {@link Category} attribute valued at {@link Category#VERIFICATION verification}.
 * <p>
 * The constant values present here are not exhaustive.  Any value is allowed, so long as that value
 * is only used to categorize a single test suite within each project.
 *
 * @since 7.4
 */
@Incubating
public interface TestSuiteType extends Named {

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
    }