def afterExecutionState = result.afterExecutionOutputState

        then:
        afterExecutionState.get() == delegateAfterExecutionState

        0 * _
    }

    def "executes when change tracking is disabled"() {
        when:
        def result = step.execute(work, context)
        delegateResult.duration >> Duration.ofSeconds(1)

        then:
        _ * context.changes >> Optional.empty()

        <h2 class="mt-5 text-center text-2xl font-bold leading-9 tracking-tight text-gray-900">Sign in to BookInfo</h2>
    </div>
    <div class="mt-10 sm:mx-auto sm:w-full sm:max-w-sm">
      <form class="space-y-6" method="post" action='login' name="login_form">
        <div>

					"logging-api",
					"kotlin-dsl-plugins",
					"serialization",
					"toolchains-jvm-shared",
					"docs-asciidoctor-extensions-base",
					"internal-instrumentation-processor",
					"security",
					"input-tracking",
					"base-ide-plugins"
				]
			},
			{
				"parallelizationMethod":{
					"name":"TestDistribution"
				},
				"subprojects":[
					"testing-jvm",
					"worker-main",
					"files",

 *
 * <p>The implementation of the nested bean is tracked as an input, too.
 * This allows tracking behavior such as {@link org.gradle.api.Action}s as task inputs.</p>
 *

import javax.xml.parsers.DocumentBuilderFactory


/**
 * Fetch the latest Kotlin versions and write a properties file.
 * Never up-to-date, non-cacheable.
 */
@UntrackedTask(because = "Not worth tracking")
abstract class UpdateKotlinVersions : DefaultTask() {

    @get:Internal
    abstract val comment: Property<String>

    @get:Internal
    abstract val minimumSupported: Property<String>

    @get:Internal

        if (!targetProjectPath.equals(currentProjectPath)) {

            // TODO: We should relax this check. For legacy reasons we are not tracking cross-build project
            // dependencies, but we should be. Removing this condition breaks some Isolated Projects tests,
            // so we need to investigate why they are failing and then remove this condition.

	if latency <= threshold {
		return
	}

	// if we are tracking latency incurred inside different layers within
	// the apiserver, add these as annotation to the audit event object.
	layerLatencies := request.AuditAnnotationsFromLatencyTrackers(ctx)
	if len(layerLatencies) == 0 {
		// latency tracking is not enabled for this request
		return
	}

import org.jetbrains.kotlin.analysis.api.platform.KotlinPlatformComponent

/**
 * [KotlinModificationTrackerFactory] creates modification trackers for select modification events.
 *
 * Further modification tracking is implemented with a subscription-based mechanism via [KotlinModificationTopics]. Modification trackers make the most

            if (details == null) {
                throw new IllegalStateException("No details for " + buildOperation.getDisplayName() + ", which is required for proper result tracking");
            }
            results.put(details.getTaskIdentityPath(), result);
        }
    }

    @Override
    public AbstractTaskResult process(AbstractTaskResult taskResult, TaskInternal taskInternal) {

func (t *Transport) PutIdleTestConn(scheme, addr string) bool {
	c, _ := net.Pipe()
	key := connectMethodKey{"", scheme, addr, false}

	if t.MaxConnsPerHost > 0 {
		// Transport is tracking conns-per-host.
		// Increment connection count to account
		// for new persistConn created below.
		t.connsPerHostMu.Lock()
		if t.connsPerHost == nil {
			t.connsPerHost = make(map[connectMethodKey]int)
		}