}

    void deleteCacheEntry(String cacheKey) {
        def entry = getTestFileCacheEntry(cacheKey)
        if (entry.file.exists()) {
            entry.file.deleteDir()
        }
    }

    boolean hasCacheEntry(String cacheKey) {
        return getTestFileCacheEntry(cacheKey).file.exists()
    }

    TestCacheEntry getCacheEntry(String cacheKey) {

        lockFileReaderWriter = new LockFileReaderWriter(resolver, context, lockFile, listener)
    }

    def 'writes a unique lock file'() {
        when:
        lockDir.deleteDir()
        lockFileReaderWriter.writeUniqueLockfile([a: ['foo', 'bar'], b: ['foo'], c: []])

        then:

        """
        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"
    }

        when:
        withBuildCache().run "cacheable", "--info"
        then:
        outputContains "Stored cache entry for task ':cacheable' with cache key"

        file("build").deleteDir()

        when:
        withBuildCache().run "cacheable", "--info"
        then:
        outputContains "Loaded cache entry for task ':cacheable' with cache key"
    }

    def defineCacheableTask() {

                }

                private void cleanupCache(File userHomeDir) {
                    ['modules-2', 'external-resources'].each {
                        new File("$userHomeDir/caches/$it").deleteDir()
                    }
                }
            }
        }
    }

    def "resolves dependencies from external repository"() {
        startServer()

        given:

        return new BuildMutator() {
            @Override
            void beforeBuild(BuildContext context) {
                if (action == storing) {
                    stateDirectory.deleteDir()
                }
            }

            @Override
            void afterBuild(BuildContext context, Throwable error) {
                if (context.iteration > 1) {

    }

    boolean stackTraceContains(Class<?> type) {
        output.contains("\tat ${type.name}.")
    }

    private TestFile cleanBuildDir() {
        file("build").assertIsDir().deleteDir()
    }

        Jvm differentVersion = AvailableJavaHomes.differentVersion

        jdkRepository = new JdkRepository(differentVersion, "not_current_jdk.zip")
        uri = jdkRepository.start()

        userHome.deleteDir()
        settingsFile << applyToolchainResolverPlugin("CustomToolchainResolver", singleUrlResolverCode(uri))
        buildFile << """
            plugins {
                id 'application'
                id 'java'

        if (GradleContextualExecuter.isConfigCache()) {
            def build = testDirectory.file("build")
            assert build.listFiles().size() == 1 && build.file("reports").exists()
            build.deleteDir()
        }

        when: "clean is executed again without any changes"
        succeeds "clean"
        then: "clean is still marked UP-TO-DATE"
        result.groupedOutput.task(":clean").outcome == "UP-TO-DATE"

		Protocol: &ipProto,
		Replace:  replace,
	})
	if err != nil {
		return fmt.Errorf("failed to add IP %s to ipset %s: %w", ip, name, err)
	}
	return nil
}

func (m *realDeps) deleteIP(name string, ip netip.Addr, ipProto uint8) error {
	err := netlink.IpsetDel(name, &netlink.IPSetEntry{
		IP:       net.IP(ip.AsSlice()),
		Protocol: &ipProto,
	})
	if err != nil {