klog.ErrorS(err, "Failed to parse a pod full name", "podFullName", podFullName)
		return false, err
	}

	var uidValue types.UID
	if uid != nil {
		uidValue = *uid
	}
	klog.V(2).InfoS("Deleting a mirror pod", "pod", klog.KRef(namespace, name), "podUID", uidValue)

	var GracePeriodSeconds int64

				{"ns1", "secret1", "pod1", 1},
				{"ns1", "secret1", "pod1", 0},
			},
		},
		{
			desc: "deleting a non-existent reference should have no effect",
			steps: []step{
				{"delete", "ns1", "secret1", "pod1"},
			},
			expects: []expect{
				{"ns1", "secret1", "pod1", 0},
			},
		},
		{
			desc: "deleting more than adding should not lead to negative refcount",
			steps: []step{

}

// resetConfigDir is used to cleanup the files in the folder defined in dirsToClean.
func resetConfigDir(configPathDir string, dirsToClean []string, isDryRun bool) {
	if !isDryRun {
		fmt.Printf("[reset] Deleting contents of directories: %v\n", dirsToClean)
		for _, dir := range dirsToClean {
			if err := CleanDir(dir); err != nil {
				klog.Warningf("[reset] Failed to delete contents of %q directory: %v", dir, err)
			}
		}

 * in CVE number once it's available.)
 *
 * <p>Temporary files created by this stream may live in the local filesystem until either:
 *
 * <ul>
 *   <li>{@link #reset} is called (removing the data in this stream and deleting the file), or...
 *   <li>this stream (or, more precisely, its {@link #asByteSource} view) is finalized during
 *       garbage collection, <strong>AND</strong> this stream was not constructed with {@linkplain

	DeletingPodsErrorTotal = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Subsystem:      podGCController,
			Name:           "force_delete_pod_errors_total",
			Help:           "Number of errors encountered when forcefully deleting the pods since the Pod GC Controller started.",
			StabilityLevel: metrics.ALPHA,
		},
		[]string{"namespace", "reason"},
	)
)

const (
	// Possible values for the "reason" label in the above metrics.

	logger := klog.FromContext(ctx)
	secret := o.(*v1.Secret)
	ttl, alreadyExpired := bootstrapsecretutil.GetExpiration(secret, time.Now())
	if alreadyExpired {
		logger.V(3).Info("Deleting expired secret", "secret", klog.KObj(secret))
		var options metav1.DeleteOptions
		if len(secret.UID) > 0 {
			options.Preconditions = &metav1.Preconditions{UID: &secret.UID}
		}

        this.usedGradleVersions = usedGradleVersions;
    }

    @Nonnull
    @Override
    public String getDisplayName() {
        return "Deleting unused Gradle distributions in " + distsDir;
    }

    @Override
    public boolean execute(@Nonnull CleanupProgressMonitor progressMonitor) {

// that targets the add and delete registry apis
// of the aggregate controller. It does so by
// creating a controller with a pseudo-random
// Options{} and create pseudo-random service
// registries and deleting them.
func FuzzAggregateController(data []byte) int {
	ops := map[int]string{
		0: "AddRegistry",
		1: "DeleteRegistry",
	}
	maxOps := 2
	f := fuzz.NewConsumer(data)
	opts := aggregate.Options{}

            objects.objectSummaries.each { S3ObjectSummary summary ->
                println "-- Deleting object ${summary.getKey()}"
                DeleteObjectRequest deleteObjectRequest = new DeleteObjectRequest(bucketName, summary.getKey())
                s3Client.amazonS3Client.deleteObject(deleteObjectRequest)
            }

            println("Deleting bucket: ${bucketName}")

	// Replace -> same as append

	// Delete
	if err := DB.Model(&users).Association("Account").Delete(&users[0].Account); err != nil {
		t.Errorf("no error should happened when deleting account, but got %v", err)
	}

	AssertAssociationCount(t, users, "Account", 2, "after delete")

	// Clear
	DB.Model(&users).Association("Account").Clear()