For testing with the build cache, the build cache directory should be cleaned between tests.
The easiest way to accomplish this is to configure the local build cache to use a temporary directory.

=== Example: Clean build cache between tests

[source,groovy,indent=0]
.BuildLogicFunctionalTest.groovy
----

   *
   * <p>Expired entries may be counted in {@link Cache#size}, but will never be visible to read or
   * write operations. Expired entries are cleaned up as part of the routine maintenance described
   * in the class javadoc.
   *
   * @param duration the length of time after an entry is created that it should be automatically
   *     removed
   * @param unit the unit that {@code duration} is expressed in

        2                 | null                   | 2                | "configured period for build cache cleanup"
        null              | 2                      | 2                | "configured period for deprecated build cache cleanup"
        1                 | 10                     | 10               | "configured period for deprecated build cache cleanup when both are configured"
    }

                      On `master` branch, these two files are usually reset (cleaned up), unless you have special reasons not to do so.
                  </div>
                </div>
                </p>
                """.stripIndent()
        )
        return violation
    }

								},
							})
						})
					}
				})
			}

			// this runs in a separate test context - confirms the cluster local config was cleaned up
			t.NewSubTest("cross cluster").Run(func(t framework.TestContext) {
				for _, source := range sources {
					source := source
					t.NewSubTest(source.Config().Cluster.StableName()).Run(func(t framework.TestContext) {

		rc.cleanupMounts(volume)
	}

	klog.V(2).InfoS("Orphan volume cleanup finished")
	// Clean the cache, cleanup is one shot operation.
	rc.volumesFailedReconstruction = make([]podVolume, 0)
}

// updateReconstructedFromNodeStatus tries to file devicePaths of reconstructed volumes from

    def setup() {
        expectReindentedValidationMessage()

        // Must run on isolated daemons so that symlink data can be properly cleaned up between builds
        executer.requireDaemon()
        executer.requireIsolatedDaemons()

        buildFile << """
// This is a workaround to bust the JVM's file canonicalization cache
def f = file("delete-me")

		return false, nil
	}

	// Clean up unhealthy replicas first, otherwise unhealthy replicas will block deployment
	// and cause timeout. See https://github.com/kubernetes/kubernetes/issues/16737
	oldRSs, cleanupCount, err := dc.cleanupUnhealthyReplicas(ctx, oldRSs, deployment, maxScaledDown)
	if err != nil {
		return false, nil
	}
	logger.V(4).Info("Cleaned up unhealthy replicas from old RSes", "count", cleanupCount)

// TODO: this isn't structured very nicely. We have a port forwarder that can notify us when it fails (ErrChan) and we are competing with
// the pod informer which is sequenced via mutex. This could probably be cleaned up to be more event driven, but would require larger refactoring.
func watchPortForward(cfg workloadConfig, w *workload) {
	t := time.NewTicker(time.Millisecond * 500)
	handler := func() {
		w.mutex.Lock()

	}
	defer os.RemoveAll(dir) // clean up

	file := filepath.Join(dir, "tmpfile")
	if err := os.WriteFile(file, []byte("content"), 0666); err != nil {
		log.Fatal(err)
	}
}

func ExampleMkdirTemp_suffix() {
	logsDir, err := os.MkdirTemp("", "*-logs")
	if err != nil {
		log.Fatal(err)
	}
	defer os.RemoveAll(logsDir) // clean up

	// Logs can be cleaned out earlier if needed by searching