// to allow for quotation marks
	MaxDatetimeSizeJSON = 32
	// MinDurationSizeJSON
	// Golang allows a string of 0 to be parsed as a duration, so that plus 2 to account for
	// quotation marks makes 3
	MinDurationSizeJSON = 3
	// JSONDateSize is the size of a date serialized as part of a JSON object
	// RFC 3339 dates require YYYY-MM-DD, and then we add 2 to allow for quotation marks
	JSONDateSize = 12

				panic(err)
			}
			err = pprof.WriteHeapProfile(f)
			if err != nil {
				panic(err)
			}
			err = f.Close()
			if err != nil {
				panic(err)
			}
		}
	}
	m.marks = append(m.marks, m.curMark)
	m.curMark = nil
}

// shouldPProf returns true if we should be doing pprof runs.
func (m *Metrics) shouldPProf() bool {
	return m != nil && len(m.filebase) > 0
}

public interface BuildableComponentResolveResult extends ComponentResolveResult, ResourceAwareResolveResult {
    /**
     * Marks the component as resolved, with the given graph resolution state.
     */
    void resolved(ComponentGraphResolveState state, ComponentGraphSpecificResolveState graphState);

    /**
     * Marks the resolve as failed with the given exception.
     */

	func (c *B) Error(args ...any)

	// Errorf is equivalent to Logf() followed by Fail(). 
	func (c *B) Errorf(format string, args ...any)

	// Fail marks the function as having failed but continues ...
	func (c *B) Fail()

	// FailNow marks the function as having failed and stops its ...
	func (c *B) FailNow()

	// Failed reports whether the function has failed. 
	func (c *B) Failed() bool

    @Nullable
    ModuleVersionResolveException getFailure();

    /**
     * Marks the module version as resolved, with the given meta-data.
     */
    void resolved(T metaData);

    /**
     * Replaces the meta-data for this result. This result must already be resolved.
     */
    void setMetadata(T metaData);

    /**
     * Marks the resolve as failed with the given exception.
     */
    @Override

public interface BuildableComponentIdResolveResult extends ComponentIdResolveResult, ResourceAwareResolveResult {
    /**
     * Marks the component selector as resolved to the specified id.
     */
    void resolved(ComponentIdentifier id, ModuleVersionIdentifier moduleVersionIdentifier);

    /**
     * Marks the component selector as resolved to the specified id, but rejected.
     */

those guidelines, and the correct and incorrect usage examples, are particularly
helpful:
>Certain marks of The Linux Foundation have been created to enable you to
>communicate compatibility or interoperability of software or products. In
>addition to the requirement that any use of a mark to make an assertion of
>compatibility must, of course, be accurate, the use of these marks must
>avoid confusion regarding The Linux Foundation’s association with the

func (g *Graph) Topo() []string {
	topo := make([]string, 0, len(g.Nodes))
	marks := make(map[string]bool)

	var visit func(n string)
	visit = func(n string) {
		if marks[n] {
			return
		}
		for _, to := range g.Edges(n) {
			visit(to)
		}
		marks[n] = true
		topo = append(topo, n)
	}
	for _, root := range g.Nodes {
		visit(root)
	}

    def cache = new InMemoryDecoratedCache(target, CacheBuilder.newBuilder().build(), "id", new AtomicReference<FileLock.State>())

    def "does not produce value when present in memory and marks completed"() {
        def producer = Mock(Function)
        def completion = Mock(Runnable)

        given:
        cache.putLater("key", "value", Stub(Runnable))

        when:

#include "tensorflow/core/common_runtime/optimization_registry.h"

namespace tensorflow {

// The attribute that marks nodes to be grouped into functions by the
// encapsulate subgraphs pass.
extern const char* const kXlaClusterAttr;

// Marks a subset of nodes in the graph which are to be clustered
// with an attribute _XlaCluster=<cluster id> so they are picked up by the
// EncapsulateSubgraphsPass.