@Override
    public PluginDependenciesSpec getPlugins() {
        return pluginDependenciesSpec;
    }

    @Override
    public void includeBuild(String rootProject) {
        includeBuild(rootProject, Actions.doNothing());
    }

    @Override
    public void includeBuild(String rootProject, Action<ConfigurableIncludedPluginBuild> configuration) {
        File projectDir = fileResolver.resolve(rootProject);

        BuildDefinition buildDefinition = BuildDefinition.fromStartParameterForBuild(
            buildSrcStartParameter,
            BUILD_SRC,
            buildSrcDir,
            PluginRequests.EMPTY,
            Actions.doNothing(),
            publicBuildPath,
            true
        );
        @SuppressWarnings("deprecation")
        File customBuildFile = DeprecationLogger.whileDisabled(buildSrcStartParameter::getBuildFile);

            new Runnable() {
              @Override
              public void run() {
                executor.execute(Runnables.doNothing());
              }
            });
    future.get(10, TimeUnit.SECONDS);
    assertThrows(RejectedExecutionException.class, () -> executor.execute(Runnables.doNothing()));
    latch.countDown();
    ExecutionException expected =

        return new BuildDefinition(null, rootBuildDir, startParameter, PluginRequests.EMPTY, Actions.doNothing(), fromBuild, false);
    }

    private static StartParameterInternal startParameterForIncludedBuildFrom(StartParameterInternal startParameter, @Nullable File buildRootDir) {

            new Runnable() {
              @Override
              public void run() {
                executor.execute(Runnables.doNothing());
              }
            });
    future.get(10, TimeUnit.SECONDS);
    assertThrows(RejectedExecutionException.class, () -> executor.execute(Runnables.doNothing()));
    latch.countDown();
    ExecutionException expected =

        0 * listenerMock._
    }

    def handlesWorkerProcessThatNeverConnects() {
        when:
        workerFactory.setConnectTimeoutSeconds(3)
        execute(worker(Actions.doNothing()).jvmArgs("-Dorg.gradle.worker.test.stuck").expectStartFailure())

        then:
        stdout.stdOut == ""
        stdout.stdErr == ""
    }

    def handlesWorkerActionThatCannotBeDeserialized() {

            val containingClassScope = firSymbol.dispatchReceiverType?.scope(
                session,
                analysisSession.getScopeSessionFor(session),
                CallableCopyTypeCalculator.DoNothing,
                requiredMembersPhase = FirResolvePhase.STATUS,
            ) ?: return false

            val overriddenProperties = containingClassScope.getDirectOverriddenProperties(propertySymbol)

     */
    protected abstract T doCreate(String name);

    @Override
    public T create(String name) {
        assertMutable("create(String)");
        return create(name, Actions.doNothing());
    }

    @Override
    public T maybeCreate(String name) {
        T item = findByName(name);
        if (item != null) {
            return item;
        }
        return create(name);
    }

                resolvedComponentVersions.put(moduleId.getModuleIdentifier(), moduleId.getVersion());
            }

        }, Actions.doNothing(), new HashSet<>());

        return resolvedComponentVersions;
    }

                    }
                }
                V generatedValue = producer.apply(key);
                delegate.putLater(key, generatedValue, completion);
                completionRef.set(Runnables.doNothing());
                return generatedValue;
            });
        } catch (UncheckedExecutionException | ExecutionException e) {
            throw UncheckedException.throwAsUncheckedException(e.getCause());