import org.gradle.internal.remote.ConnectionAcceptor;
import org.gradle.internal.remote.ObjectConnection;
import org.gradle.process.ExecResult;
import org.gradle.process.internal.ExecException;
import org.gradle.process.internal.ExecHandle;
import org.gradle.process.internal.ExecHandleListener;
import org.gradle.process.internal.health.memory.JvmMemoryStatus;

import javax.annotation.Nullable;
import java.util.Date;
import java.util.Optional;

     *
     * <p>This method is re-entrant, so that an action can call back into this method.</p>
     */
    <T> T withFileLock(Supplier<? extends T> action);

    /**

}
"""

        file('buildSrc/src/main/java/TestWorkerProcessImpl.java') << '''
import org.gradle.process.internal.worker.RequestHandler;

public class TestWorkerProcessImpl implements RequestHandler<Object, Object> {
    public Object run(Object param) { return null; }
}
'''
        buildFile << '''
import org.gradle.process.internal.worker.WorkerProcessFactory

task runBrokenWorker {
    def rootDir = project.rootDir

import org.gradle.api.tasks.WorkResult;
import org.gradle.api.tasks.WorkResults;
import org.gradle.language.base.internal.compile.Compiler;
import org.gradle.process.ExecResult;
import org.gradle.process.internal.ExecHandle;
import org.gradle.process.internal.ExecHandleBuilder;
import org.gradle.process.internal.ExecHandleFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.Serializable;

/**

		"--mark", inpodMark,
		"-j", "CONNMARK",
		"--set-xmark", inpodTproxyMark)

	// Handle healthcheck probes from the host node. In the host netns, before the packet enters the pod, we SNAT
	// the healthcheck packet to a fixed IP if the packet is coming from a node-local process with a socket.
	//
	// We do this so we can exempt this traffic from ztunnel capture/proxy - otherwise both kube-proxy (legit)

                    logger.warn("Could not close a process output stream.", e);
                }
            });

            if (logger.isDebugEnabled()) {
                logger.debug("Terminating process {}.", p);
            }
            try {
                if (!p.destroyForcibly().waitFor(timeout, TimeUnit.MILLISECONDS)) {
                    logger.warn("Terminating process {} is timed out.", p);

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

package org.gradle.process;

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

/**
 * Process execution operations.
 *

	"internal/stringslite"
	"runtime"
)

func executable() (string, error) {
	var procfn string
	switch runtime.GOOS {
	default:
		return "", errors.New("Executable not implemented for " + runtime.GOOS)
	case "linux", "android":
		procfn = "/proc/self/exe"
	case "netbsd":
		procfn = "/proc/curproc/exe"
	}
	path, err := Readlink(procfn)

	// When the executable has been deleted then Readlink returns a

        new JUnitTestClassProcessor(spec, new LongIdGenerator(), new TestActorFactory(), Time.clock())
    }

    void process(Class... clazz) {
        process(clazz*.name)
    }

    void process(Iterable<String> classNames) {
        classProcessor.startProcessing(processor)
        for (String c : classNames) {

        def dumpbin = findExe("lib.exe")
        def process = [dumpbin.absolutePath, '/LIST', binaryFile.absolutePath].execute(["PATH=$vcPath"], null)
        return process.inputStream.readLines().drop(3).collect { new File(it).name }
    }

    List<String> listLinkedLibraries() {
        def dumpbin = findExe("dumpbin.exe")