// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Linkname fastrand is allowed _for now_, as it has a
// linknamed definition, for legacy reason.
// NOTE: this may not be allowed in the future. Don't do this!

package main

import _ "unsafe"

//go:linkname fastrand runtime.fastrand
func fastrand() uint32

func main() {
	println(fastrand())

        succeeds()
    }

    // Documents actual behaviour for backwards compatibility, not necessarily desired behaviour
    @Requires(
        value = IntegTestPreconditions.NotIsolatedProjects,
        reason = "Exercises IP incompatible behavior: Groovy method inheritance"
    )
    def "inherited convention method is preferred over property with closure value"() {
        given:
        createDirs("child")

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Existing pull linknames in the wild are allowed _for now_,
// for legacy reason. Test a function and a method.
// NOTE: this may not be allowed in the future. Don't do this!

package main

import (
	_ "reflect"
	"unsafe"
)

//go:linkname noescape runtime.noescape

        if (expirationStatus == DO_NOT_EXPIRE) {
            return DaemonExpirationResult.NOT_TRIGGERED;
        }

        // We've encountered an unhealthy condition. Log if necessary.

        String reason = Joiner.on(" and ").join(reasons);
        if (shouldPrintLog(expirationStatus)) {

            String when = expirationStatus == GRACEFUL_EXPIRE ? "after the build" : "immediately";

import groovy.io.FileType
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions

import java.nio.file.Files

@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = NOT_EMBEDDED_REASON)
class WrapperIntegrationTest extends AbstractWrapperIntegrationSpec {
    def "can recover from a broken distribution"() {
        buildFile << "task hello"
        prepareWrapper()

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    @Requires(value = IntegTestPreconditions.NotParallelExecutor, reason = """
Don't run in parallel mode, as the expectation for the setup build are incorrect and running in parallel
does not really make any difference to the coverage
""")

 */

package org.gradle.integtests

import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions

@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = NOT_EMBEDDED_REASON)
class WrapperUpgradeIntegrationTest extends AbstractWrapperIntegrationSpec {

    def "can run the wrapper task when the build was started with the wrapper"() {
        given:
        prepareWrapper()

// StateTransition provides details about a StateTransition event.
type StateTransition struct {
	// Resource is the resource this state transition is for.
	Resource ResourceID

	// Reason is a human-readable reason for the state transition.
	Reason string

	// Stack is the stack trace of the resource making the state transition.
	//
	// This is distinct from the result (Event).Stack because it pertains to

import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.junit.Rule
import spock.lang.Issue

@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = NOT_EMBEDDED_REASON)
class WrapperConcurrentDownloadTest extends AbstractWrapperIntegrationSpec {
    @Rule BlockingHttpServer server = new BlockingHttpServer()

    def setup() {

    @KaAnalysisNonPublicApi
    override val errorMessage: String
        get() = withValidityAssertion { coneType.diagnostic.reason }

    @KaAnalysisNonPublicApi
    override val presentableText: String?
        get() = withValidityAssertion {
            when (val diagnostic = coneType.diagnostic) {