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

    def "incremental task is informed that all input files are 'out-of-date' when all output files have been removed"() {
        given:
        previousExecution()

        when:
        file("outputs").deleteDir()

        then:
        executesNonIncrementally()
    }

    def "incremental task is informed that all input files are 'out-of-date' when Task.upToDate() is false"() {
        given:

  EXPECT_TRUE(stat.is_directory);
}

TEST_F(GCSFilesystemTest, DeleteDir) {
  tf_gcs_filesystem::Init(filesystem_, status_);
  ASSERT_TF_OK(status_);
  const std::string dir = GetURIForPath("DeleteDir");
  const std::string file = io::JoinPath(dir, "DeleteDirFile.csv");
  WriteString(file, "test");
  ASSERT_TF_OK(status_);
  tf_gcs_filesystem::DeleteDir(filesystem_, dir.c_str(), status_);

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

        createJarWithProperties("lib/foo.jar")
        buildFile << """
            buildscript { dependencies { classpath files("lib") }}
        """

        when:
        run()
        assert file("lib").deleteDir()
        run()

        then:
        notCached

        when:
        run()

        then:
        isCached()
    }

        // delete .gradle dir to simulate this
        when:
        file('.gradle').assertIsDir().deleteDir()
        outputAFile.makeOlder()
        outputBFile.makeOlder()
        succeeds "b"

        then:
        result.assertTasksNotSkipped(":a", ":b")

        when:
        file('build/b').deleteDir()
        succeeds "b"

        then:
        result.assertTasksNotSkipped(":b")

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