target, perControllerWork := wp.q.Pop(wp.currentlyWorking)

			if target == (Resource{}) {
				// continue or return?
				// could have been deleted, or could be no items in queue not currently worked on.  need a way to differentiate.
				wp.lock.Unlock()
				continue
			}
			wp.q.Delete(target)
			wp.currentlyWorking.Insert(convert(target))
			wp.lock.Unlock()
			// work should be done without holding the lock

	}
	// Delete tail.
	if err = h.Delete(mkHeapObj("bal", 31)); err != nil {
		t.Fatalf("Failed to delete tail.")
	}
	// Delete one of the items with value 30.
	if err = h.Delete(mkHeapObj("zab", 30)); err != nil {
		t.Fatalf("Failed to delete item.")
	}
	item, err = h.Pop()
	if e, a := 11, item.(testHeapObject).val; err != nil || a != e {
		t.Fatalf("expected %d, got %d", e, a)
	}
	item, err = h.Pop()

	c, ok := b.caches[id]
	if ok {
		// Delete from root map.
		list := b.cachesRoot[c.root]
		for i, lid := range list {
			if id == lid {
				list = append(list[:i], list[i+1:]...)
				break
			}
		}
		b.cachesRoot[c.root] = list
		delete(b.caches, id)
		b.updated = true
	}
	b.mu.Unlock()
	if ok {
		c.delete(context.Background())
	}

const deletionTimeout = 5 * time.Minute

func TestReconcileDelete(t *testing.T) {
	framework.
		NewTest(t).
		Run(func(t framework.TestContext) {
			// For positive casse, use minimal profile, iop file will be deleted
			t.NewSubTest("delete-iop-success").Run(func(t framework.TestContext) {
				istioCtl := istioctl.NewOrFail(t, t, istioctl.Config{})
				workDir, err := t.CreateTmpDirectory("operator-controller-test")
				if err != nil {

  WorkloadInfo workload_info = 2;
}

// Keep workload that we can't find in the fd cache. This can only be sent before SnapshotSent is sent
// to signal ztunnel to not delete the workload if it has it.
message KeepWorkload {
  string uid = 1;
}

// Delete a workload from the ztunnel. Ztunnel should shutdown the workload's proxy.
message DelWorkload {
  string uid = 2;
}

					// safely delete only the first item without
					// worrying about unshadowing a later one,
					// which might be a security problem.
					envs[i] = ""
				}
				break
			}
		}
	}
}

func Unsetenv(key string) error {
	envOnce.Do(copyenv)

	envLock.Lock()
	defer envLock.Unlock()

	if i, ok := env[key]; ok {
		envs[i] = ""
		delete(env, key)
	}
	runtimeUnsetenv(key)

            }
        }
        LOGGER.info("{} cleanup deleted {} files/directories.", cleanableStore.getDisplayName(), filesDeleted);
    }

    protected int deleteEmptyParentDirectories(File baseDir, File dir) {
        if (dir.equals(baseDir)) {
            return 0;
        }
        File[] files = dir.listFiles();
        if (files != null && files.length == 0 && dir.delete()) {
            handleDeletion(dir);

        }

        final List<Map<String, Object>> afterList = readJobLog(NAME_PREFIX);
        assertEquals(0, afterList.size()); // check if logs are successfully deleted
    }

    /**
     * Test for CrawlingInfo
     * */
    private void testReadCrawlingInfo() {
        final List<Map<String, Object>> logList = readCrawlingInfo(webConfigId);

			}
		}
	}

	// If the deleted pod doesn't use any host ports, it doesn't make the target pod schedulable.
	if len(usedPorts) == 0 {
		return framework.QueueSkip, nil
	}

	// Construct a fake NodeInfo that only has the deleted Pod.
	// If we can schedule `pod` to this fake node, it means that `pod` and the deleted pod don't have any common port(s).

	m.Lock()
	defer m.Unlock()

	k := makeProxyKey(conn.Proxy())
	connections := m.byProxy[k]
	if connections == nil {
		return false
	}

	id := conn.ID()
	delete(connections, id)
	if len(connections) == 0 {
		delete(m.byProxy, k)
		return false
	}

	return true
}

// keys required to uniquely ID a single proxy
type proxyKey struct {
	Network   string
	IP        string