@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);

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

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

            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());

        then:
        1 * source1.visit(closureAsVisitor)
        1 * source2.visit(closureAsVisitor)
    }

    def visitsEachTreeWithAction() {
        final Action<FileVisitDetails> visitor = Actions.doNothing()

        when:
        tree.visit(visitor)

        then:
        1 * source1.visit(visitor)
        1 * source2.visit(visitor)
    }

        CopySpecResolver childResolver = childSpec.buildResolverRelativeToParent(copySpec.buildRootResolver())

        when:
        copySpec.filesMatching("**/*.java", Actions.doNothing())

        then:
        1 == childResolver.allCopyActions.size()
        childResolver.allCopyActions[0] instanceof MatchingCopyAction
    }

    private FileCopyDetails details(String file) {

    private String customDescription;
    private VersionConstraint useVersion;
    private ModuleComponentSelector useSelector;
    private Action<ArtifactSelectionDetails> artifactSelectionAction = Actions.doNothing();
    private boolean dirty;

    @Inject
    public DefaultDependencyResolveDetails(DependencySubstitutionInternal delegate, ModuleVersionSelector requested) {
        this.delegate = delegate;