if err := DB.AutoMigrate(&Profile{}, &Member{}); err != nil {
		t.Fatalf("Failed to migrate, got error: %v", err)
	}

	member := Member{Refer: 1, Name: "foreign_key_constraints", Profile: Profile{Name: "my_profile"}}

	DB.Create(&member)

	var profile Profile
	if err := DB.First(&profile, "id = ?", member.Profile.ID).Error; err != nil {
		t.Fatalf("failed to find profile, got error: %v", err)

stderr '^cannot use -blockprofile flag with -fuzz flag$'

! go test -fuzz=FuzzTrivial -cpuprofile=prof
! stdout .
stderr '^cannot use -cpuprofile flag with -fuzz flag$'

! go test -fuzz=FuzzTrivial -memprofile=prof
! stdout .
stderr '^cannot use -memprofile flag with -fuzz flag$'

! go test -fuzz=FuzzTrivial -mutexprofile=prof
! stdout .
stderr '^cannot use -mutexprofile flag with -fuzz flag$'

! go test -fuzz=FuzzTrivial -trace=prof

# Tests issue 19394

[short] skip

! go test -cpuprofile cpu.pprof -memprofile mem.pprof -timeout 1ms
stdout '^panic: test timed out'
grep . cpu.pprof
grep . mem.pprof

-- go.mod --
module profiling

go 1.16
-- timeout_test.go --
package timeouttest_test

import (
	"testing"
	"time"
)

func TestSleep(t *testing.T) {
	for {
		time.Sleep(1 * time.Second)
	}

	// Find out how many records there are (MemProfile(nil, true)),
	// allocate that many records, and get the data.
	// There's a race—more records might be added between
	// the two calls—so allocate a few extra records for safety
	// and also try again if we're very unlucky.
	// The loop should only execute one iteration in the common case.
	var p []runtime.MemProfileRecord
	n, ok := runtime.MemProfile(nil, true)
	for {

# or -outputdir, not the directory containing the test.

go test -memprofile=mem.out ./x
exists ./mem.out
rm ./mem.out

go test -trace=trace.out ./x
exists ./trace.out
rm ./trace.out

# Relative paths with -outputdir should be relative to the go command's working
# directory, not the directory containing the test.
mkdir profiles
go test -memprofile=mem.out -outputdir=./profiles ./x
exists ./profiles/mem.out
rm profiles

	"failfast":             true,
	"fullpath":             true,
	"fuzz":                 true,
	"fuzzminimizetime":     true,
	"fuzztime":             true,
	"list":                 true,
	"memprofile":           true,
	"memprofilerate":       true,
	"mutexprofile":         true,
	"mutexprofilefraction": true,
	"outputdir":            true,
	"parallel":             true,
	"run":                  true,

var cpuprofileflag = flag.String("cpuprofile", "", "Write CPU profile to specified file")
var memprofileflag = flag.String("memprofile", "", "Write memory profile to specified file")
var memprofilerateflag = flag.Int("memprofilerate", 0, "Set memprofile sampling rate to value")

var matchpkg func(name string) bool

var atExitFuncs []func()

func atExit(f func()) {
	atExitFuncs = append(atExitFuncs, f)

	if *cpuProfile != "" {
		pprof.StopCPUProfile() // flushes profile to disk
	}
	if *memProfile != "" {
		f, err := os.Create(*memProfile)
		if err != nil {
			fmt.Fprintf(os.Stderr, "testing: %s", err)
			return
		}
		if err = pprof.WriteHeapProfile(f); err != nil {
			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s", *memProfile, err)
		}
		f.Close()
	}
}

var timer *time.Timer

	flagRandLayout    = flag.Int64("randlayout", 0, "randomize function layout")
	cpuprofile        = flag.String("cpuprofile", "", "write cpu profile to `file`")
	memprofile        = flag.String("memprofile", "", "write memory profile to `file`")
	memprofilerate    = flag.Int64("memprofilerate", 0, "set runtime.MemProfileRate to `rate`")

		},
		{
			"with_memprofile",
			`
package main
import "runtime"
func main() {
	runtime.MemProfile(nil, false)
	println(runtime.MemProfileRate)
}
`,
			"524288",
		},
		{
			"with_memprofile_indirect",
			`
package main
import "runtime"
var f = runtime.MemProfile
func main() {
	if f == nil {
		panic("no f")
	}
	println(runtime.MemProfileRate)
}
`,