expect:
        succeeds "compileJava"
        file("build/generated-sources/TestAppHelper.java").text == 'class TestAppHelper {    String getValue() { return "greetings"; }}'
    }

    def "generated sources are cleaned up on full compilations"() {
        given:
        buildFile << """
            dependencies {
                compileOnly project(":annotation")
                annotationProcessor project(":processor")
            }

		},
	}
	lockPath14x, lockPath16x := getLockPaths()
	// the lockPath14x is a UNIX socket which is cleaned up automatically on close, but the
	// lockPath16x is a plain file which is not cleaned up.
	defer os.Remove(lockPath16x)
	runner := newInternal(fexec, ProtocolIPv4, lockPath14x, lockPath16x)

	err := runner.RestoreAll([]byte{}, NoFlushTables, RestoreCounters)

/**
 * Define clean up rules for the project.
 * See https://www.jetbrains.com/help/teamcity/teamcity-data-clean-up.html#Clean-up+Rules
 *
 * @param historyDays days number of days to store build history .
 * @param artifactsDays number of days to store artifacts. In the stored history, artifacts older than this number will be cleaned up.

func init() {
	// Register audit scheme to parse audit config.
	auditinstall.Install(auditpkg.Scheme)
}

func TestCreateMasterAuditPolicy(t *testing.T) {
	baseDir, err := os.MkdirTemp("", "configure-helper-test") // cleaned up by c.tearDown()
	require.NoError(t, err, "Failed to create temp directory")

	policyFile := filepath.Join(baseDir, "audit_policy.yaml")
	c := ManifestTestCase{
		t:                t,
		kubeHome:         baseDir,

        disableProblemsApiCheck()

        executer.cleanup()
        m2.cleanupState()

        // Verify that the test (or fixtures) has cleaned up state correctly
        m2.assertNoLeftoverState()
    }

    private void recreateExecuter() {
        if (executor != null) {
            executor.cleanup()
        }
        executor = null
    }

        dir.assertDoesNotExist()

        when:
        boolean didWork = deleter.deleteRecursively(dir)

        then:
        !didWork
    }

    def "didWork is false when nothing has been cleaned"() {
        given:
        TestFile emptyDir = tmpDir.getTestDirectory()

        when:
        boolean didWork = deleter.ensureEmptyDirectory(emptyDir)

        then:
        !didWork
    }

		return path
	default:
		return path[0 : len(path)-1] // chop off trailing separator
	}
}

// cleanGlobPathWindows is windows version of cleanGlobPath.
func cleanGlobPathWindows(path string) (prefixLen int, cleaned string) {
	vollen := filepathlite.VolumeNameLen(path)
	switch {
	case path == "":
		return 0, "."
	case vollen+1 == len(path) && os.IsPathSeparator(path[len(path)-1]): // /, \, C:\ and C:/

	if err != nil {
		return err
	}

	// Ignore the Jobs that are already deleted or being deleted, or the ones that don't need clean up.
	job, err := tc.jLister.Jobs(namespace).Get(name)

	logger := klog.FromContext(ctx)
	logger.V(4).Info("Checking if Job is ready for cleanup", "job", klog.KRef(namespace, name))

	if errors.IsNotFound(err) {
		return nil
	}
	if err != nil {
		return err
	}

					data.cfg.ControlPlane.LocalAPIEndpoint.BindPort != 1234 {
					t.Error("Invalid ControlPlane")
				}
			},
		},
		{
			name: "control plane setting are cleaned up if --control-plane flag is not set",
			flags: map[string]string{
				options.ControlPlane:              "false",
				options.APIServerAdvertiseAddress: "1.2.3.4",
				options.APIServerBindPort:         "1.2.3.4",

	// deleting cached results.
	RemovePod(pod *v1.Pod)

	// CleanupPods handles cleaning up pods which should no longer be running.
	// It takes a map of "desired pods" which should not be cleaned up.
	CleanupPods(desiredPods map[types.UID]sets.Empty)

	// UpdatePodStatus modifies the given PodStatus with the appropriate Ready state for each
	// container based on container running status, cached probe results and worker states.