result.assertTaskExecuted(":hello")
        executer.stop()

        when:
        // Delete important file in distribution
        boolean deletedSomething = false
        gradleUserHome.eachFileRecurse(FileType.FILES) { file ->
            if (file.name.startsWith("gradle-launcher")) {
                Files.delete(file.toPath())
                println("Deleting " + file)
                deletedSomething = true
            }

		t.Fatal(err)
	}
}

func (c *configPlan) Delete() error {
	// Delete for each namespace concurrently.
	g, _ := errgroup.WithContext(context.TODO())
	for ns, y := range c.yamlText {
		ns, y := ns, y
		g.Go(func() error {
			return c.deleteYAML(ns, y...)
		})
	}

	// Wait for all each delete to complete.
	return g.Wait()
}

        when:
        configurationCacheRun(":help", "--profile")

        then:
        configurationCache.assertStateStored()
        def report = findReport()

        and:
        report.delete()

        when:
        configurationCacheRun(":help", "--profile")

        then:
        configurationCache.assertStateLoaded()
        findReport()
    }

	}
	return nil
}

func (m *realDeps) deleteIP(name string, ip netip.Addr, ipProto uint8) error {
	err := netlink.IpsetDel(name, &netlink.IPSetEntry{
		IP:       net.IP(ip.AsSlice()),
		Protocol: &ipProto,
	})
	if err != nil {
		return fmt.Errorf("failed to delete IP %s from ipset %s: %w", ip, name, err)
	}
	return nil
}

var errNoSuchPolicy = errors.New("Specified canned policy does not exist")

// error returned when policy to be deleted is in use.
var errPolicyInUse = errors.New("Specified policy is in use and cannot be deleted.")

// error returned when more than a single policy is specified when only one is
// expected.
var errTooManyPolicies = errors.New("Only a single policy may be specified here.")

  const xla::Shape shape_;
  tsl::AsyncValueRef<std::unique_ptr<se::Event>> done_event_;

  XlaHostSendDeviceContext(const XlaHostSendDeviceContext&) = delete;
  void operator=(const XlaHostSendDeviceContext&) = delete;
};

}  // namespace tensorflow

		return cniLog{}, false
	}
	if err := json.Unmarshal(raw["time"], &msg.Time); err != nil {
		log.Debugf("Failed to unmarshal CNI plugin log entry: %v", err)
		return cniLog{}, false
	}
	delete(raw, "msg")
	delete(raw, "level")
	delete(raw, "time")
	msg.Arbitrary = make(map[string]any, len(raw))
	for k, v := range raw {
		var res any
		if err := json.Unmarshal(v, &res); err != nil {

            file.also(onFileAccess).outputStream()

        override fun inputStream(): InputStream =
            throw UnsupportedOperationException()

        override fun delete() {
            if (file.exists()) {
                Files.delete(file.toPath())
            }
        }

        override fun moveFrom(file: File) {
            Files.move(file.toPath(), this.file.toPath(), StandardCopyOption.ATOMIC_MOVE)

         */
        File getCacheLocation();
    }

    /**
     * Sent after the cache has been cleaned up.
     */
    public interface Result {

        /**
         * The number of cache entries deleted during this clean up.
         */
        long getDeletedEntriesCount();

        /**
         * The timestamp the last cleanup was performed.
         */
        Instant getPreviousCleanupTime();
    }

		for _, dir := range dirsToClean {
			if err := CleanDir(dir); err != nil {
				klog.Warningf("[reset] Failed to delete contents of %q directory: %v", dir, err)
			}
		}
	} else {
		fmt.Printf("[reset] Would delete contents of directories: %v\n", dirsToClean)
	}

	filesToClean := []string{
		filepath.Join(configPathDir, kubeadmconstants.AdminKubeConfigFileName),