* when creating new instances and/or loading from the configuration cache.
 */
@ThreadSafe
@ServiceScope(Scope.BuildTree.class)
public class TaskIdentityFactory {

    private final ConfigurationCacheableIdFactory idFactory;

    public TaskIdentityFactory(ConfigurationCacheableIdFactory idFactory) {
        this.idFactory = idFactory;
    }

    /**
     * Create a task identity.
     */

    private final TaskIdentityFactory taskIdentityFactory;
    private final ITaskFactory taskFactory;
    private final ProjectInternal project;

    public TaskInstantiator(TaskIdentityFactory taskIdentityFactory, ITaskFactory taskFactory, ProjectInternal project) {
        this.taskIdentityFactory = taskIdentityFactory;
        this.taskFactory = taskFactory;
        this.project = project;

    private static final SimpleModelRuleDescriptor COPY_TO_TASK_CONTAINER_DESCRIPTOR = new SimpleModelRuleDescriptor("copyToTaskContainer");
    private final Instantiator instantiator;
    private final TaskIdentityFactory taskIdentityFactory;
    private final ITaskFactory taskFactory;
    private final CollectionCallbackActionDecorator callbackDecorator;
    private final ProjectInternal project;
    private final TaskStatistics statistics;

import java.util.concurrent.atomic.AtomicLong;

/**
 * A test fixture to create {@link TaskIdentityFactory}'es or {@link TaskIdentity}'es directly.
 * <p>
 * It exists mainly because {@code TaskIdentity} is a final class and cannot be mocked.
 */
public class TestTaskIdentities {

    private static final TaskIdentityFactory DEFAULT_FACTORY = factory();

    }

    @Provides
    protected TaskInstantiator createTaskInstantiator(TaskIdentityFactory taskIdentityFactory, ITaskFactory taskFactory) {
        return new TaskInstantiator(taskIdentityFactory, taskFactory, project);
    }

    @Provides
    protected TaskContainerInternal createTaskContainerInternal(
        TaskStatistics taskStatistics,

    ) {
        super(Task.class, instantiator, project, MutationGuards.of(crossProjectConfigurator), callbackDecorator);
        this.taskIdentityFactory = taskIdentityFactory;
        this.taskFactory = taskFactory;
        taskInstantiator = new TaskInstantiator(taskIdentityFactory, taskFactory, project);
        this.statistics = statistics;
        this.eagerlyCreateLazyTasks = Boolean.getBoolean(EAGERLY_CREATE_LAZY_TASKS_PROPERTY);

    public static final String TEST_TASK_NAME = "taskname"

    def taskClassInfoStore = new DefaultTaskClassInfoStore(new TestCrossBuildInMemoryCacheFactory())
    def taskIdentityFactory = new TaskIdentityFactory(new ConfigurationCacheableIdFactory())
    def taskFactory = new AnnotationProcessingTaskFactory(DirectInstantiator.INSTANCE, taskClassInfoStore, new TaskFactory())

    abstract DefaultTask getTask()

import org.gradle.api.internal.file.TestFiles
import org.gradle.api.internal.project.ProjectInternal
import org.gradle.api.internal.project.taskfactory.TaskFactory
import org.gradle.api.internal.project.taskfactory.TaskIdentityFactory
import org.gradle.api.internal.project.taskfactory.TaskInstantiator
import org.gradle.api.internal.tasks.DefaultSourceSetContainer
import org.gradle.internal.id.ConfigurationCacheableIdFactory

import org.gradle.api.internal.model.NamedObjectInstantiator;
import org.gradle.api.internal.project.DefaultProjectStateRegistry;
import org.gradle.api.internal.project.taskfactory.TaskIdentityFactory;
import org.gradle.api.internal.provider.DefaultConfigurationTimeBarrier;
import org.gradle.api.internal.provider.PropertyFactory;
import org.gradle.api.internal.tasks.TaskDependencyFactory;

import org.gradle.util.Path
import org.gradle.util.TestUtil

import static java.util.Collections.singletonMap

class DefaultTaskContainerTest extends AbstractPolymorphicDomainObjectContainerSpec<Task> {

    private taskIdentityFactory = TestTaskIdentities.factory()
    private taskFactory = Mock(ITaskFactory)
    private project = Mock(ProjectInternal, name: "<project>") {
        identityPath(_) >> { String name ->