}

        override fun getPluginManager(): PluginManagerInternal {
            onAccess("pluginManager")
            return delegate.pluginManager
        }

        override fun identityPath(name: String): Path {
            shouldNotBeUsed()
        }

        override fun projectPath(name: String): Path {
            shouldNotBeUsed()
        }

    FilePropertyFactory filePropertyFactory = TestFiles.filePropertyFactory()

    @Subject
    DefaultDependencyLockingProvider provider

    def setup() {
        context.identityPath(_) >> { String value -> Path.path(value) }
        context.getProjectPath() >> Path.path(':')
        resolver.canResolveRelativePath() >> true
        resolver.resolve(LockFileReaderWriter.DEPENDENCY_LOCKING_FOLDER) >> lockDir

    DomainObjectContext context = Mock()
    FileResourceListener listener = Mock()
    RegularFileProperty lockFile = TestFiles.filePropertyFactory().newFileProperty()

    def setup() {
        context.identityPath(_) >> { String value -> Path.path(value) }
        resolver.canResolveRelativePath() >> true
        resolver.resolve(LockFileReaderWriter.DEPENDENCY_LOCKING_FOLDER) >> lockDir

            it.settingsFile << """
                gradle.projectsEvaluated {
                    // only print from the root build of the build tree to avoid duplication
                    if (gradle.owner.identityPath.path == ':') {
                        def registry = gradle.services.get(${BuildStateRegistry.name})
                        registry.visitBuilds { b ->
                            def buildId = b.buildIdentifier

                addressSerializer.write(this, it)
            }
        }
    }

    private
    fun DefaultWriteContext.writeModelKey(key: ModelKey) {
        writeNullableString(key.identityPath?.path)
        writeString(key.modelName)
        writeNullableString(key.parameterHash?.toString())
    }

    internal
    fun readCacheEntryDetailsFrom(stateFile: ConfigurationCacheStateFile): EntryDetails? {

            getIdentityPath() >> Stub(Path)
        }
        def exclude = Mock(ExcludeRule)

        and:
        projectDependencyResolver.resolveComponent(ModuleVersionIdentifier, projectDependency.identityPath) >> DefaultModuleVersionIdentifier.newId("pub-org", "pub-module", "pub-revision")
        projectDependency.targetConfiguration >> "dep-configuration"
        projectDependency.artifacts >> []

    }

    static String projectDependency(String projectPath) {
        return "DefaultProjectDependency{identityPath='${projectPath}', configuration='default'}"
    }

    static String getDeclarativeScriptThatConfiguresOnlyTestSoftwareType(String configuration="") {
        return """
            testSoftwareType {

    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()