file("build/classes/java/main/A.txt").exists()

        when:
        a.delete()
        succeeds "compileJava"

        then: "they all get cleaned"
        outputs.deletedClasses("A")
        !file("build/generated/sources/annotationProcessor/java/main/A.txt").exists()
        !file("build/generated/sources/headers/java/main/A.txt").exists()

	utilflowcontrol "k8s.io/apiserver/pkg/util/flowcontrol"
	"k8s.io/client-go/tools/cache"
	testingclock "k8s.io/utils/clock/testing"
)

// verifies the cacheWatcher.process goroutine is properly cleaned up even if
// the writes to cacheWatcher.result channel is blocked.
func TestCacheWatcherCleanupNotBlockedByResult(t *testing.T) {
	var lock sync.RWMutex
	var w *cacheWatcher
	count := 0

        then:
        fixture.staleFilesHaveBeenRemoved()

        where:
        outputDir << ['build', 'build/outputs', 'build/some/deeply/nested/structure']
    }

    def "build operations are created for stale outputs cleanup"() {
        def operations = new BuildOperationsFixture(executer, testDirectoryProvider)
        def fixture = new StaleOutputFixture()
        fixture.createInputs()
        buildScript(fixture.buildScript)

// ID -> pod
var quotaPodMap = make(map[common.QuotaID]types.UID)

// Directory -> pod
var dirPodMap = make(map[string]types.UID)

// Backing device -> applier
// This is *not* cleaned up; its size will be bounded.
var devApplierMap = make(map[string]common.LinuxVolumeQuotaApplier)

// Directory -> applier
var dirApplierMap = make(map[string]common.LinuxVolumeQuotaApplier)
var dirApplierLock sync.RWMutex

		log_end_msg 0
		exit 0
	fi

	# Prepare environment
	mkdir -p "$LOG_DIR" "$DATA_DIR" && chown "$FESS_USER":"$FESS_GROUP" "$LOG_DIR" "$DATA_DIR"

	# Ensure that the PID_DIR exists (it is cleaned at OS startup time)
	if [ -n "$PID_DIR" ] && [ ! -e "$PID_DIR" ]; then
		mkdir -p "$PID_DIR" && chown "$FESS_USER":"$FESS_GROUP" "$PID_DIR"
	fi
	if [ -n "$PID_FILE" ] && [ ! -e "$PID_FILE" ]; then

        class3.isFile()
        file(compiledFile).isFile()

        when:
        run("clean")
        withBuildCache().run(compilationTask)
        then:
        skipped(compilationTask)

        when:
        assert source3.delete()
        withBuildCache().run(compilationTask)
        then: 'Gradle cleans up the stale class file'
        executedAndNotSkipped(compilationTask)
        class1.exists()

                    res.addEdge(sourceV, newV, edge);
                }
            }
            // System.err.println("Original graph("+graph.getVertices().size()+"):\n"+graph.toString());
            // System.err.println("Cleaned("+requestedScope+") graph("+res.getVertices().size()+"):\n"+res.toString());
            // System.err.println("Linked("+requestedScope+")
            // subgraph("+linkedRes.getVertices().size()+"):\n"+linkedRes.toString());

			return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
		}

		return mux.handler(r.Host, r.URL.Path)
	}

	// All other requests have any port stripped and path cleaned
	// before passing to mux.handler.
	host := stripHostPort(r.Host)
	path := cleanPath(r.URL.Path)

	// If the given path is /tree and its handler is not registered,
	// redirect for /tree/.

				retry.UntilSuccessOrFail(t, func() error {
					entries := getWorkloadEntriesOrFail(t, autoVM)
					if len(entries) != 1 || entries[0].UID != initialWLE.UID {
						t.Fatalf("WorkloadEntry was cleaned up unexpectedly")
					}

					currentPilot := entries[0].Annotations[annotation.IoIstioWorkloadController.Name]
					if currentPilot == initialPilot || !strings.HasPrefix(currentPilot, "istiod-") {

            }
        });
    }

    /**
     * Creates the file to hold the options for the scaladoc process.
     *
     * @implNote This file will be cleaned up by {@link GenerateScaladoc#execute()}.
     */
    @Nullable
    private File createOptionsFile() {
        return new File(getTemporaryDir(), "scaladoc.options");
    }

    @Inject