)

    protected fun ignoreStabilityIfNeeded(directives: RegisteredDirectives, body: () -> Unit) {
        val directive = directives.doNotCheckSymbolRestoreDirective()
        val isStabilitySuppressed = directive != null && directives[directive].let { values ->
            values.isEmpty() || values.any { it == resolveKind }
        }

        try {
            body()

cp go.mod go.mod.orig

# For modules whose go.mod file does not include a 'go' directive,
# we assume the language and dependency semantics of Go 1.16,
# but do not trigger “automatic vendoring” mode (-mod=vendor),
# which was added in Go 1.14 and was not triggered
# under the same conditions in Go 1.16 (which would instead
# default to -mod=readonly when no 'go' directive is present).

# For Go 1.16 modules, 'all' should prune out dependencies of tests,

-------------------

The //go:uintptrkeepalive directive must be followed by a function declaration.

It specifies that the function's uintptr arguments may be pointer values that
have been converted to uintptr and must be kept alive for the duration of the
call, even though from the types alone it would appear that the object is no
longer needed during the call.

This directive is similar to //go:uintptrescapes, but it does not force

	fmt.Println("%v", "hi")                     // ERROR "Println call has possible Printf formatting directive %v"
	fmt.Println("%T", "hi")                     // ERROR "Println call has possible Printf formatting directive %T"
	fmt.Println("0.0%")                         // correct (trailing % couldn't be a formatting directive)

     */
    QUOTED,
    /**
     * An identifier that should be macro expanded. These appear in the body of a directive eg {@code #define HEADER ABC}.
     */
    MACRO,
    /**
     * A macro function invocation that should be expanded. These appear in the body of a directive and as arguments to another function eg {@code #define HEADER ABC(X, Y)}.
     */
    MACRO_FUNCTION,
    /**

 * limitations under the License.
 */
package org.gradle.api.internal.tasks.testing.testng;

import org.gradle.api.internal.tasks.testing.detection.AbstractTestFrameworkDetector;
import org.gradle.api.internal.tasks.testing.detection.ClassFileExtractionManager;

class TestNGDetector extends AbstractTestFrameworkDetector<TestNGTestClassDetector> {

    }

    def "reports download and detection options"() {
        given:
        defineJdks()
        toolchainConfiguration.isAutoDetectEnabled() >> false
        toolchainConfiguration.isDownloadEnabled() >> false

        when:
        task.showToolchains()

        then:
        outputProbe.value == """
{identifier} + Options{normal}
     | Auto-detection:     {description}Disabled{normal}

/**
 * Status of a feature in a build that affects Gradle behavior,
 * and may impose additional requirements on plugins or build scripts.
 * <p>
 * It is possible to check if the feature is {@link #getActive() active} in the current build.
 * The {@link #getRequested() requested} property shows whether the user opted in or opted out from the feature.
 *
 * @see BuildFeatures
 * @since 8.5
 */
@Incubating

			Description: `turn 'on' to set Strict-Transport-Security 'includeSubDomains' directive` + defaultHelpPostfix(browserHSTSIncludeSubdomains),
			Optional:    true,
			Type:        "boolean",
		},
		config.HelpKV{
			Key:         browserHSTSPreload,
			Description: `turn 'on' to set Strict-Transport-Security 'preload' directive` + defaultHelpPostfix(browserHSTSPreload),
			Optional:    true,
			Type:        "boolean",
		},

        }

        println("Determined baseline is: ${determinedBaselines.get()}")
    }

    /**
     * Coordinator build doesn't resolve to real commit version, they just pass "flakiness-detection-commit" as it is to worker build
     * "flakiness-detection-commit" is resolved to real commit id in worker build to disable build cache.
     *
     * @see PerformanceTest#NON_CACHEABLE_VERSIONS
     */
    private