}

    def "tracks time for getSupportedOptions()"() {
        when:
        def options = tracker.getSupportedOptions()

        then:
        1 * delegate.getSupportedOptions() >> {
            simulateWorkWithDuration(17)
            ['Option']
        }
        options == ['Option'] as Set
        result.executionTimeInMillis == 17
    }

    def "tracks time for getSupportedSourceVersion()"() {

	"k8s.io/component-base/metrics/legacyregistry"
)

// JobControllerSubsystem - subsystem name used for this controller.
const JobControllerSubsystem = "job_controller"

var (
	// JobSyncDurationSeconds tracks the latency of Job syncs. Possible label
	// values:
	//   completion_mode: Indexed, NonIndexed
	//   result:          success, error
	//   action:          reconciling, tracking, pods_created, pods_deleted

        ModelContainer<?> model,
        CalculatedValueContainerFactory calculatedValueContainerFactory
    );

    /**
     * A cache of the defined dependencies for dependency configurations. This tracks the cached internal
     * dependency representations for these types so when constructing leaf configuration metadata
     * (resolvable and consumable), these conversions do not need to be executed multiple times.
     */

	g1 := t.Generation(1)

	// A running goroutine emits a task begin.
	b1 := g1.Batch(trace.ThreadID(0), 0)
	b1.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
	b1.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
	b1.Event("UserTaskBegin", trace.TaskID(2), trace.TaskID(0) /* 0 means no parent, not background */, "my task", testgen.NoStack)

	g2 := t.Generation(2)

 * limitations under the License.
 */

package org.gradle.internal.file;

import java.io.File;

/**
 * Tracks access to files.
 */
public interface FileAccessTracker {
    /**
     * Marks the supplied file as accessed.
     *
     * If the supplied file is unknown to this tracker, implementations must
     * simply ignore it instead of throwing an exception. However, depending

    def coordinationService = Mock(ResourceLockCoordinationService)
    def container = Mock(ResourceLockContainer)
    def lock = new TestTrackedResourceLock("test", coordinationService, container)

    def "tracks the lock in the current resource lock state and calls provided actions"() {
        given:
        _ * coordinationService.current >> resourceLockState

        when:
        lock.tryLock()

        then:

import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
import org.jetbrains.kotlin.analysis.api.platform.KaEngineService

/**
 * [KaLifetimeTracker] is an *engine service* which tracks the current [KtLifetimeToken].
 *
 * It can be used in the implementation of custom lifetime tokens to check that the accessed token is in scope.
 */
public interface KaLifetimeTracker : KaEngineService {
    /**

import java.util.Collections;
import java.util.List;

/**
 * Tracks some state for build operations of a given type.
 */
public interface BuildOperationTracker {
    /**
     * Returns the trackers that are used by this tracker. If this tracker is required, then its trackers should be notified of
     * build operation execution. If this tracker is not required, the trackers can be ignored.
     */

import org.gradle.api.internal.tasks.TaskDependencyUsageTracker
import org.gradle.internal.configuration.problems.ProblemFactory
import org.gradle.internal.configuration.problems.ProblemsListener


/** Reports all usages of the tracked TaskDependency APIs as problems using the [problems] listener.

import com.google.common.base.Preconditions;
import org.gradle.internal.file.FileAccessTimeJournal;
import org.gradle.internal.file.FileAccessTracker;

import java.io.File;
import java.nio.file.Path;

/**
 * Tracks access to files and directories at the supplied depth within the supplied base
 * directory by setting their last access time in the supplied {@link FileAccessTimeJournal}.
 */
@SuppressWarnings("Since15")