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

/**
 * An action that cleans up some resource and reports to a {@link CleanupProgressMonitor}.
 */
public interface MonitoredCleanupAction extends Describable {
    /**
     * Perform the cleanup action, returning true if any resources were actually cleaned up.
     *
     * @param progressMonitor
     * @return true if resources were cleaned
     */

/**
 * 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.
         */

		// be at a higher level of the hierarchy, and so when we append the key prefix we will end up with
		// continue start key that is fully qualified and cannot range over anything less specific than
		// keyPrefix.
		key := c.StartKey
		if !strings.HasPrefix(key, "/") {
			key = "/" + key
		}
		cleaned := path.Clean(key)
		if cleaned != key {

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

			return s[:i]
		}
		if p == '。' || p == '．' {
			return s[:i]
		}
		ppp, pp, p = pp, p, q
	}
	return s
}

// Synopsis returns a cleaned version of the first sentence in text.
//
// Deprecated: New programs should use [Package.Synopsis] instead,
// which handles links in text properly.
func Synopsis(text string) string {
	var p Package

			ttl:          pointer.Int32(100),
			since:        &now.Time,
			expectErr:    true,
			expectErrStr: "should not be cleaned up",
		},
		{
			name:           "Error case: Job completed now, no TTL",
			completionTime: now,
			since:          &now.Time,
			expectErr:      true,
			expectErrStr:   "should not be cleaned up",
		},
		{
			name:             "Job completed now, 0s TTL",
			completionTime:   now,

    vcs.useAbsoluteVcs(VersionedSettingsBranch.fromDslContext().vcsRootId())

    features {
        freeDiskSpace {
            // Lower the limit such that the agent work directories aren't cleaned during the AMI baking process
            requiredSpace = "100mb"
        }
    }

    params {
        param("defaultBranchName", "master")
        param("env.JAVA_HOME", javaHome(BuildToolBuildJvm, Os.LINUX))