// Act
	dsw.DeletePod(types.UniquePodName(podName), generatedVolumeName, nodeName)
	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
	if volumeExists {
		t.Fatalf(
			"Deleted pod %q from volume %q/node %q. Volume should also be deleted but it still exists.",
			podName,
			generatedVolumeName,
			nodeName)
	}
	asw.SetVolumesMountedByNode(logger, []v1.UniqueVolumeName{generatedVolumeName}, nodeName)

				total1 := 0
				// Validate that empty namespace is deleted when all filters in that namespace are deleted.
				for ns, envoyFilters := range pc1.envoyFiltersByNamespace {
					total1 += len(envoyFilters)
					deleted := 0
					for _, ef := range envoyFilters {
						key := ConfigKey{Kind: kind.EnvoyFilter, Namespace: ns, Name: ef.Name}
						if deletes.Contains(key) {
							deleted++
						}
					}

        then:
        succeeds("echo")
        executedAndNotSkipped(":echo")
        output.contains("text: original")
        when: "symlink is deleted"
        symlink.delete()
        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":echo")
        output.contains("text: missing")
        when: "symlink is created"

				return nil
			},
		},
		{
			// deleteClaim with a bound claim makes bound volume released with external deleter.
			// delete the corresponding volume from apiserver, and report latency metric
			name: "5-5 - delete claim and delete volume report metric",
			initialVolumes: volumesWithAnnotation(volume.AnnDynamicallyProvisioned, "gcr.io/vendor-csi",

}

// DestroySet is part of interface.  It deletes both the entries and the set itself.
func (f *FakeIPSet) DestroySet(set string) error {
	delete(f.Sets, set)
	delete(f.Entries, set)
	return nil
}

// DestroyAllSets is part of interface.
func (f *FakeIPSet) DestroyAllSets() error {
	f.Sets = nil
	f.Entries = nil
	return nil
}

// CreateSet is part of interface.

    }

    def "classes files of generated sources are deleted when annotated file is deleted"() {
        given:
        def a = java "@Service class A {}"
        java "class Unrelated {}"

        outputs.snapshot { run "compileJava" }

        when:
        a.delete()
        run "compileJava"

        then:

	// syncSecretQueue handles secret events:
	//   * deletes tokens whose service account no longer exists
	//   * updates tokens with missing token or namespace data, or mismatched ca data
	//   * ensures service account secret references are removed for tokens which are deleted
	// key is a secretQueueKey{}
	syncSecretQueue workqueue.TypedRateLimitingInterface[secretQueueKey]

        !result.didWork
    }

    def deletes() {
        def fileToBeDeleted = tmpDir.file("file")
        def fileCollection = Stub(FileCollectionInternal)
        fileCollectionFactory.resolving(["file"] as Object[]) >> fileCollection
        fileCollection.iterator() >> [fileToBeDeleted].iterator()
        fileToBeDeleted.touch()

        expect:
        fileOperations.delete('file') == true

	// system. If it's not a valid resource, the garbage collector should i)
	// ignore the reference when decide if the object should be deleted, and
	// ii) should update the object to remove such references. This is to
	// prevent objects having references to an old resource from being
	// deleted during a cluster upgrade.
	resource, namespaced, err := gc.apiResource(reference.APIVersion, reference.Kind)
	if err != nil {

    private final Deleter deleter;
    private final OutputChangeListener outputChangeListener;
    private final Step<? super C, ? extends R> delegate;

    public RemovePreviousOutputsStep(
        Deleter deleter,
        OutputChangeListener outputChangeListener,
        Step<? super C, ? extends R> delegate
    ) {
        this.deleter = deleter;
        this.outputChangeListener = outputChangeListener;