operatingSystem "osx"
        }
        macosx64 {
            architecture "x64"
            operatingSystem "osx"
        }

        linux64 {
            architecture "x64"
            operatingSystem "linux"
        }
    }
    binaries {
        all {
            cCompiler.define "SOMETHING1=0"
            cCompiler.define "SOMETHING2=0"
            cCompiler.define "SOMETHING3=0"

        jansiLibrary.resourcePath ==  "/META-INF/native/" + jansiLibrary.path

        where:
        platform << ['linux32', 'linux64']
    }

    def "jansi library can be created for Windows platform #platform"() {
        when:
        JansiLibrary jansiLibrary = factory.create()

        then:
        1 * resolver.operatingSystem >> JansiOperatingSystemSupport.WINDOWS.identifier
        1 * resolver.platform >> platform

            }
            withoutDefaultVariants()
            withVariant("linux64") {
                attribute(Usage.USAGE_ATTRIBUTE.name, "linux64")
                attribute(Category.CATEGORY_ATTRIBUTE.name, Category.LIBRARY)
                useDefaultArtifacts = false
                artifact("foo.klib", "foo-linux64-1.0.klib")
            }
        }.withModuleMetadata().publish()
        buildFile << """

        def windows1 = factory.windows
        def windows2 = factory.windows
        def linux1 = factory.linux.x86_64
        def linux2 = factory.linux.x86_64

        expect:
        def targetMachines = [windows1, windows2, linux1, linux2] as Set
        targetMachines.size() == 2
        targetMachines == [windows1, linux1] as Set
    }

    def "same target machine are equals"() {
        expect:

#include "platform.h"

const char* platform_name = "Linux";

int max_path_length() { return -1; }

unsigned long long max_memory() { return TB(128); }

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

//go:build linux && s390x

package runtime

const (
	// vdsoArrayMax is the byte-size of a maximally sized array on this architecture.
	// See cmd/compile/internal/s390x/galign.go arch.MAXWIDTH initialization.
	vdsoArrayMax = 1<<50 - 1
)

var vdsoLinuxVersion = vdsoVersionKey{"LINUX_2.6.29", 0x75fcbb9}

var vdsoSymbolKeys = []vdsoSymbolKey{

TARGET_OUT="${TARGET_OUT:-$(pwd)/out/${TARGET_OS}_${TARGET_ARCH}}"
TARGET_OUT_LINUX="${TARGET_OUT_LINUX:-$(pwd)/out/linux_${TARGET_ARCH}}"

CONTAINER_TARGET_OUT="${CONTAINER_TARGET_OUT:-/work/out/${TARGET_OS}_${TARGET_ARCH}}"
CONTAINER_TARGET_OUT_LINUX="${CONTAINER_TARGET_OUT_LINUX:-/work/out/linux_${TARGET_ARCH}}"

IMG="${IMG:-${TOOLS_REGISTRY_PROVIDER}/${PROJECT_ID}/${IMAGE_NAME}:${IMAGE_VERSION}}"

env GOARCH=
# check -w doesn't allow invalid GOOS
! go env -w GOOS=linuxx
stderr 'unsupported GOOS/GOARCH pair linuxx'
# check -w doesn't allow invalid GOARCH
! go env -w GOARCH=amd644
stderr 'unsupported GOOS/GOARCH.*/amd644$'
# check -w doesn't allow invalid GOOS with valid GOARCH
! go env -w GOOS=linuxx GOARCH=amd64
stderr 'unsupported GOOS/GOARCH pair linuxx'
# check a valid GOOS and GOARCH values but an incompatible combinations

The XCTest Plugin provides the tasks, configurations and conventions for integrating with a https://developer.apple.com/documentation/xctest[XCTest testing framework on macOS] as well as https://github.com/apple/swift-corelibs-xctest[Linux's open source implementation].

[[sec:xctest_usage]]
== Usage

.Applying the XCTest Plugin
====
include::sample[dir="snippets/swift/swiftXCTest/kotlin",files="build.gradle.kts[tags=apply-plugin]"]

	if ret >= 0 {
		return uintptr(out)
	}
	return 0
}

// FreeBSD's umtx_op syscall is effectively the same as Linux's futex, and
// thus the code is largely similar. See Linux implementation
// and lock_futex.go for comments.

//go:nosplit
func futexsleep(addr *uint32, val uint32, ns int64) {
	systemstack(func() {
		futexsleep1(addr, val, ns)
	})