import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.junit.jupiter.api.Tag;

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Tag("fast")
public @interface Fast {

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.junit.jupiter.api.Tag;

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Tag("fast")
public @interface Fast {

parallel-task-fast.png...

        false             | MetadataFetchingCost.FAST      | MetadataFetchingCost.FAST
        false             | MetadataFetchingCost.EXPENSIVE | MetadataFetchingCost.FAST
        true              | MetadataFetchingCost.CHEAP     | MetadataFetchingCost.CHEAP
        true              | MetadataFetchingCost.FAST      | MetadataFetchingCost.FAST

// are function calls rather than intrinsics, since this prevents inlining
// of the sync fast paths. This test should be re-enabled once the problem
// is solved.

package foo

import (
	"sync"
)

var mutex *sync.Mutex

func small5() { // ERROR "can inline small5"
	// the Unlock fast path should be inlined
	mutex.Unlock() // ERROR "inlining call to sync\.\(\*Mutex\)\.Unlock"
}

        where:
        description       | taskList                   | buildConfig
        'failFast = true' | ['test']                   | 'test { failFast = true }'
        '--fail-fast'     | ['test', '--fail-fast']    | ''
    }

    def "ensure fail fast with forkEvery #forkEvery, maxWorkers #maxWorkers, omittedTests #testOmitted"() {
        given:
        buildFile.text = generator.initBuildFile(maxWorkers, forkEvery)

import org.junit.jupiter.api.Tag;

@Tag("fast")
public class SomeTestClass {
    @Test
    public void ok1() {
    }

    @Test
    public void ok2() {
    }
}
        """
        file("src/integTest/java/org/example/SomeIntegTestClass.java") << """
package org.example;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Tag;

@Tag("fast")
public class SomeIntegTestClass {
    @Test

// license that can be found in the LICENSE file.

package main

import (
	"flag"
	"os"
	"runtime"
	"testing"

	fast "./fast"
	slow "./slow"
)

var buf = make([]byte, 1048576)

func BenchmarkFastNonASCII(b *testing.B) {
	for i := 0; i < b.N; i++ {
		fast.NonASCII(buf, 0)
	}
}

func BenchmarkSlowNonASCII(b *testing.B) {
	for i := 0; i < b.N; i++ {
		slow.NonASCII(buf, 0)
	}
}

	os.WriteFile(tmp("importcfg"), []byte(importcfg), 0644)

	run("go", "tool", "compile", "-importcfg="+tmp("importcfg"), "-p=test/slow", "-N", "-o", tmp("test/slow.o"), "pkg.go")
	run("go", "tool", "compile", "-importcfg="+tmp("importcfg"), "-p=test/fast", "-o", tmp("test/fast.o"), "pkg.go")

     * even if it's cheap to tell it's missing. Use {@link #CHEAP} in that case.
     */
    FAST,
    /**
     * Can return metadata in a cheap way, or tell that it's missing in a cheap way. The difference with
     * {@link #FAST} is that we can use it for missing metadata.
     */
    CHEAP,
    /**