import "log"

func main() {
	log.Fatalf("HERE")
}
`

func TestIssue33808(t *testing.T) {
	if runtime.GOOS != "darwin" {
		return
	}
	testenv.MustHaveGoBuild(t)
	testenv.MustHaveCGO(t)
	t.Parallel()

	dir := t.TempDir()

	f := gobuild(t, dir, prog, "-ldflags=-linkmode=external")
	f.Close()

	syms, err := f.Symbols()
	if err != nil {
		t.Fatalf("Error reading symbols: %v", err)
	}

//	testcover -mode=count -var=CoverTest -o ./testdata/test_cover.go testdata/test_line.go
//	go run ./testdata/main.go ./testdata/test.go
func TestCover(t *testing.T) {
	testenv.MustHaveGoRun(t)
	t.Parallel()
	dir := tempDir(t)

	// Read in the test file (testTest) and write it, with LINEs specified, to coverInput.
	testTest := filepath.Join(testdata, "test.go")
	file, err := os.ReadFile(testTest)
	if err != nil {

            // TODO - should fail
            succeeds 'b', 'a'
        }
    }

    void 'finalizer tasks are executed as expected in parallel builds'() {
        setupMultipleProjects()
        executer.beforeExecute {
            withArguments('--parallel')
        }

        expect:
        2.times {
            succeeds 'a'

  static final String MULTIPLE_EDGES_CONNECTING =
      "Cannot call edgeConnecting() when parallel edges exist between %s and %s. Consider calling "
          + "edgesConnecting() instead.";
  static final String PARALLEL_EDGES_NOT_ALLOWED =
      "Nodes %s and %s are already connected by a different edge. To construct a graph "
          + "that allows parallel edges, call allowsParallelEdges(true) on the Builder.";

            }
        """
    }

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    @UnsupportedWithConfigurationCache(because = "parallel by default")
    def "reuses compiler daemons within a single project build"() {
        withSingleProjectSources()

        when:
        succeeds("compileAll")

        then:

		Log:             os.Stderr,
		Timeout:         timeout,
		Limit:           limit,
		MinimizeTimeout: minimizeTimeout,
		MinimizeLimit:   minimizeLimit,
		Parallel:        parallel,
		Seed:            seed,
		Types:           types,
		CorpusDir:       corpusDir,
		CacheDir:        cacheDir,
	})
	if err == ctx.Err() {
		return nil
	}
	return err
}

	}

	const env = "GO_RAND_TEST_HELPER_CODE"
	if v := os.Getenv(env); v != "" {
		doDefaultTest(t, v)
		return
	}

	t.Parallel()

	for i := 0; i < 6; i++ {
		i := i
		t.Run(strconv.Itoa(i), func(t *testing.T) {
			t.Parallel()
			exe, err := os.Executable()
			if err != nil {
				exe = os.Args[0]
			}
			cmd := testenv.Command(t, exe, "-test.run=TestDefaultRace")

[short] skip
[!fuzz] skip
env GOCACHE=$WORK/cache

# If the I/O error occurs before F.Fuzz is called, the coordinator should
# stop the worker and say that.
! go test -fuzz=FuzzClosePipeBefore -parallel=1
stdout '\s*fuzzing process terminated without fuzzing:'
! stdout 'communicating with fuzzing process'
! exists testdata

# If the I/O error occurs after F.Fuzz is called (unlikely), just exit.

// because the private method in testing.TB led gccgo to assume that
// the interface method table would be defined in the testing package.

package main

import "testing"

type I interface {
	testing.TB
	Parallel()
}

func F(i I) {
	i.Log("F")
}

var t testing.T

func main() {
	F(&t)

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

package objabi

import "testing"

func TestDecodeArg(t *testing.T) {
	t.Parallel()
	tests := []struct {
		arg, want string
	}{
		{"", ""},
		{"hello", "hello"},
		{"hello\\n", "hello\n"},
		{"hello\\nthere", "hello\nthere"},
		{"hello\\\\there", "hello\\there"},
		{"\\\\\\n", "\\\n"},