}
	if len(list) != 3 {
		t.Errorf("Expect 2 virtual servers, got: %d", len(list))
	}
	// Delete a virtual server
	err = fake.DeleteVirtualServer(vs1)
	if err != nil {
		t.Errorf("Fail to delete virtual server: %v, error: %v", vs1, err)
	}
	// Check the deleted virtual server no longer exists
	got, _ := fake.GetVirtualServer(vs1)
	if got != nil {
		t.Errorf("Expect nil, got: %v", got)
	}

		labeled := m.labeledBySelecting[sObject.selectorKey]
		labeled.objects[labeledObject.key] = labeledObject
	}
}

// Delete removes a labeled object and incoming associations.
func (m *BiMultimap) Delete(key Key) {
	m.mux.Lock()
	defer m.mux.Unlock()
	m.delete(key)
}

func (m *BiMultimap) delete(key Key) {
	if _, ok := m.labeledObjects[key]; !ok {
		// Does not exist.
		return
	}

    private final Compiler<T> compiler;
    private final TaskOutputsInternal taskOutputs;
    private final Deleter deleter;

    public CleaningJavaCompiler(Compiler<T> compiler, TaskOutputsInternal taskOutputs, Deleter deleter) {
        this.compiler = compiler;
        this.taskOutputs = taskOutputs;
        this.deleter = deleter;
    }

    @Override
    public WorkResult execute(T spec) {

    def deleter = TestFiles.deleter()
    Predicate<File> fileSafeToDelete = Mock()
    Predicate<File> dirSafeToDelete = Mock()
    def cleaner = new OutputsCleaner(deleter, fileSafeToDelete, dirSafeToDelete)

    def "does not delete non-empty directories"() {
        def outputFiles = []

    hello world
    pod "dummy" deleted
    ```

    As you observe, sending _world_ on a TCP connection to the server results in
    the server prepending _hello_ and echoing back with _hello world_.

1. To clean up, execute the following command:

    ```console
    $ kubectl delete -f tcp-echo.yaml
    service "tcp-echo" deleted
    deployment.apps "tcp-echo" deleted

// ShortNames implements the ShortNamesProvider interface. Returns a list of short names for a resource.
func (r *REST) ShortNames() []string {
	return []string{"pc"}
}

// Delete ensures that system priority classes are not deleted.
func (r *REST) Delete(ctx context.Context, name string, deleteValidation rest.ValidateObjectFunc, options *metav1.DeleteOptions) (runtime.Object, bool, error) {
	for _, spc := range schedulingapiv1.SystemPriorityClasses() {

        cacheEntries[1].assertDoesNotExist()
        cacheEntries[2].assertExists()
        deletedFiles == [cacheEntries[1]]
    }

    def "can delete directories"() {
        given:
        def cacheEntry = cacheDir.file("subDir").createFile("somefile")
        cacheEntry.text = "delete me"

        when:
        cleanupAction(finder([cacheEntry.parentFile]), { true })
            .clean(cleanableStore, progressMonitor)

import javax.annotation.CheckForNull;

/**
 * Exception indicating that a recursive delete can't be performed because the file system does not
 * have the support necessary to guarantee that it is not vulnerable to race conditions that would
 * allow it to delete files and directories outside of the directory being deleted (i.e., {@link
 * SecureDirectoryStream} is not supported).
 *

import (
	"istio.io/istio/pkg/test"
	"istio.io/istio/pkg/test/framework/resource/config/apply"
)

// Plan for configuration that can be applied or deleted as an atomic unit.
// A Plan is initially created by a Factory, but then can continually be
// appended to before finally calling Apply or Delete.
type Plan interface {
	// Factory for appending to this Config.
	Factory

	// Copy returns a deep copy of this Plan.
	Copy() Plan

		if len(secret.UID) > 0 {
			options.Preconditions = &metav1.Preconditions{UID: &secret.UID}
		}
		err := tc.client.CoreV1().Secrets(secret.Namespace).Delete(ctx, secret.Name, options)
		// NotFound isn't a real error (it's already been deleted)
		// Conflict isn't a real error (the UID precondition failed)
		if err != nil && !apierrors.IsConflict(err) && !apierrors.IsNotFound(err) {