if (isFirstRunWithCache(context)) {
                            cacheDir.deleteDir().mkdirs()
                            buildCacheServer.cacheDir.deleteDir().mkdirs()
                            settings << remoteCacheSettingsScript
                        }

	}
	return m.Deps.addIP(m.V4Name, ipToInsert, ipProto, comment, replace)
}

func (m *IPSet) DeleteIP(ip netip.Addr, ipProto uint8) error {
	ipToDel := ip.Unmap()

	// We have already Unmap'd, so we can do a simple IsV6 y/n check now
	if ipToDel.Is6() {
		return m.Deps.deleteIP(m.V6Name, ipToDel, ipProto)
	}
	return m.Deps.deleteIP(m.V4Name, ipToDel, ipProto)
}

func (m *IPSet) Flush() error {
	var err error

        """
        when:
        withBuildCache().run "customTask"
        then:
        result.assertTaskNotSkipped(":customTask")

        when:
        file("buildSrc/build").deleteDir()
        file("buildSrc/.gradle").deleteDir()
        cleanBuildDir()

        withBuildCache().run "customTask"
        then:
        result.groupedOutput.task(":customTask").outcome == "FROM-CACHE"
    }

        then:
        cached()
        localCache.hasCacheEntry(cacheKey)

        when:
        settingsFile << """
            buildCache.remote.enabled = false
        """
        assert remoteCache.cacheDir.deleteDir()
        execute()

        then:
        cached()
    }

    def "remote loads are not cached locally if local cache is #state"() {
        given:
        settingsFile << """

        when:
        def movedLocation = temporaryFolder.file("moved-location")
        originalLocation.renameTo(movedLocation)
        movedLocation.file("build").deleteDir()
        movedLocation.file(".gradle").deleteDir()

        executer.usingProjectDirectory(movedLocation)
        withBuildCache().run "jar", "customTask"

        then:
        // Built-in tasks are loaded from cache

        runCacheableBuild(pushToCacheEvents)
        then:
        writingOperations(pushToCacheEvents).size() == maybeIncludeLocalBuildOperations(1)

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

        localCache.listCacheFailedFiles().size() == 1

        and:
        !localCache.hasCacheEntry(cacheKey)

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

        then:
        succeeds("customTask")
    }

    def "corrupted cache artifact metadata provides useful error message"() {
        when:
        buildFile << """
            @CacheableTask

        result.assertTaskSkipped ':runWork'
        outputContains ':runWork UP-TO-DATE'

        and:
        outputDoesNotContain expectedOutput

        when: 'the outputs are deleted'
        file('build').deleteDir()

        and: 'task runs for the 3rd time'
        runWork()

        then: 'it is skipped because FROM-CACHE'
        result.assertTaskSkipped ':runWork'
        outputContains ':runWork FROM-CACHE'

    abstract protected void setupProjectInOriginalLocation()

    abstract protected void moveFilesAround()

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

    abstract protected def extractResults()

    protected void assertResultsEqual(def originalResult, def movedResult) {
        assert movedResult == originalResult
    }

            this.invocationSettings = invocationSettings
            this.testId = testId.replaceAll(/[- ]/, '_')
        }

        @Override
        void beforeBuild(BuildContext context) {
            spoolDir().deleteDir()
        }

        @Override
        void afterBuild(BuildContext context, Throwable t) {
            def spoolDir = this.spoolDir()