override fun setIncludedBuilds(includedBuilds: MutableCollection<out IncludedBuildInternal>) {
        delegate.setIncludedBuilds(includedBuilds)
    }

    override fun getIdentityPath(): Path =
        delegate.identityPath

    override fun contextualize(description: String): String =
        delegate.contextualize(description)

    override fun getPublicBuildPath(): PublicBuildPath =
        delegate.publicBuildPath

        private DetachedDependencyResolutionDomainObjectContext(DomainObjectContext delegate) {
            this.delegate = delegate;
        }

        @Override
        public Path identityPath(String name) {
            return delegate.identityPath(name);
        }

        @Override
        public Path projectPath(String name) {
            return delegate.projectPath(name);
        }

        @Override

        }
    }

    private DefaultProject defaultProject(String name, ProjectState owner, def parent, File rootDir, ClassLoaderScope scope) {
        _ * owner.identityPath >> (parent == null ? Path.ROOT : parent.identityPath.child(name))
        _ * owner.projectPath >> (parent == null ? Path.ROOT : parent.projectPath.child(name))
        _ * owner.depth >> owner.projectPath.segmentCount()

    }

    @Internal
    @Override
    public String getPath() {
        return identity.projectPath.toString();
    }

    @Override
    public Path getIdentityPath() {
        return identity.identityPath;
    }

    @Override
    public Task dependsOn(final Object... paths) {
        taskMutator.mutate("Task.dependsOn(Object...)", new Runnable() {
            @Override
            public void run() {

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

    private DefaultConfigurationFactory confFactory(String projectPath, String buildPath) {
        def domainObjectContext = Stub(DomainObjectContext)
        def build = Path.path(buildPath)
        _ * domainObjectContext.identityPath(_) >> { String p -> build.append(Path.path(projectPath)).child(p) }
        _ * domainObjectContext.projectPath(_) >> { String p -> Path.path(projectPath).child(p) }

        hasher.putHash(requireNotNull(identityFileInputs[CLASSPATH_INPUT_PROPERTY]).hash)
        val identityHash = hasher.hash().toString()
        return UnitOfWork.Identity { identityHash }
    }

    override fun getWorkspaceProvider() = workspaceProvider.accessors

    override fun getInputFingerprinter() = inputFingerprinter