public TimeoutStep(
        TimeoutHandler timeoutHandler,
        CurrentBuildOperationRef currentBuildOperationRef,
        Step<? super C, ? extends R> delegate
    ) {
        this.timeoutHandler = timeoutHandler;
        this.currentBuildOperationRef = currentBuildOperationRef;
        this.delegate = delegate;
    }

    @Override
    public R execute(UnitOfWork work, C context) {

        OutputSnapshotter outputSnapshotter,
        OverlappingOutputDetector overlappingOutputDetector,
        StartParameter startParameter,
        TimeoutHandler timeoutHandler,
        ValidateStep.ValidationWarningRecorder validationWarningRecorder,
        VirtualFileSystem virtualFileSystem
    ) {
        UniqueId buildId = buildInvocationScopeId.getId();

        FileSystemAccess fileSystemAccess,
        ListenerManager listenerManager,
        ImmutableWorkspaceMetadataStore immutableWorkspaceMetadataStore,
        OutputSnapshotter outputSnapshotter,
        TimeoutHandler timeoutHandler,
        ValidateStep.ValidationWarningRecorder validationWarningRecorder,
        VirtualFileSystem virtualFileSystem
    ) {

import org.gradle.internal.concurrent.ExecutorFactory;
import org.gradle.internal.event.ListenerManager;
import org.gradle.internal.event.ScopedListenerManager;
import org.gradle.internal.execution.timeout.TimeoutHandler;
import org.gradle.internal.execution.timeout.impl.DefaultTimeoutHandler;
import org.gradle.internal.file.FileAccessTimeJournal;
import org.gradle.internal.hash.ClassLoaderHierarchyHasher;

	t.Cleanup(func() {
		testHookProxyConnectTimeout = orig
	})
	testHookProxyConnectTimeout = f
}

func NewTestTimeoutHandler(handler Handler, ctx context.Context) Handler {
	return &timeoutHandler{
		handler:     handler,
		testContext: ctx,
		// (no body)
	}
}

func ResetCachedEnvironment() {
	resetProxyConfig()
}

func (t *Transport) NumPendingRequestsForTesting() int {

// After such a timeout, writes by h to its [ResponseWriter] will return
// [ErrHandlerTimeout].
//
// TimeoutHandler supports the [Pusher] interface but does not support
// the [Hijacker] or [Flusher] interfaces.
func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler {
	return &timeoutHandler{
		handler: h,
		body:    msg,
		dt:      dt,
	}
}

// Both issues involved panics in the implementation of TimeoutHandler.
func TestTimeoutHandlerRaceHeader(t *testing.T) { run(t, testTimeoutHandlerRaceHeader) }
func testTimeoutHandlerRaceHeader(t *testing.T, mode testMode) {
	delay204 := HandlerFunc(func(w ResponseWriter, r *Request) {
		w.WriteHeader(204)
	})

	ts := newClientServerTest(t, mode, TimeoutHandler(delay204, time.Nanosecond, "")).ts

	var wg sync.WaitGroup

Class <org.gradle.internal.execution.timeout.TimeoutHandler> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (TimeoutHandler.java:0)