Russ Cox <******@****.***> 1488850797 -0500

	for i := 0; i < len(fs); i++ {
		testfs := Clone(fs)
		testfs[i] = math.NaN()

		fmin := Min(testfs)
		if !math.IsNaN(fmin) {
			t.Errorf("got min %v, want NaN", fmin)
		}

		fmax := Max(testfs)
		if !math.IsNaN(fmax) {
			t.Errorf("got max %v, want NaN", fmax)
		}
	}
}

func TestMinMaxPanics(t *testing.T) {
	intCmp := func(a, b int) int { return a - b }

[short] skip
[!cgo] skip
[compiler:gccgo] skip # gccgo has no cover tool

# Test coverage on cgo code. This test case has an external
# test that tests the code and an in-package test file with
# no test cases.

go test -short -cover cgocover3
stdout  'coverage:.*[1-9][0-9.]+%'
! stderr '[^0-9]0\.0%'

-- go.mod --
module cgocover3

go 1.16
-- p.go --
package p

/*
void
f(void)
{
}
*/
import "C"

// For example, using "matching" to mean "whose name contains":
//
//	go test -run ''        # Run all tests.
//	go test -run Foo       # Run top-level tests matching "Foo", such as "TestFooBar".
//	go test -run Foo/A=    # For top-level tests matching "Foo", run subtests matching "A=".
//	go test -run /A=1      # For all top-level tests, run subtests matching "A=1".
//	go test -fuzz FuzzFoo  # Fuzz the target matching "FuzzFoo"
//

	return ret
}
func testdse(t *testing.T) {
	x := int64(-1)
	// construct two pointers that alias one another
	ui64 := (*uint64)(unsafe.Pointer(&x))
	ui32 := (*uint32)(unsafe.Pointer(&x))
	if want, got := uint32(0), alias_ssa(ui64, ui32); got != want {
		t.Fatalf("alias_ssa: wanted %d, got %d\n", want, got)
	}
}

func TestUnsafe(t *testing.T) {
	testf(t)
	testg(t)
	testdse(t)

#	Powers of 2.
#	%.20g versions.
#	random sources
#	random targets
#	random targets ± half a ULP

# Difficult boundary cases, derived from tables given in
#	Vern Paxson, A Program for Testing IEEE Decimal-Binary Conversion
#	ftp://ftp.ee.lbl.gov/testbase-report.ps.Z

# Table 1: Stress Inputs for Conversion to 53-bit Binary, < 1/2 ULP
float64 %b 5e+125 6653062250012735p+365
float64 %b 69e+267 4705683757438170p+841

env GO111MODULE=off

# Issue 23882

[short] skip

go test -coverpkg=all x
stdout ok[\s\S]+?coverage

[!race] stop

go test -coverpkg=all -race x
stdout ok[\s\S]+?coverage

-- x/x.go --
package x
import _ "runtime"
func F() {}

-- x/x_test.go --
package x
import "testing"

  ASSERT_EQ(-1, shape.dim_size(1));
}

INSTANTIATE_TEST_SUITE_P(
    UnifiedCppAPI, UnifiedAPI,
    ::testing::Combine(::testing::Values("graphdef", "mlir"),
                       /*tfrt*/ ::testing::Values(false),
                       /*use_function*/ ::testing::Values(true, false)));
}  // namespace

package p_test

import (
	. "cgocover2"
	"testing"
)

func TestF(t *testing.T) {
	F()

env GO111MODULE=off # relative import not supported in module mode

# Run tests outside GOPATH.
env GOPATH=$WORK/tmp

go test ./testimport
stdout '^ok'

-- testimport/p.go --
package p

func F() int { return 1 }
-- testimport/p1/p1.go --
package p1

func F() int { return 1 }
-- testimport/p_test.go --
package p

import (
	"./p1"

	"testing"
)

func TestF(t *testing.T) {