ctx1, t1 := trace.NewTask(ctx0, "type1")

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}
	t1.End()

	// Create a task that starts during the trace and ends after.
	ctx2, t2 := trace.NewTask(ctx0, "type2")

	// Create a task that starts and ends during the trace.

 * guaranteed to execute. There is no guarantee, however, that listeners will be executed in the
 * order that they are added.
 *
 * <p>Exceptions thrown by a listener will be propagated up to the executor. Any exception thrown
 * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException} or an exception
 * thrown by {@linkplain MoreExecutors#directExecutor direct execution}) will be caught and logged.
 *
 * @author Nishant Thakkar

    /**
     * Sets whether directories should be considered during up-to-date checks and build cache key calculations.  Defaults to false.
     *
     * See {@link #ignoreEmptyDirectories()}.
     *
     * @since 6.8
     */
    TaskInputFilePropertyBuilder ignoreEmptyDirectories(boolean ignoreEmptyDirectories);

    /**

	a, b int
}

func main() {
	debug.SetGCPercent(1)
	for i := 0; i < 100000; i++ {
		m := make(map[*T]struct{}, 0)
		for j := 0; j < 20; j++ {
			// During the call to mapassign_fast64, the key argument
			// was incorrectly treated as a uint64. If the stack was
			// scanned during that call, the only pointer to k was
			// missed, leading to *k being collected prematurely.
			k := new(T)
			m[k] = struct{}{}
		}
	}

            resultHandler.finished()
        }

        then:
        configureWasCancelled(resultHandler, "Could not fetch model of type 'GradleProject' using")

        where:
        configureOnDemand << [true, false]
    }

    def "can cancel build action execution during settings phase"() {
        setupCancelInSettingsBuild()

        def cancel = GradleConnector.newCancellationTokenSource()

 */
package org.gradle.kotlin.dsl

import org.gradle.api.file.ContentFilterable

import java.io.FilterReader
import kotlin.reflect.KClass


/**
 * Adds a content filter to be used during the copy.
 * Multiple calls add additional filters to the filter chain.
 * Each filter should implement [FilterReader].
 * Import `org.apache.tools.ant.filters.*` for access to all the standard Ant filters.
 *
 * Examples:

	Reason string
	// a brief message why the pod should be evicted.
	Message string
}

// PodSyncHandler is invoked during each sync pod operation.
type PodSyncHandler interface {
	// ShouldEvict is invoked during each sync pod operation to determine
	// if the pod should be evicted from the kubelet.  If so, the pod status

    for misconfigured server first protocols rather than failing fast.

    This timeout has been disabled by default. This has the following impacts:

    - Non "server first" protocols will no longer have a risk of telemetry or traffic failures during slow connections

	// Check that this goroutine is still running on a different
	// thread.
	if mainTID != 0 && gettid() == mainTID {
		println("goroutine migrated to locked thread")
		os.Exit(1)
	}
	println("OK")
}

func LockOSThreadAlt() {
	// This is running locked to the main OS thread.

	var subTID int
	ready := make(chan bool, 1)
	go func() {
		// This goroutine must be running on a new thread.
		runtime.LockOSThread()

		t.Run(rt.name, func(t *testing.T) {
			_, _, _, actual := RunCmd(kubeadmPath, "join", rt.args, "--ignore-preflight-errors=all")
			if (actual == nil) != rt.expected {
				t.Errorf(
					"failed CmdJoinConfig running 'kubeadm join %s' with an error: %v\n\texpected: %t\n\t  actual: %t",
					rt.args,
					actual,
					rt.expected,
					(actual == nil),
				)
			}
			kubeadmReset()
		})
	}
}