when:
        a.text = "@Helper class A { public String bar() { return 0; } }"
        runAndFail "compileJava", "-d"

        then:
        outputs.noneRecompiled()
        outputContains("Deleting generated files: [${file("build/classes/java/main/AHelperResource.txt")}, " +
            "${file("build/generated/sources/annotationProcessor/java/main/AHelper.java")}]"
        )

        when:
        a.text = "@Service class A { public String foo() { return 0; } }"
        runAndFail "compileJava", "-d"

        then:
        outputs.noneRecompiled()
        outputContains("Deleting generated files: [${file("build/classes/java/main/ServiceRegistryResource.txt")}, " +
            "${file("build/generated/sources/annotationProcessor/java/main/ServiceRegistry.java")}]")

		if err := os.Remove(fullContainerDirPath); err != nil {
			return fmt.Errorf("error deleting %s: %s", fullContainerDirPath, err)
		}
		klog.V(5).Infof("Removed %s", fullContainerDirPath)
	}
	// Whole pod volume subpaths have been cleaned up, remove its subpath directory.
	if err := os.Remove(subPathDir); err != nil {
		return fmt.Errorf("error deleting %s: %s", subPathDir, err)
	}
	klog.V(5).Infof("Removed %s", subPathDir)

func (h *FakeNetlinkHandle) DeleteDummyDevice(devName string) error {
	if len(devName) == 0 {
		return fmt.Errorf("device name can't be empty")
	}
	if _, ok := h.localAddresses[devName]; !ok {
		return fmt.Errorf("error deleting a non-exist interface: %s", devName)
	}
	delete(h.localAddresses, devName)
	return nil
}

// ListBindAddress is a mock implementation

func (h *netlinkHandle) DeleteDummyDevice(devName string) error {
	link, err := h.LinkByName(devName)
	if err != nil {
		_, ok := err.(netlink.LinkNotFoundError)
		if ok {
			return nil
		}
		return fmt.Errorf("error deleting a non-exist dummy device: %s, %v", devName, err)
	}
	dummy, ok := link.(*netlink.Dummy)
	if !ok {
		return fmt.Errorf("expect dummy device, got device type: %s", link.Type())
	}
	return h.LinkDel(dummy)
}

  // a trainable dtype.
  bool ShouldRecord(
      absl::Span<const AbstractTensorHandle* const> tensors) const;
  // Unwatches this tensor on the tape. Mainly used for cleanup when deleting
  // eager tensors.
  void DeleteTrace(const AbstractTensorHandle*);

  // Consumes the internal state of the tape (so cannot be called more than

}

// cleanup removes redundant and outdated entries.
func (b *bucketMetacache) cleanup() {
	// Entries to remove.
	remove := make(map[string]struct{})

	// Test on a copy
	// cleanup is the only one deleting caches.
	caches, _ := b.cloneCaches()

	for id, cache := range caches {
		if !cache.worthKeeping() {
			b.debugf("cache %s not worth keeping", id)
			remove[id] = struct{}{}
			continue
		}

		return NewEmptyManaged(), nil
	}

	// If the managed field is empty or we failed to decode it,
	// let's try the live object. This is to prevent clients who
	// don't understand managedFields from deleting it accidentally.
	managed, err := DecodeManagedFields(newAccessor.GetManagedFields())
	if err != nil || len(managed.Fields()) == 0 {
		return emptyManagedFieldsOnErr(DecodeManagedFields(liveAccessor.GetManagedFields()))
	}

	schema.GroupVersionKind

	kubeClient clientset.Interface
	podControl controller.PodControlInterface

	eventBroadcaster record.EventBroadcaster

	// A ReplicaSet is temporarily suspended after creating/deleting these many replicas.
	// It resumes normal action after observing the watch events for them.
	burstReplicas int
	// To allow injection of syncReplicaSet for testing.
	syncHandler func(ctx context.Context, rsKey string) error

      op.getResult(0).replaceAllUsesWith(
          block.addArgument(resource_type, op.getLoc()));
      AddEntryFunctionInput(
          absl::StrCat("hash_table_", it.first->getValue(), ":0"), target_func);
      // Avoid deleting the op here, clone it to the caller function first.
      lifted_op_and_arg_idx.emplace_back(&op, it.first->getValue());
    } else {
      op.getResult(0).replaceAllUsesWith(