package org.gradle;

import java.io.File;

public class TestMain {
    public static void main(String[] args) throws Exception {
        File expectedWorkingDir = new File(args[0]).getCanonicalFile();
        File actualWorkingDir = new File(System.getProperty("user.dir")).getCanonicalFile();
        if (!expectedWorkingDir.getCanonicalFile().equals(actualWorkingDir)) {

# Test TestMain
go test standalone_main_normal_test.go
! stdout '^ok.*\[no tests to run\]'
! stderr '^ok.*\[no tests to run\]'
stdout '^ok'

# Test TestMain sees testing flags
go test standalone_testmain_flag_test.go
stdout '^ok.*\[no tests to run\]'

# Test TestMain with wrong signature (Issue #22388)
! go test standalone_main_wrong_test.go
stderr 'wrong signature for TestMain, must be: func TestMain\(m \*testing.M\)'

            task javaexecTask(type: JavaExec) {
                def testFile = file("${'$'}buildDir/${'$'}name")
                classpath(sourceSets.main.output.classesDirs)
                mainClass = 'org.gradle.TestMain'
                args projectDir, testFile
                doLast {
                    assert testFile.exists()
                }
                assert delegate instanceof ExtensionAware
            }

# because this is how TestMain works. If we decide to support -list even when
# TestMain is used to skip entire packages, we can change this test case.
go test -list=. ./main_zero
stdout 'skipping all tests'
! stdout TestNotListed

# Running the test directly still fails, if we pass the flag.
go test -c -o ./zero.exe ./zero
! exec ./zero.exe -test.paniconexit0

package life_test

import (
	"bytes"
	"cmd/cgo/internal/cgotest"
	"internal/testenv"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"testing"
)

func TestMain(m *testing.M) {
	log.SetFlags(log.Lshortfile)
	os.Exit(testMain(m))
}

func testMain(m *testing.M) int {
	GOPATH, err := os.MkdirTemp("", "cgolife")
	if err != nil {
		log.Panic(err)
	}
	defer os.RemoveAll(GOPATH)
	os.Setenv("GOPATH", GOPATH)

go test -v -x -gcflags=-m -ldflags=-v p
stderr 'compile( |\.exe"?)'
stderr 'p_test.go:.*can inline Test' # from compile of p_test
stderr 'testmain\.go:.*inlin' # from compile of testmain
stderr 'link(\.exe"?)? -'
stderr '\d+ symbols' # from linker
stderr 'p\.test( |\.exe"?)'
stdout 'TEST' # from test

import (
	"bytes"
	"cmd/cgo/internal/cgotest"
	"internal/testenv"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
)

func TestMain(m *testing.M) {
	log.SetFlags(log.Lshortfile)
	os.Exit(testMain(m))
}

func testMain(m *testing.M) int {
	GOPATH, err := os.MkdirTemp("", "cgostdio")
	if err != nil {
		log.Panic(err)
	}
	defer os.RemoveAll(GOPATH)
	os.Setenv("GOPATH", GOPATH)

		switch {
		case name == "TestMain":
			if isTestFunc(n, "T") {
				t.Tests = append(t.Tests, testFunc{pkg, name, "", false})
				*doImport, *seen = true, true
				continue
			}
			err := checkTestFunc(n, "M")
			if err != nil {
				return err
			}
			if t.TestMain != nil {
				return errors.New("multiple definitions of TestMain")
			}
			t.TestMain = &testFunc{pkg, name, "", false}

-- go.mod --
module m
go 1.14
-- mainpanic/mainpanic_test.go --
package mainpanic_test

import "testing"

func TestMain(m *testing.M) {
	panic("haha no")
}
-- mainexit0/mainexit0_test.go --
package mainexit0_test

import (
	"fmt"
	"os"
	"testing"
)

func TestMain(m *testing.M) {
	fmt.Println("nothing to do")
	os.Exit(0)
}
-- testpanic/testpanic_test.go --
package testpanic_test

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

//go:build freebsd

package syscall_test

import (
	"os"
	"testing"
)

func TestMain(m *testing.M) {
	if os.Getenv("GO_DEATHSIG_PARENT") == "1" {
		deathSignalParent()
	} else if os.Getenv("GO_DEATHSIG_CHILD") == "1" {
		deathSignalChild()
	}

	os.Exit(m.Run())