<property name="maven.release.repo.url" value="https://oss.sonatype.org/content/repositories/releases" />

	<target name="install.plugins">
		<mkdir dir="${target.dir}" />
		<delete dir="${plugins.dir}" />
		<mkdir dir="${plugins.dir}" />
		<!-- analysis-extension -->
		<antcall target="install.plugin">
			<param name="repo.url" value="${maven.release.repo.url}" />

    --add-secondary-ranges="pods-default=${CLUSTER_IP_RANGE},services-default=${SERVICE_CLUSTER_IP_RANGE}"; do
    printf "."
    sleep 1
  done
}

# Delete all K8s node routes.
#
# Assumed vars:
#   PROJECT
function delete-k8s-node-routes() {
  local -a routes
  local -r batch=200
  routes=()
  while IFS=$'\n' read -r route; do
    routes+=( "${route}" )

		Into(result)
	return
}

// Delete takes name of the example and deletes it. Returns an error if one occurs.
func (c *examples) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
	return c.client.Delete().
		Namespace(c.ns).
		Resource("examples").
		Name(name).
		Body(&opts).
		Do(ctx).
		Error()
}

// DeleteCollection deletes a collection of objects.

        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 {