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
    }

        make("A")
        succeeds("cacheable")
        make("B")
        // populate the cache
        withBuildCache().run("cacheable")

        when:
        gradleUserHome.deleteDir() // nuke the file snapshot cache
        resources.deleteDir().mkdirs()
        succeeds("clean")
        and:
        // Building with the resources seen in the opposite order
        // shouldn't make a difference
        make("B")

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

    private TestBuildCache buildCache

    @Before
    void setupCacheDirectory() {
        // Make sure cache dir is empty for every test execution
        buildCache = new TestBuildCache(temporaryFolder.file("cache-dir").deleteDir().createDir())
        settingsFile << buildCache.localCacheConfiguration()
    }

    // Spock 2 executes @Before after the setup() methods

        def versionDir = this.versionDir
        fileAccessManager.access(distributionZip) {
            if (!markerFile.exists()) {
                distributionZip.delete()
                gradleHomeDir.deleteDir()

                URL url = getDownloadURL();
                System.out.println("downloading $url")
                distributionZip.copyFrom(url)

			if _, f := pmap[port.Name]; !f {
				pmap[port.Name] = uint32(port.ContainerPort)
			}
		}
	}
	return pmap
}

// deleteIP returns true if the pod and ip are really deleted.
func (pc *PodCache) deleteIP(ip string, podKey types.NamespacedName) bool {
	pc.Lock()
	defer pc.Unlock()
	if pc.podsByIP[ip].Contains(podKey) {
		sets.DeleteCleanupLast(pc.podsByIP, ip, podKey)

        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:

        tgzCacheEntry.delete()

        def metadata = new Properties()
        extractDir.file("METADATA").withInputStream { input ->
            metadata.load(input)
        }
        extractDir.deleteDir()
        return metadata
    }

        return osName.contains("windows");
    }

    private boolean deleteDir(File dir) {
        if (dir.isDirectory()) {
            String[] children = dir.list();
            if (children != null) {
                for (int i = 0; i < children.length; i++) {
                    boolean success = deleteDir(new File(dir, children[i]));
                    if (!success) {
                        return false;

}

func (m *realDeps) addIP(name string, ip netip.Addr, ipProto uint8, comment string, replace bool) error {
	return errors.New("not implemented on this platform")
}

func (m *realDeps) deleteIP(name string, ip netip.Addr, ipProto uint8) error {
	return errors.New("not implemented on this platform")
}

func (m *realDeps) flush(name string) error {
	return errors.New("not implemented on this platform")
}