import org.gradle.internal.work.WorkerThreadRegistry
import org.gradle.process.internal.worker.child.WorkerDirectoryProvider
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.gradle.util.UsesNativeServices
import org.gradle.util.internal.RedirectStdOutAndErr
import org.gradle.workers.WorkAction
import org.gradle.workers.WorkParameters
import org.gradle.workers.WorkerSpec
import org.junit.Rule
import spock.lang.Specification

 * limitations under the License.
 */

package org.gradle.workers.internal


import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.internal.jvm.Jvm
import org.gradle.workers.fixtures.WorkerExecutorFixture

class WorkerExecutorProblemsApiIntegrationTest extends AbstractIntegrationSpec {

    // Worker-written file containing the build operation id

            "plugin2-runtime"
        ]

        and:
        1 * moduleRegistry.getModule("gradle-worker-main") >> module("gradle-worker-main")
        1 * moduleRegistry.getModule("gradle-launcher") >> module("gradle-launcher", module("gradle-cli"))
        1 * moduleRegistry.getModule("gradle-workers") >> module("gradle-workers")
        1 * moduleRegistry.getModule("gradle-dependency-management") >> module("gradle-dependency-management")

        1 * connection.useParameterSerializers(_)
        1 * connection.connect() >> {
            start {
                worker.startProcessing()
                worker.processTestClass(test)
                thread.block()
                instant.stopped
                worker.stop()
            }
        }
        1 * processor.startProcessing(_)

import org.gradle.internal.stream.EncodedStream;
import org.gradle.process.internal.JavaExecHandleBuilder;
import org.gradle.process.internal.worker.GradleWorkerMain;
import org.gradle.process.internal.worker.WorkerProcessBuilder;
import org.gradle.process.internal.worker.messaging.WorkerConfig;
import org.gradle.process.internal.worker.messaging.WorkerConfigSerializer;

import java.io.DataOutputStream;
import java.io.File;
import java.io.IOException;

        then:
        1 * client1.stop()
        1 * client2.stop()
        1 * client3.stop()

        and:
        reserveIdleClient(twoGbOptions) == null
    }

    def "expires idle worker daemons workers that have not provided usage but max heap is specified"() {
        given:
        reportsMemoryUsage = false
        def client1 = reserveNewClient(threeGbOptions)
        def client2 = reserveNewClient(twoGbOptions)

                message = String.format(
                    "Unsupported worker JDK version. Required: %s. Current: %s",
                    e2.getVersion().getMajorVersion(), JavaVersion.current().getMajorVersion()
                );
            } else {
                message = "Unsupported worker JDK version: " + JavaVersion.current().getMajorVersion();
            }

import org.gradle.api.NonNullApi;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Limits configured for workers in the current build.
 * <p>
 * Workers can be threads, processes or whatever Gradle considers a "worker".
 * <p>
 * Some examples:
 * <ul>
 *     <li>A thread running a task</li>
 *     <li>A test process</li>
 *     <li>A language compiler in a forked process</li>

        processed.gradleUserHomeDirPath == original.gradleUserHomeDirPath
        processed.serverAddress == original.serverAddress
        processed.workerId == original.workerId
        processed.displayName == original.displayName
        processed.workerAction instanceof TestAction
        processed.workerAction.value == original.workerAction.value
    }

 * limitations under the License.
 */

package org.gradle.workers.internal

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.workers.fixtures.WorkerExecutorFixture

/**
 * Verifies that we can spawn large amounts of workers without running out of memory, because the old ones will be killed
 * if necessary.
 *
 * <p>