CalculatedValueContainerFactory calculatedValueContainerFactory,
        DefaultConfigurationFactory defaultConfigurationFactory,
        TaskDependencyFactory taskDependencyFactory,
        ConfigurationRole roleAtCreation,
        boolean lockUsage
    ) {
        super(taskDependencyFactory);
        this.userCodeApplicationContext = userCodeApplicationContext;
        this.projectStateRegistry = projectStateRegistry;

    def "provides all tasks from dependent projects"() {
        def dep = new TasksFromDependentProjects("buildDependents", "testRuntime", checker, TestFiles.taskDependencyFactory())

        [child1, child2, child3].each {
            it.configurations.create "testRuntime"
            it.configurations.create "conf"
            it.tasks.create "buildDependents"

        }
    }

    def "provides tasks from project dependencies"() {
        def tasks = new TasksFromProjectDependencies("buildNeeded", () -> [projectDep1, projectDep2] as Set, TestFiles.taskDependencyFactory(), projectStateRegistry)
        def task = Mock(TaskInternal)

        when:
        tasks.visitDependencies(context)

        then:
        1 * project1State.ensureTasksDiscovered()

        ModuleDependency dep1 = new DefaultProjectDependency(null, null, false, TestFiles.taskDependencyFactory())
        dep1.attributesFactory = AttributeTestUtil.attributesFactory()
        ModuleDependency dep2 = new DefaultProjectDependency(null, null, false, TestFiles.taskDependencyFactory())
        dep2.attributesFactory = AttributeTestUtil.attributesFactory()

        when:

import org.gradle.api.internal.provider.PropertyFactory;
import org.gradle.api.internal.provider.PropertyHost;
import org.gradle.api.internal.tasks.DefaultTaskDependencyFactory;
import org.gradle.api.internal.tasks.TaskDependencyFactory;
import org.gradle.cache.FileLockManager;
import org.gradle.cache.GlobalCache;
import org.gradle.cache.internal.CacheFactory;
import org.gradle.cache.internal.CrossBuildInMemoryCacheFactory;

        ImmutableAttributesFactory attributesFactory,
        TaskDependencyFactory taskDependencyFactory,
        CapabilityNotationParser capabilityNotationParser,
        ObjectFactory objectFactory
    ) {
        return new DefaultProjectDependencyFactory(instantiator, startParameter.isBuildProjectDependencies(), capabilityNotationParser, objectFactory, attributesFactory, taskDependencyFactory);
    }

    @Provides

@SuppressWarnings("deprecation")
class CachingDependencyResolveContextTest extends Specification {
    private final CachingDependencyResolveContext context = new CachingDependencyResolveContext(TestFiles.taskDependencyFactory(), true, null)

    def resolvesAFileCollection() {
        ResolvableDependency dependency = Mock()
        FileCollectionInternal fileCollection = Mock()

        when:
        context.add(dependency)

    Instantiator instantiator = TestUtil.instantiatorFactory().decorateLenient()
    def task = Mock(Task)
    def dependencies = ImmutableSet.of(task)
    def taskDependency = TestFiles.taskDependencyFactory().configurableDependency(dependencies)
    def fileNotationParser = Mock(NotationParser)
    def publishArtifact = Stub(PublishArtifact) {
        getExtension() >> 'extension'
        getClassifier() >> 'classifier'

        binary = new DefaultSwiftBinary(Names.of("mainDebug"), project.objects, project.taskDependencyFactory, Stub(Provider), false, Stub(FileCollection), configurations, implementation, Stub(SwiftPlatform), Stub(NativeToolChainInternal), Stub(PlatformToolProvider), Stub(NativeVariantIdentity))
    }

    final store = new DefaultDomainObjectSet<PublishArtifact>(PublishArtifact, CollectionCallbackActionDecorator.NOOP)
    final set = new DefaultPublishArtifactSet('artifacts', store, fileCollectionFactory(), TestFiles.taskDependencyFactory())

    def "set is built by the union of the tasks that build the publish artifacts"() {
        PublishArtifact artifact1 = Mock()
        PublishArtifact artifact2 = Mock()
        Task task1 = Mock()