public static TaskDependencyFactory withNoAssociatedProject() {
        return new DefaultTaskDependencyFactory(null, null);
    }

    public static TaskDependencyFactory forProject(
        TaskResolver taskResolver,
        @Nullable TaskDependencyUsageTracker taskDependencyUsageTracker
    ) {
        return new DefaultTaskDependencyFactory(taskResolver, taskDependencyUsageTracker);
    }

            }
        });

    public ProjectExecutionServiceRegistry(ServiceRegistry globalServices) {
        global = globalServices::get;
    }

    public NodeExecutionContext forProject(@Nullable ProjectInternal project) {
        if (project == null) {
            return global;
        }
        return projectRegistries.getUnchecked(project);
    }

    @Override
    public void close() {

    }

    def "reports usages of getDependencies if provided a tracker"() {
        given:
        def tracker = Mock(TaskDependencyUsageTracker)
        def dependency = DefaultTaskDependencyFactory.forProject(resolver, tracker).configurableDependency()

        when:
        dependency.getDependenciesForInternalUse(null)
        then:
        0 * tracker.onTaskDependencyUsage(_)

        when:

        @Nullable TaskDependencyUsageTracker tracker = project.getServices().get(CrossProjectModelAccess.class).taskDependencyUsageTracker(project);
        return DefaultTaskDependencyFactory.forProject(project.getTasks(), tracker);
    }

    @Provides
    protected ConfigurationTargetIdentifier createConfigurationTargetIdentifier() {
        return ConfigurationTargetIdentifier.of(project);
    }

    private final TaskResolver taskResolver = [resolveTask: {name -> [getName: {name}] as Task}] as TaskResolver
    private final TaskDependencyFactory taskDependencyFactory = DefaultTaskDependencyFactory.forProject(taskResolver, Mock(TaskDependencyUsageTracker))
    private final FileResolver fileResolver = TestFiles.resolver(tmpDir.testDirectory)

            this.projectExecutionServices = projectExecutionServices;
        }

        @Override
        public void execute(Node node) {
            NodeExecutionContext context = projectExecutionServices.forProject(node.getOwningProject());
            for (NodeExecutor nodeExecutor : nodeExecutors) {
                if (nodeExecutor.execute(node, context)) {
                    return;
                }
            }

        serviceRegistryMock.get(ObjectFactory) >> objectFactory
        serviceRegistryMock.get(TaskDependencyFactory) >> DefaultTaskDependencyFactory.forProject(taskContainerMock, Mock(TaskDependencyUsageTracker))
        pluginManager.getPluginContainer() >> pluginContainer

        serviceRegistryMock.get((Type) DeferredProjectConfiguration) >> Stub(DeferredProjectConfiguration)

    def taskResolver = Mock(TaskResolver)
    def host = Mock(PropertyHost)
    def patternSetFactory = TestFiles.patternSetFactory
    def taskDependencyFactory = DefaultTaskDependencyFactory.forProject(taskResolver, (tasks) -> { })
    def collection = new DefaultConfigurableFileCollection("<display>", fileResolver, taskDependencyFactory, patternSetFactory, host)

    @Override

        mavenRepo.module("foo", "baz", "1.0").dependsOn("foo", "bar", "1.0").dependsOn("foo", "qix", "1.0").publish()

        file("settings.gradle") << """
            rootProject.name = 'fooProject'
        """

        file("build.gradle") << """
            apply plugin : 'project-report'
            description = 'dummy description'
            repositories {
                maven { url "${mavenRepo.uri}" }

// Tlon.io : https://tlon.io
// Submitted by Mark Staarink <******@****.***>
arvo.network
azimuth.network
tlon.network

// Tor Project, Inc. : https://torproject.org
// Submitted by Antoine Beaupré <anarcat@torproject.org
torproject.net
pages.torproject.net

// TownNews.com : http://www.townnews.com
// Submitted by Dustin Ward <******@****.***>
bloxcms.com
townnews-staging.com