} else {
                    cleaned.add(arg);
                }
            }
        }

        if (currentArg != null) {
            cleaned.add(currentArg.toString());
        }

        int cleanedSz = cleaned.size();

        String[] cleanArgs;

        if (cleanedSz == 0) {
            cleanArgs = args;
        } else {
            cleanArgs = cleaned.toArray(new String[0]);
        }

    def setup() {
        // Verify that the previous test cleaned up state correctly
        assert System.getProperty(StartParameterBuildOptions.ConfigurationCacheOption.PROPERTY_NAME) == null
        assert System.getProperty(StartParameterBuildOptions.IsolatedProjectsOption.PROPERTY_NAME) == null
        problems = new ConfigurationCacheProblemsFixture(testDirectory)
    }

    def cleanup() {

/**
 * Represents file-based store that can be cleaned by a {@link CleanupAction}.
 */
public interface CleanableStore {

    /**
     * Returns the base directory that should be cleaned for this store.
     */
    File getBaseDir();

    /**
     * Returns the files used by this store for internal tracking
     * which should be exempt from the cleanup.
     */
    Collection<File> getReservedCacheFiles();

    /**
     * Sent when the cache is cleaned up.
     */
    public interface Details {

        /**
         * Returns the location of the cache.
         */
        File getCacheLocation();
    }

    /**
     * Sent after the cache has been cleaned up.
     */
    public interface Result {

        /**
         * The number of cache entries deleted during this clean up.
         */

distinct from those stored in testdata directory; clean does not remove
those files.

For more about build flags, see 'go help build'.

For more about specifying packages, see 'go help packages'.
	`,
}

var (
	cleanI         bool // clean -i flag
	cleanR         bool // clean -r flag
	cleanCache     bool // clean -cache flag
	cleanFuzzcache bool // clean -fuzzcache flag
	cleanModcache  bool // clean -modcache flag

 */

package org.gradle.test.fixtures.file;

import java.lang.annotation.*;

/**
 * Declares that the test holds files open and therefore not to error if the test workspace can't be cleaned up.
 *
 * @see AbstractTestDirectoryProvider
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@Inherited
public @interface LeaksFileHandles {
    String value() default "";

	}
	req = &PushRequest{Start: zeroTime.Add(time.Duration(2))}
	// after adding an entry with the same key, previous indexes are correctly cleaned
	c.Add(secondEntry.Key(), secondEntry, req, res)

	assert.Equal(t, cache.store.Len(), 1)

	// Flush the cache and validate the index is cleaned.
	cache.Flush()
	assert.Equal(t, cache.indexLength(), 1)

	assert.Equal(t, cache.configIndexSnapshot(), map[ConfigHash]sets.Set[uint64]{

        if (!dir.exists()) {
            // Directory does not exist, nothing to clean up
            return Optional.empty();
        }

        if (!gcFile.exists()) {
            // If GC file hasn't been created, then this cache hasn't been used before.
            // We create the GC file, but there's nothing to clean up
            try {
                FileUtils.touch(gcFile);

		// TODO: getMountedVolumePathListFromDisk() call may be redundant with
		// kl.getPodVolumePathListFromDisk(). Can this be cleaned up?
		if podVolumesExist := kl.podVolumesExist(uid); podVolumesExist {
			errorPods++
			klog.V(3).InfoS("Orphaned pod found, but volumes are not cleaned up", "podUID", uid)
			continue
		}

		// Attempt to remove the pod volumes directory and its subdirs

import java.io.File;
import java.util.Set;

@ServiceScope(Scope.Build.class)
public interface BuildOutputCleanupRegistry {

    /**
     * Registers outputs to be cleaned up as {@link org.gradle.api.Project#files(Object...)}.
     */
    void registerOutputs(Object files);

    /**
     * Determines if an output file is owned by this build and therefore can be safely removed.
     *