class WorkerPruningSoakTest extends AbstractIntegrationSpec {
    def fixture = new WorkerExecutorFixture(temporaryFolder)

    def setup() {
        fixture.prepareTaskTypeUsingWorker()

        // Purposefully not using an isolated daemon, this test should work regardless of any other builds before or after
        // If it doesn't, that indicates an issue with our worker memory management.

 * 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.gradle.internal.cc.impl.isolated;

import org.gradle.api.Action;
import org.gradle.internal.cc.impl.fixtures.SomeToolingModel;
import org.gradle.internal.cc.impl.fixtures.SomeToolingModelParameter;
import org.gradle.tooling.BuildAction;

import java.lang.reflect.Constructor

class NativeServicesInitializationTest extends Specification {

    def "cannot get an instance of NativeServices without initializing first" () {
        // Construct an isolated classloader so we can load a pristine NativeServices class
        // that's guaranteed not to have been initialized before
        URL[] jars = [
            jar(NativeServices),
            jar(ServiceRegistration),

import org.gradle.internal.Cast;
import org.gradle.internal.Factory;
import org.gradle.internal.classloader.ClassLoaderUtils;
import org.gradle.internal.instantiation.InstantiatorFactory;
import org.gradle.internal.isolated.IsolationScheme;
import org.gradle.internal.operations.BuildOperationRef;
import org.gradle.internal.operations.BuildOperationRunner;
import org.gradle.internal.service.ServiceRegistry;
import org.gradle.workers.WorkAction;

import org.gradle.api.file.ArchiveOperations;
import org.gradle.api.file.FileSystemOperations;
import org.gradle.process.ExecOperations;

/**
 * A dataflow action.
 *
 * <p>
 * A parameterized and isolated piece of work that becomes eligible for execution within a
 * {@link FlowScope dataflow scope} as soon as all of its input {@link FlowParameters parameters}
 * become available.
 * </p>
 * <p>

        outputDoesNotContain("Configuring ':included")
    }

    @Requires(
        value = IntegTestPreconditions.NotIsolatedProjects,
        reason = "accessing `tasks` from subprojects is in violation of Isolated Projects"
    )
    def "lifecycle applied build logic runs before subprojects configuration logic"() {
        given:
        settingsFile """
            include 'sub'

            $beforeProject {

        File toolsJar = Jvm.current().getToolsJar();
        if (toolsJar != null) {
            antClasspath.add(toolsJar);
        }

        antLoader = classLoaderFactory.createIsolatedClassLoader("isolated-ant-loader", DefaultClassPath.of(antClasspath));
        FilteringClassLoader.Spec loggingLoaderSpec = new FilteringClassLoader.Spec();
        loggingLoaderSpec.allowPackage("org.slf4j");

# concurrently accessing the cache while this test is running, it can
# lead to cache lookup failures, which manifest as test failures here.
# To avoid such flakes, use a separate isolated GOCACHE for this test.
env GOCACHE=$WORK/cache

# Initial run with simple coverage.
go test -cover ./pkg1 ./pkg2 ./pkg3 ./pkg4
[!GOEXPERIMENT:coverageredesign] stdout 'pkg1	\[no test files\]'

)

// ContainerRuntimeOptions defines options for the container runtime.
type ContainerRuntimeOptions struct {
	// General Options.

	// RuntimeCgroups that container runtime is expected to be isolated in.
	RuntimeCgroups string
	// PodSandboxImage is the image whose network/ipc namespaces
	// containers in each pod will use.
	PodSandboxImage string
	// Image credential provider plugin options

import org.gradle.internal.classpath.ClassPath
import java.io.File
import java.lang.reflect.InvocationTargetException
import java.net.URLClassLoader


/**
 * Reflectively calls generation functions in an isolated classloader.
 *
 * This is required so that our build uses the production code to generate extensions.
 *
 * The parameters of the called functions need to be from the JDK only in order to isolate
 * the Kotlin version.