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:

        // start one JVM with jdk to remove
        executer.withJavaHome(jdkToRemove)
        succeeds("help")

        when:
        // remove the JDK
        jdkToRemove.deleteDir()
        // don't ask for the removed JDK now
        executer.withJavaHome(installedJdk)
        then:
        // try to start another build
        succeeds("help")
    }

    @Requires(

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

void DeleteFile(const TF_Filesystem* filesystem, const char* path,
                TF_Status* status);
void Stat(const TF_Filesystem* filesystem, const char* path,
          TF_FileStatistics* stats, TF_Status* status);
void DeleteDir(const TF_Filesystem* filesystem, const char* path,
               TF_Status* status);
void CopyFile(const TF_Filesystem* filesystem, const char* src, const char* dst,
              TF_Status* status);

        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'

        "user value" == properties["prop"]
    }

    def loadPropertiesWithNoExceptionForNonexistentGradleInstallationHomeAndUserHomeAndSettingsDir() {
        given:
        tmpDir.getTestDirectory().deleteDir()

        expect:
        loadProperties() != null
    }

    def loadPropertiesWithNoExceptionIfGradleInstallationHomeIsNotKnown() {
        given:
        gradleInstallationHomeDir = null

        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 {