def buildOs = 'linux'
def buildJdk = '17'
def buildMvn = '3.8.x'
def runITsOses = ['linux']
def runITsJdks = ['17', '21']
def runITsMvn = '3.8.x'
def runITscommand = "mvn clean install -Prun-its,embedded -B -U -V" // -DmavenDistro=... -Dmaven.test.failure.ignore=true
def tests

try {

def osNode = jenkinsEnv.labelForOS(buildOs)
node(jenkinsEnv.nodeSelection(osNode)) {
    dir('build') {

		telemetry.Inc("go/subcommand:unknown")
		fmt.Fprintf(os.Stderr, "go %s: unknown command\nRun 'go help%s' for usage.\n", cmdName, helpArg)
		base.SetExitStatus(2)
		base.Exit()
	}
	// Increment a subcommand counter for the subcommand we're running.
	// Don't increment the counter for the tool subcommand here: we'll
	// increment in the tool subcommand's Run function because we need
	// to do the flag processing in invoke first.

def buildOs = 'linux'
def buildJdk = '17'
def buildMvn = '3.8.x'
def runITsOses = ['linux']
def runITsJdks = ['17']
def runITsMvn = '3.8.x'
def runITscommand = "mvn clean install -Prun-its,embedded -B -U -V" // -DmavenDistro=... -Dmaven.test.failure.ignore=true
def tests

try {

def osNode = jenkinsEnv.labelForOS(buildOs)
node('s390x') {
    dir('build') {
        stage('Checkout') {

	// configuration type
	RegisterEventHandler(kind config.GroupVersionKind, handler EventHandler)

	// Run until a signal is received.
	// Run *should* block, so callers should typically call `go controller.Run(stop)`
	Run(stop <-chan struct{})

	// HasSynced returns true after initial cache synchronization is complete
	HasSynced() bool
}

const (

! go test -run /this
stdout FAIL
stdout 'error here'
! stdout 'no tests to run'

! go test -v -run FuzzFoo/this
stdout FAIL
stdout 'error here'
stdout '=== RUN   FuzzFoo/thisfails'
stdout '--- FAIL: FuzzFoo/thisfails'
stdout '=== RUN   FuzzFoo/thispasses'
stdout '--- PASS: FuzzFoo/thispasses'
! stdout 'no tests to run'

! go test -v -run /this
stdout FAIL
stdout 'error here'

{"Action":"start"}
{"Action":"run","Test":"TestIndex"}
{"Action":"output","Test":"TestIndex","Output":"=== RUN   TestIndex\n"}
{"Action":"output","Test":"TestIndex","Output":"--- PASS: TestIndex (0.00s)\n"}
{"Action":"pass","Test":"TestIndex"}
{"Action":"pass","Test":"TestIndex"}
{"Action":"output","Test":"TestIndex","Output":"=== PASS  TestIndex\n"}
{"Action":"run","Test":"TestLastIndex"}
{"Action":"output","Test":"TestLastIndex","Output":"=== RUN   TestLastIndex\n"}

        given:
        addIsCachedCheck()

        when:
        run()
        run()

        then:
        isCached()
    }

    def "refreshes when buildscript changes"() {
        given:
        addIsCachedCheck()
        run()
        buildFile << """
            task newTask
        """

        expect:
        run "newTask" //knows new task
        isNotCached()
    }

	mkasm="go run mkasm.go"
	mkerrors="$mkerrors -m64"
	mksyscall="go run mksyscall.go -openbsd -libc"
	mksysctl="go run mksysctl_openbsd.go"
	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	;;
openbsd_arm)
	mkasm="go run mkasm.go"
	mkerrors="$mkerrors"
	mksyscall="go run mksyscall.go -l32 -openbsd -arm -libc"
	mksysctl="go run mksysctl_openbsd.go"
	# Let the type of C char be signed for making the bare syscall

go test -v -run Test -skip T skip_test.go
! stdout RUN
stdout '^ok.*\[no tests to run\]'

go test -v -skip T skip_test.go
! stdout RUN

go test -v -skip 1 skip_test.go
! stdout Test1
stdout RUN.*Test2
stdout RUN.*Test2/3

go test -v -skip 2/3 skip_test.go
stdout RUN.*Test1
stdout RUN.*Test2
stdout RUN.*ExampleTest1
! stdout Test2/3

go test -v -skip 2/4 skip_test.go
stdout RUN.*Test1
stdout RUN.*Test2
stdout RUN.*Test2/3

/**< 
 *  Retrieves the entire run summary for the last test run (reset each run).
 *  The run counts and stats contained in the run summary are updated 
 *  throughout a test run.  Note, however, that the elapsed time is not 
 *  updated until after all suites/tests are run but before the "all tests 
 *  complete"  message handler is called (if any).  To get the elapsed 
 *  time during a test run, use CU_get_elapsed_time() instead.
 */