this.workerExecutor = workerExecutor
    }

    @TaskAction
    void reverseFiles() {
        // tag::worker-daemon[]
        // Create a WorkQueue with process isolation
        WorkQueue workQueue = workerExecutor.processIsolation() { ProcessWorkerSpec spec ->
            // Configure the options for the forked process
            forkOptions { JavaForkOptions options ->
                options.maxHeapSize = "512m"

            // forked phase
            if (md.getExecuteLifecycle() != null && !md.getExecuteLifecycle().isEmpty()) {
                buff.append('[');
                buff.append(md.getExecuteLifecycle());
                buff.append(']');
            }
            buff.append(md.getExecutePhase());
        } else {
            // forked goal
            buff.append(':');

        }

        then:
        events.tests.size() == 2 * (1 + 2 + 2 + 6)  // two test tasks with each: 1 root suite, 2 worker processes, 2 tests classes, 6 tests
        events.successful.size() == 8 // two test tasks with 4 tests
        events.failed.size() == 14 // two test tasks with: 1 root suite, 2 worker processes, 2 test classes, 2 tests

/**
 * 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>
 * </ul>
 */
@NonNullApi
@ServiceScope(Scope.CrossBuildSession.class)
public interface WorkerLimits {

    /**

See the License for the specific language governing permissions and
limitations under the License.
*/

package conversion

import (
	"k8s.io/apimachinery/third_party/forked/golang/reflect"
)

// The code for this type must be located in third_party, since it forks from
// go std lib. But for convenience, we expose the type here, too.
type Equalities struct {
	reflect.Equalities
}

            apply plugin: 'java'
            ${mavenCentralRepository()}
            dependencies { ${testImplementationConfiguration} 'junit:junit:4.13' }
            compileTestJava.options.fork = true  // forked as 'Gradle Test Executor 1'
        """

        file("src/test/java/MyTest.java") << """
            package example;
            public class MyTest {

    abstract String getDaemonConfiguration()

    abstract String getForkOptionsObject()

    def "can provide relocatable command line arguments to forked daemons"() {
        def originalDir = file("original-dir")
        originalDir.file("settings.gradle") << localCacheConfiguration()
        setupProjectWithJavaAgentIn(originalDir)

     *
     * Workers can be threads, processes or whatever Gradle considers a "worker". Some examples:
     *
     * <ul>
     *     <li>A thread running a task</li>
     *     <li>A test process</li>
     *     <li>A language compiler in a forked process</li>
     * </ul>
     *
     * Defaults to the number of processors available to the Java virtual machine.
     *

=====

JCIFS is an Open Source client library that implements the CIFS/SMB networking protocol in 100% Java.
From version 2.x, this project is forked from [jcifs-ng](https://github.com/AgNO3/jcifs-ng) and existing jcifs code is merged as `smb1`.

## Version

[Versions in Maven Repository](https://repo1.maven.org/maven2/org/codelibs/jcifs/)

## Using Maven

```

 */

package org.gradle.process.internal.worker;

/**
 * Configures and builds single request workers. A single request worker runs each request in a separate forked worker process.
 *
 * <p>This builder produces instances of type {@link RequestHandler}. Each call to {@link RequestHandler#run(Object)} on the returned object will start a worker process,