//
// For example, given apps a, b, and c in 2 clusters,
// these tests would all run before the context is cleaned up:
//   - a/to_b/from_cluster-1
//   - a/to_b/from_cluster-2
//   - a/to_c/from_cluster-1
//   - a/to_c/from_cluster-2
//   - cleanup...
//   - b/to_a/from_cluster-1
//     ...
func (t *T) Setup(setupFn srcSetupFn) *T {

		var myMountPoints []string  // mount points that match name
		for _, vol := range container.VolumeMounts {
			cleaned := filepath.Clean(vol.MountPath)
			allMountPoints = append(allMountPoints, cleaned)
			if vol.Name == name {
				myMountPoints = append(myMountPoints, cleaned)
			}
		}
		sort.Strings(allMountPoints)
		parentPrefix := ".." + string(os.PathSeparator)

 */

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 "";

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 43950

releaseNotes:
- |
  **Fixed** WorkloadEntry resources never being cleaned up if multiple

	}
	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 (didWork) {
                LOGGER.info("Cleaned previous output of {} as it has no source files.", work.getDisplayName());
                skipOutcome = ExecutionOutcome.EXECUTED_NON_INCREMENTALLY;
                executionReason = "Cleaned previous output";
            } else {
                skipOutcome = ExecutionOutcome.SHORT_CIRCUITED;
            }

# Test a replacement with an absolute path (so the path isn't
# cleaned by having filepath.Abs called on it). This checks
# whether the modindex logic cleans the modroot path before using
# it.

[!GOOS:windows] skip
[short] skip

go run print_go_mod.go # use this program to write a go.mod with an absolute path
cp stdout go.mod

go list -modfile=go.mod all
-- print_go_mod.go --
//go:build ignore
package main

import (
    "fmt"

 * limitations under the License.
 */

package org.gradle.cache;

/**
 * A cache entity that can be cleaned on demand.
 */
public interface HasCleanupAction {
    /**
     * Cleans up the cache, if any cleanup action has been provided.
     */
    void cleanup();

        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