given:
        run("work")
        run("work")
        result.assertTasksSkipped(":work")

        when:
        Files.move(inDir.toPath(), copy.toPath(), StandardCopyOption.ATOMIC_MOVE)
        inDir.deleteDir()
        inDir.createLink(copy)

        run("work")

        /*
         * This documents the current behavior, which is optimizing
         * for performance at the expense of not detecting some corner

        runCacheableBuild(pushToCacheEvents)
        then:
        !cacheableTaskResult(pushToCacheEvents).fromCache
        !cacheableTaskResult(pushToCacheEvents).upToDate

        when:
        file("build").deleteDir()
        and:
        def pullFromCacheResults = ProgressEvents.create()
        runCacheableBuild(pullFromCacheResults)
        then:
        cacheableTaskResult(pullFromCacheResults).fromCache

        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "supplies no installations for non-existing directory"() {
        given:
        assert candidates.deleteDir()

        when:
        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "supplies single installations for single candidate"() {
        given:

        then:
        taskIsNotCached()
        remoteProjectDir.file("build/docs/javadoc/index.html").assertExists()

        // Remove the project completely
        remoteProjectDir.deleteDir()

        when:
        // Move the dependencies around by using a new Gradle user home
        executer.requireOwnGradleUserHomeDir()
        withBuildCache().run "javadoc"
        then:
        taskIsCached()

    private MavenFileRepository mavenRepo
    private TestFile gradleUserHomeDir

    boolean retryWithCleanProjectDir() {
        temporaryFolder.testDirectory.listFiles().each {
            it.deleteDir()
        }
        true
    }

    def cleanup() {
        executers.each { it.cleanup() }
    }

    void requireOwnGradleUserHomeDir() {
        gradleUserHomeDir = file("user-home")
    }

        result.taskPaths(SKIPPED).empty
        result.taskPaths(UP_TO_DATE).empty
        result.taskPaths(FAILED).empty
        result.taskPaths(FROM_CACHE).empty

        when:
        file("build").deleteDir()
        result = runner('cacheable').build()
        then:
        file("build/output").text == "done"
        result.tasks.collect { it.path } == [':cacheable']
        result.taskPaths(SUCCESS).empty

        0 * logger._
    }

    def "filters always and warns once about an installation that does not exist"() {
        given:
        def jdk8 = temporaryFolder.createDir("non-existent")
        jdk8.deleteDir()
        def logOutput = "Directory '${jdk8}' (testSource) used for java installations does not exist"
        when:
        def registry = createRegistry([jdk8])
        def installations = registry.listInstallations()

func (m *MockedIpsetDeps) addIP(name string, ip netip.Addr, ipProto uint8, comment string, replace bool) error {
	args := m.Called(name, ip, ipProto, comment, replace)
	return args.Error(0)
}

func (m *MockedIpsetDeps) deleteIP(name string, ip netip.Addr, ipProto uint8) error {
	args := m.Called(name, ip, ipProto)
	return args.Error(0)
}

func (m *MockedIpsetDeps) flush(name string) error {
	args := m.Called(name)
	return args.Error(0)

        NODE_INITIALIZER_REGISTRY = new DefaultNodeInitializerRegistry(SCHEMA_STORE, STRUCT_BINDINGS_STORE)

        // Class rule does not always clean this up, so clean it up now
        SERVICES_TEST_DIRECTORY.testDirectory.deleteDir()
    }

    ModelRegistry registry = createModelRegistry()
    ModelSchemaStore schemaStore = SCHEMA_STORE
    ManagedProxyFactory proxyFactory = MANAGED_PROXY_FACTORY

        // Do nothing
    }

    @SuppressWarnings("GrMethodMayBeStatic")
    protected void removeResults(TestFile projectDir) {
        projectDir.file("build").deleteDir()
    }

    @SuppressWarnings("GrMethodMayBeStatic")
    protected void assertResultsEqual(def originalResult, def relocatedResult) {
        assert relocatedResult == originalResult
    }