}

    def "clean on Java project with a single source file and no dependencies"() {
        given:
        buildWithSingleSourceFile()

        def buildDir = file("build")
        buildDir.mkdirs()

        expect:
        configurationCacheRun "clean"
        assertStateStored()
        result.assertTasksExecuted(":clean")
        !buildDir.exists()

        when:

            )
        """

        when:
        buildDir.mkdir()
        configurationCacheRun 'clean'

        then:
        configurationCache.assertStateStored()

        and:
        buildDir.assertDoesNotExist()

        when:
        buildDir.mkdir()
        configurationCacheRun 'clean'

        then:
        configurationCache.assertStateLoaded()

        and:

        classFile.isFile()
        testClassFile.isFile()
        testResults.isDirectory()

        and:
        assertTestsExecuted("ThingTest", "ok")

        when:
        configurationCacheRun "clean"

        and:
        configurationCacheRun "build"

        then:
        configurationCache.assertStateLoaded()
        result.assertTasksExecuted(*expectedTasks)

        and:
        classFile.isFile()

            '''
        }

        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheRun 'clean', 'compileJava'

        then:
        configurationCache.assertStateStored()

        when:
        configurationCacheRun 'clean', 'compileJava'

        then:
        configurationCache.assertStateLoaded()

        and:

}

packageCycles {
    excludePatterns.add("org/gradle/**")
}

testFilesCleanup.reportOnly = true

tasks.clean {
    val testFiles = layout.buildDirectory.dir("tmp/teŝt files")
    doFirst {
        // On daemon crash, read-only cache tests can leave read-only files around.
        // clean now takes care of those files as well
        testFiles.get().asFileTree.matching {
            include("**/read-only-cache/**")

	}()

	if i.cfg.DumpKubernetesManifests {
		i.installer.Dump(i.ctx)
	}

	if i.cfg.DeployIstio {
		errG := multierror.Group{}
		// Make sure to clean up primary clusters before remotes, or istiod will recreate some of the CMs that we delete
		// in the remote clusters before it's deleted.
		for _, c := range i.ctx.AllClusters().Primaries() {
			i.cleanupCluster(c, &errG)
		}

abstract class CleanAcceptedApiChanges extends DefaultTask {

    @PathSensitive(PathSensitivity.ABSOLUTE)
    @InputDirectory
    abstract DirectoryProperty getJsonFileDirectory()

    @TaskAction
    void clean() {
        def jsonFileManager = new AcceptedApiChangesJsonFileManager()
        jsonFileDirectory.asFile.get().listFiles()
            ?.findAll { it.name.endsWith(".json") }

	fi
	@cp -a $(TMP)/common-files/files/* $(TMP)/common-files/files/.devcontainer $(TMP)/common-files/files/.gitattributes $(shell pwd)
	@rm -fr $(TMP)/common-files
	@$(or $(COMMONFILES_POSTPROCESS), true)

check-clean-repo:
	@common/scripts/check_clean_repo.sh

tidy-docker:
	@docker image prune --all --force --filter="label=io.istio.repo=https://github.com/istio/tools" --filter="label!=io.istio.version=$(IMAGE_VERSION)"

  fi
  "${DOCKER[@]}" rm -f -v "$1" >/dev/null 2>&1 || true
}

# ---------------------------------------------------------------------------
# Building


function kube::build::clean() {
  if kube::build::has_docker ; then
    kube::build::docker_delete_old_containers "${KUBE_BUILD_CONTAINER_NAME_BASE}"
    kube::build::docker_delete_old_containers "${KUBE_RSYNC_CONTAINER_NAME_BASE}"

		for _, remote := range m.Targets() {
			if err := m.Connection(remote).WaitForConnect(ctx); err != nil {
				return nil, err
			}
		}
	}
	return &res, nil
}

// Cleanup will clean up the test grid.
func (t *TestGrid) Cleanup() {
	t.cancel()
	t.cleanupOnce.Do(func() {
		for _, manager := range t.Managers {
			manager.debugMsg(debugShutdown)
		}
		for _, server := range t.Servers {