// Test aliasing the first argument and the receiver.
	v1.Set(x)
	if out := f(v1, v1, y); out != v1 || !equal(v1, v) {
		t.Logf("f(v, x, y) != f(x, x, y)")
		return false
	}
	// Test aliasing the second argument and the receiver.
	v1.Set(y)
	if out := f(v1, x, v1); out != v1 || !equal(v1, v) {
		t.Logf("f(v, x, y) != f(y, x, y)")
		return false
	}

	// Calculate a reference f(y, y) without aliasing.

		// Try to print out profile content for debugging.
		cmd = testenv.Command(t, pprofPath(t), "-raw", cpuExe, profile)
		out, err = cmd.CombinedOutput()
		if err != nil {
			t.Logf("pprof -raw failed: %v\n%s", err, out)
		} else {
			t.Logf("profile content:\n%s", out)
		}
		return
	}

	sout := string(out)
	want := "ROUTINE ======================== main.main"
	if !strings.Contains(sout, want) {

		// This short test does NOT ensure that the vendored contents match
		// the unmodified contents of the corresponding dependency versions.
		t.Run(m.Path+"(quick)", func(t *testing.T) {
			t.Logf("module %s in directory %s", m.Path, m.Dir)

			if m.hasVendor {
				// Load all of the packages in the module to ensure that their
				// dependencies are vendored. If any imported package is missing,

	}
	pause := ms.PauseNs[(ms.NumGC+255)%256]
	// Due to timer granularity, pause can actually be 0 on windows
	// or on virtualized environments.
	if pause == 0 {
		t.Logf("last GC pause was 0")
	} else if pause > 10e9 {
		t.Logf("bad last GC pause: got %v, want [0, 10e9]", pause)
	}
}

var hugeSink any

func TestHugeGCInfo(t *testing.T) {

					if !isDeadlineExceeded(err) {
						t.Logf("good client timeout after %v, reading %d bytes", res.d, res.n)
					} else {
						t.Fatalf("client Copy = %d, %v; want timeout", res.n, res.err)
					}
				case <-max.C:
					t.Fatalf("timeout (%v) waiting for client to timeout (%v) reading", tooLong, timeout)
				}

				select {
				case res := <-pasvch:
					t.Logf("writer in %v wrote %d: %v", res.d, res.n, res.err)

			if c > len(zstdExp) {
				c = len(zstdExp)
			}
			goExp = goExp[:c]
			zstdExp = zstdExp[:c]
			if !bytes.Equal(goExp, zstdExp) {
				t.Error("byte mismatch after error")
				t.Logf("Go error: %v\n", goErr)
				t.Logf("zstd error: %v\n", zstdErr)
				showDiffs(t, zstdExp, goExp)
			}
		}
	})

package failfast

import "testing"

func TestA(t *testing.T) {
	// Edge-case testing, mixing unparallel tests too
	t.Logf("LOG: %s", t.Name())
}

func TestFailingA(t *testing.T) {
	t.Errorf("FAIL - %s", t.Name())
}

func TestB(t *testing.T) {
	// Edge-case testing, mixing unparallel tests too
	t.Logf("LOG: %s", t.Name())
}

func TestParallelFailingA(t *testing.T) {
	t.Parallel()
	t.Errorf("FAIL - %s", t.Name())
}

// substitute for testing.TB, which cannot be implemented outside of the testing
// package.
type Failer interface {
	Fail()
	FailNow()
	Fatal(args ...any)
	Fatalf(format string, args ...any)
	Log(args ...any)
	Logf(format string, args ...any)
	TempDir() string
	Helper()
	Cleanup(func())
	Skip(args ...any)
}

// Fuzzer abstracts *testing.F
type Fuzzer interface {
	Fuzz(ff any)
	Add(args ...any)
}

	var err error
	argv0 := argv[0]
	if filepath.Base(argv0) == argv0 {
		argv0, err = exec.LookPath(argv0)
		if err != nil {
			Exitf("cannot find %s: %v", argv[0], err)
		}
	}
	if ctxt.Debugvlog != 0 {
		ctxt.Logf("invoking archiver with syscall.Exec()\n")
	}
	err = syscall.Exec(argv0, argv, os.Environ())
	if err != nil {
		Exitf("running %s failed: %v", argv[0], err)
	}

			bad := avoidSamples[i]
			if bad != 0 {
				t.Logf("found %d samples in avoid-function %s\n", bad, name)
				ok = false
			}
		}

		if len(need) == 0 {
			return
		}

		var total uintptr
		for i, name := range need {
			total += have[i]
			t.Logf("found %d samples in expected function %s\n", have[i], name)
		}
		if total == 0 {
			t.Logf("no samples in expected functions")
			ok = false
		}