Help:      "Latencies in seconds of value transformation operations.",
			// In-process transformations (ex. AES CBC) complete on the order of 20 microseconds. However, when
			// external KMS is involved latencies may climb into hundreds of milliseconds.
			Buckets:        metrics.ExponentialBuckets(5e-6, 2, 25),
			StabilityLevel: metrics.ALPHA,
		},
		[]string{"transformation_type", "transformer_prefix"},
	)

        // A better solution for output files would be to record the type of the output file and then using this type here instead of looking at the disk.
        // Though that is more involved and as soon as the file has been produced, the right file type will be detected here as well.
        boolean elementIsFile = !element.isDirectory();

        // This gradleApi() method creates a Gradle API classpath based on real jars for embedded test running.
        // Currently, this leaks additional dependencies that may cause unexpected issues.
        // This method is involved in generating the gradleApi() Jar which is used in a real Gradle run.
        // See: `org.gradle.api.internal.notations.DependencyClassPathNotationConverter`
        ClassPath classpath = ClassPath.EMPTY;

	// user
	UserLimitType LimitType = "User"
	// SourceAndObjectLimitType is a type of limit where there is one bucket used
	// by each combination of source and involved object of the event.
	SourceAndObjectLimitType LimitType = "SourceAndObject"
)

// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

env GO111MODULE=on
env GOFLAGS=-mod=mod
[short] skip

# golang.org/issue/30166: 'go mod tidy' should not crash if a replaced module is
# involved in a cycle.
cd cycle
env GOTRACEBACK=off
go mod tidy
cd ..

# From inside the module, 'go list -m all' should NOT include transitive
# requirements of modules that have been replaced.
go list -m all
stdout 'rsc.io/quote/v3 v3.0.0'
! stdout 'rsc.io/sampler'
! stdout 'golang.org/x/text'

        evaluateInBlock()  | evaluateInLambda()
        evaluateInLambda() | evaluateInBlock()
    }

    def "re-evaluating the owner in #evaluator throws exception when intermediate owner is involved"() {
        def otherOwner = createOwner()

        when:
        evaluator.apply(owner) {
            evaluator.apply(otherOwner) {
                evaluator.apply(this.owner) {}
            }
        }

// Context passed to [Log] and [WithRegion].
//
// For example, assume that we decided to froth milk, extract coffee,
// and mix milk and coffee in separate goroutines. With a task,
// the trace tool can identify the goroutines involved in a specific
// cappuccino order.
//
//	ctx, task := trace.NewTask(ctx, "makeCappuccino")
//	trace.Log(ctx, "orderID", orderID)
//
//	milk := make(chan bool)
//	espresso := make(chan bool)
//
//	go func() {

//	 HTTP request was initially issued by one origin but then later
//	 redirected by another origin, the user agent MAY inform the server
//	 that two origins were involved in causing the user agent to issue the
//	 request
//			origin-list = serialized-origin *( SP serialized-origin )
func isOriginAllowed(originHeader string, allowedOriginPatternsREs []*regexp.Regexp) bool {

// [Named.Obj] methods return the same [TypeName] symbol.
// A collection of symbols is consistent if, for each logical
// package whose path is P, the creation of those symbols
// involved at most one call to [NewPackage](P, ...).
// To ensure consistency, use a single [Importer] for
// all loaded packages and their dependencies.
// For more information, see https://github.com/golang/go/issues/57497.

    }

    /**
     * Exclude of transitive dependency involved in a dependency cycle.
     *
     * Dependency graph:
     * a -> b -> c -> d -> c
     *
     * 'c' is excluded on dependency a->b
     */
    def "can excluded module involved in dependency cycle"() {
        given:
        repository {
            'a:a:1.0' {