// Do nothing
    }

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

    @SuppressWarnings("GrMethodMayBeStatic")
    protected void assertResultsEqual(def originalResult, def relocatedResult) {
        assert relocatedResult == originalResult
    }

        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:

        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:

    }

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

        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"