expectedEvents:  noevents,
			errors:          noerrors,
			// Inject deleter into the controller and call syncVolume. The
			// deleter simulates one delete() call that succeeds.
			test: wrapTestWithReclaimCalls(operationDelete, []error{nil}, testSyncVolume),
		},
		{
			// PV requires external deleter
			name:            "8-10-1 - external deleter when volume is dynamic provisioning",

	echo DELETING "${x}"
	gcloud compute --project="${PROJECT}" firewall-rules delete "k8s-fw-${x}" -q
	gcloud compute --project="${PROJECT}" forwarding-rules delete "${x}" --region="${REGION}" -q
	gcloud compute --project="${PROJECT}" addresses delete "${x}" --region="${REGION}" -q
	gcloud compute --project="${PROJECT}" target-pools delete "${x}" --region="${REGION}" -q
        result=1
    fi
done

import org.gradle.internal.file.Deleter
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification

class StaleOutputCleanerTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    Deleter deleter = TestFiles.deleter()

    def "deletes all previous output files"() {

        when:
        delete.delete(file)
        execute(delete)

        then:
        delete.getDidWork()
        !file.exists()
    }

    def "did work is false when nothing gets deleted"() {
        when:
        delete.delete("does-not-exist")
        execute(delete)

        then:
        !delete.getDidWork()
    }

    def "get target files and multiple targets"() {
        when:

<section>
    <section>
        <title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr><td>delete</td></tr>
            <tr><td>targetFiles</td></tr>
            <tr><td>followSymlinks</td></tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>

case of versioned deletes a.k.a permanent delete of a version by doing a `mc rm --version-id` on a object, replication implementation marks a object version permanently deleted as `PENDING` purge and deletes the version from source after syncing to the target and ensuring target version is deleted. The delete marker being deleted or object version being deleted will still be visible on listing with `mc ls --versions` until the sync is completed. Objects marked as deleted will not be accessible via `GET`...

    private final Predicate<File> fileSafeToDelete;
    private final Predicate<File> dirSafeToDelete;

    private boolean didWork;

    public OutputsCleaner(Deleter deleter, Predicate<File> fileSafeToDelete, Predicate<File> dirSafeToDelete) {
        this.deleter = deleter;
        this.fileSafeToDelete = fileSafeToDelete;
        this.dirSafeToDelete = dirSafeToDelete;

        files[1].assertDoesNotExist()

        and: // deletes empty parent directories
        findFiles(cacheDir, 'resources-*/*').isEmpty()
        findFiles(cacheDir, 'files-*/*').isEmpty()
    }

    @ToBeFixedForConfigurationCache(because = "does not re-download missing artifacts")
    def "downloads deleted files again when they are referenced"() {
        given:

				i.mu.Unlock()
				return
			}
			if n.isEntry {
				// What we saw is still true, so we can continue with the delete.
				break
			}
		}
		// We have to start over.
		i.mu.Unlock()
	}
	// Try to delete the entry.
	e, deleted := n.entry().compareAndDelete(key, old, ht.keyEqual, ht.valEqual)
	if !deleted {

	sotwRes model.Resources,
	deltaRes model.Resources,
	deleted model.DeletedResources,
	usedDelta bool,
	delta model.ResourceDelta,
	incremental bool,
) {
	current := con.proxy.GetWatchedResource(w.TypeUrl).LastResources
	if current == nil {
		log.Debugf("ADS:%s: resources initialized", v3.GetShortType(w.TypeUrl))
		return
	}
	if deltaRes == nil && deleted == nil && len(sotwRes) == 0 {