import org.gradle.api.Task
import org.gradle.api.internal.TaskInternal
import org.gradle.api.internal.project.ProjectInternal
import org.gradle.api.internal.tasks.TaskContainerInternal
import spock.lang.Specification

class TaskNameResolverTest extends Specification {
    def tasks = Mock(TaskContainerInternal)
    def project = Mock(ProjectInternal)

    def setup() {
        _ * project.getTasks() >> tasks
    }

            PublicationInternal<?> internalPublication = Cast.uncheckedNonnullCast(publication);
            ProjectInternal projectInternal = (ProjectInternal) project;
            projectPublicationRegistry.registerPublication(projectInternal, internalPublication);
        });
        bridgeToSoftwareModelIfNeeded((ProjectInternal) project);
        validatePublishingModelWhenComplete(project, extension);
    }

     * @return the collection of the child projects
     *
     * @see Project#getChildProjects()
     * @see ProjectInternal#getChildProjectsUnchecked()
     */
    public static Collection<Project> getChildProjectsForInternalUse(Project thisProject) {
        return ((ProjectInternal) thisProject).getChildProjectsUnchecked().values();
    }

    private final CollectionCallbackActionDecorator callbackDecorator;
    private final ProjectInternal project;
    private final TaskStatistics statistics;
    private final BuildOperationRunner buildOperationRunner;
    private final CrossProjectConfigurator crossProjectConfigurator;
    private final ProjectRegistry<ProjectInternal> projectRegistry;

    public DefaultTaskContainerFactory(
        Instantiator instantiator,

            .map(targetProject -> (Supplier<Object>) () -> fetchModel(modelName, controller, (ProjectInternal) targetProject, parameter))
            .collect(toList());

        return runFetchActions(fetchActions);
    }

    @Nullable
    private static Object fetchModel(String modelName, BuildToolingModelController controller, ProjectInternal targetProject, @Nullable ToolingModelParameterCarrier parameter) {

        return buildForRoot(project);
    }

    @Override
    public DefaultGradleProject buildForRoot(Project project) {
        requireRootProject(project);
        ProjectInternal rootProject = (ProjectInternal) project;
        IsolatedGradleProjectParameter parameter = createParameter(GradleProjectBuilderOptions.shouldRealizeTasks());

    }

    private static class ReferenceImpl implements Reference<ProjectPublication> {
        private final ProjectPublication publication;
        private final ProjectInternal project;

        ReferenceImpl(ProjectPublication publication, ProjectInternal project) {
            this.publication = publication;
            this.project = project;
        }

        @Override
        public ProjectPublication get() {

import groovy.lang.DelegatesTo;
import org.gradle.api.Action;
import org.gradle.api.internal.project.ProjectInternal;

/**
 * A container responsible for managing the configuration of a project.
 */
public interface ProjectConfigurationActionContainer {
    void finished();

    Iterable<Action<? super ProjectInternal>> getActions();

    /**

    }

    @Override
    public void apply(Project project) {
        ProjectInternal p = (ProjectInternal) project;
        project.getExtensions().add(SourceSetContainer.class, "sourceSets", sourceSets);
        configureVariantDerivationStrategy(p);
        configureSchema(p);
    }

    private void configureVariantDerivationStrategy(ProjectInternal project) {

        new DefaultProjectDescriptor(parent, name, projectDir, projectDescriptorRegistry, TestFiles.resolver(rootProjectDir))
    }

    ProjectInternal project(ProjectDescriptor descriptor, ProjectInternal parent) {
        ProjectInternal project
        if (parent) {
            project = TestUtil.createChildProject(parent, descriptor.name, descriptor.projectDir)
        } else {