# go build -buildmode=pie -race main.go on Darwin should work without errors

[!race] skip 'test requires race detector support'

[!GOOS:darwin] ! go build -buildmode=pie -race
[!GOOS:darwin] stderr '^-buildmode=pie not supported when -race is enabled on '$GOOS'/'$GOARCH'$'
[!GOOS:darwin] stop 'not testing -buildmode=pie -race on platform that does not support it'

go build -buildmode=pie -race bytes
! stderr .

[!race] skip

cd $GOPATH/src/empty/pkg
go test -cover -coverpkg=. -race

[short] stop # Only run first case in short mode

cd $GOPATH/src/empty/test
go test -cover -coverpkg=. -race

cd $GOPATH/src/empty/xtest
go test -cover -coverpkg=. -race

cd $GOPATH/src/empty/pkgtest
go test -cover -coverpkg=. -race

cd $GOPATH/src/empty/pkgxtest
go test -cover -coverpkg=. -race

cd $GOPATH/src/empty/pkgtestxtest

	// reported here (after m.Run but before the process exits), it will print
	// "PASS", then print the stack traces for the race, then exit with nonzero
	// status.
	//
	// This is a somewhat fundamental race: because the race detector hooks into
	// the runtime at a very low level, no matter where we put the printing it
	// would be possible to report a race that occurs afterward. However, we could

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

// Package race implements data race detection logic.
// No public interface is provided.
// For details about the race detector see
// https://golang.org/doc/articles/race_detector.html
package race

		seqDone = true
	})
	next = func() (v1 V, ok1 bool) {
		race.Write(unsafe.Pointer(&racer)) // detect races

		if done {
			return
		}
		if yieldNext {
			panic("iter.Pull: next called again before yield")
		}
		yieldNext = true
		race.Release(unsafe.Pointer(&racer))
		coroswitch(c)
		race.Acquire(unsafe.Pointer(&racer))

		// Propagate panics and goexits from seq.
		if panicValue != nil {

test-configfile: install-race
	@env bash $(PWD)/docs/distributed/distributed-from-config-file.sh

test-upgrade: install-race
	@echo "Running minio upgrade tests"
	@(env bash $(PWD)/buildscripts/minio-upgrade.sh)

test-race: verifiers build ## builds minio, runs linters, tests (race)
	@echo "Running unit tests under -race"
	@(env bash $(PWD)/buildscripts/race.sh)

test-iam: install-race ## verify IAM (external IDP, etcd backends)

go version -m m$GOEXE
! stdout gccgoflags

# Build and tool tags are added but not release tags.
# "race" is included with build tags but not "cgo".
go build -tags=a,b
go version -m m$GOEXE
stdout '^\tbuild\t-tags=a,b$'
[race] go build -race
[race] go version -m m$GOEXE
[race] ! stdout '^\tbuild\t-tags='
[race] stdout '^\tbuild\t-race=true$'

# CGO flags are separate settings.
# CGO_ENABLED is always present.

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

/*
Package race contains helper functions for manually instrumenting code for the race detector.

The runtime package intentionally exports these functions only in the race build;
this package exports them unconditionally but without the "race" build tag they are no-ops.
*/

func stackGuardMultiplier(race bool) int {
	// This arithmetic must match that in runtime/internal/sys/consts.go:StackGuardMultiplier.
	n := 1
	// On AIX, a larger stack is needed for syscalls.
	if buildcfg.GOOS == "aix" {
		n += 1
	}
	// The race build also needs more stack.
	if race {
		n += 1
	}
	return n

[short] skip
[!race] skip

# Make sure test is functional.
go test testrace

# Now, check that -race -covermode=set is not allowed.
! go test -race -covermode=set testrace
stderr '-covermode must be "atomic", not "set", when -race is enabled'
! stdout PASS
! stderr PASS

-- go.mod --
module testrace

go 1.16
-- race_test.go --
package testrace

import "testing"

func TestRace(t *testing.T) {