import javax.annotation.Nullable;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.function.Consumer;

/**
 * A {@link DirectorySnapshotBuilder} that tracks whether a directory has been filtered.
 *
 * You can mark a directory as filtered by {@link #markCurrentLevelAsFiltered()}.
 * When you do that, all the parent levels are marked as filtered as well.

        }
    }

    @Subject AbstractCachedIndex<String, CachedItem> cachedIndex = new AbstractCachedIndex(CACHE_NAME, STRING_SERIALIZER, valueSerializer, cacheAccessCoordinator, fileAccessTracker) {}

    def "tracks access to looked up files"() {
        given:
        def cachedFile = temporaryFolder.createFile("foo.txt")

        when:
        cachedIndex.storeInternal("foo", cachedItem(cachedFile))

	if *v == nil {
		*v = []string{}
	}
	return err
}

func (v *StringsFlag) String() string {
	return "<StringsFlag>"
}

// explicitStringFlag is like a regular string flag, but it also tracks whether
// the string was set explicitly to a non-empty value.
type explicitStringFlag struct {
	value    *string
	explicit *bool
}

func (f explicitStringFlag) String() string {
	if f.value == nil {

	connections := m.byProxy[k]
	if connections == nil {
		connections = make(map[string]connection)
		m.byProxy[k] = connections
	}
	connections[conn.ID()] = conn
}

// Disconnect tracks disconnect events of ads clients.
// Returns false once there are no more connections for the given proxy.
func (m *adsConnections) Disconnect(conn connection) bool {
	m.Lock()
	defer m.Unlock()

        1 * userCodeContext.current() >> Mock(UserCodeApplicationContext.Application) {
            getSource() >> currentSource
        }
    }

    void assertIsCallerStackTrace(List<StackTraceElement> trace) {
        assert trace.any { it.className == DefaultProblemDiagnosticsFactoryTest.name }
    }

See [Gradle runtimes](runtimes.md) for a list of these runtimes and more details.

## Build state model

As Gradle executes, it acts on various pieces of the build definition, such as each project in the build.
Gradle tracks the state of each piece and transitions each piece through its lifecycle as the build runs.

#include <cstdint>
#include <string>

#include "tensorflow/compiler/jit/xla_compile_util.h"
#include "tensorflow/core/framework/attr_value.pb.h"

namespace tensorflow {

// Tracks statistics for device compilation and uses these to determine whether
// the given cluster should be compiled or not.
class DeviceCompilationProfiler : public ResourceBase {
 public:
  DeviceCompilationProfiler() = default;

import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.file.FileSystemOperations;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.OutputDirectory;
import org.gradle.api.tasks.TaskAction;
import org.gradle.api.tasks.UntrackedTask;
import org.gradle.process.ExecOperations;
import org.gradle.process.ExecResult;

import javax.inject.Inject;

	"istio.io/istio/pkg/test/util/yml"
)

// Context is the core context interface that is used by resources.
type Context interface {
	yml.FileWriter

	// TrackResource tracks a resource in this context. If the context is closed, then the resource will be
	// cleaned up.
	TrackResource(r Resource) ID

	// GetResource accepts either a *T or *[]*T where T implements Resource.

        then:
        op1.operationId.id == 1L
        op1.parent == null
        op2.operationId.id == 2L
        op2.parent == null
    }

    def "tracks progress"() {
        when:
        ops.start("Building", null, new OperationIdentifier(1), null)
        def op2 = ops.start("Resolving", null, new OperationIdentifier(2), new OperationIdentifier(1))