addEmptyTestClass("ACTest")
        addEmptyTestClass("AÄTest")
        addEmptyTestClass("AZTest")
        addEmptyTestClass("AbTest")

        String expectedTestMessages = """
executed Test ${maybeParentheses('test')}(AATest)
executed Test ${maybeParentheses('test')}(ACTest)
executed Test ${maybeParentheses('test')}(AZTest)
executed Test ${maybeParentheses('test')}(AbTest)
executed Test ${maybeParentheses('test')}(AdTest)

    @Issue("https://github.com/gradle/gradle/issues/14434")
    def "can run tests in parallel with project dependencies"() {
        given:
        httpServer.expectConcurrent(':a:test', ':b:test', ':c:test', ':d:test')
        httpServer.start()

        settingsFile << """
            include 'a', 'b', 'c', 'd'
        """
        buildFile << """
            allprojects {
                tasks.withType(AbstractScalaCompile) {

[short] skip

# test fail fast
! go test ./failfast_test.go -run='TestFailingA' -failfast=true
stdout -count=1 'FAIL - '
! go test ./failfast_test.go -run='TestFailing[AB]' -failfast=true
stdout -count=1 'FAIL - '
! go test ./failfast_test.go -run='TestFailing[AB]' -failfast=false
stdout -count=2 'FAIL - '

# mix with non-failing tests
! go test ./failfast_test.go -run='TestA|TestFailing[AB]' -failfast=true
stdout -count=1 'FAIL - '

require example.net/c v0.2.0
-- b2/b.go --
package b
-- b2/b_test.go --
package b_test

import _ "example.net/c"
-- c1/go.mod --
module example.net/c

go 1.18
-- c1/c.go --
package c
-- c2/go.mod --
module example.net/c

go 1.18

require example.net/d v0.1.0
-- c2/c.go --
package c
-- c2/c_test.go --
package c_test

import _ "example.net/d"
-- d/go.mod --
module example.net/d

go test -coverpkg=./a ./...
stdout '^ok\s+M/a\s+\S+\s+coverage: 100.0% of statements in ./a'
stdout '^\s*\?\s+M/f\s+\[no test files\]'

-- a/a.go --
package a

import "M/f"

var G int

func AFunc() int {
	G = 1
	return f.Id()
}
-- a/a_test.go --
package a

import "testing"

func TestA(t *testing.T) {
	if AFunc() != 42 {
		t.Fatalf("bad!")
	}
}
-- b/b.go --

                task test { }
            }
            // should be 'project-a', not 'projectA'
            project(":modules:projectA:project-b") {
                task test { }
            }
        """

        when:
        run("test")

        then:
        result.assertTasksExecuted(":modules:project-a:test", ":modules:projectA:project-b:test")
    }

# packages); prior to the fix for #58770 Go 1.20 would show 100%
# coverage. For packages "x" and "f" (which have no tests), check for
# 0% stmts covered (as opposed to "no test files").

go test -count=1 -coverprofile=cov.dat -coverpkg=./... ./...
stdout '^\s*\?\s+M/n\s+\[no test files\]'
stdout '^\s*M/x\s+coverage: 0.0% of statements'
stdout '^\s*M/f\s+coverage: 0.0% of statements'
stdout '^ok\s+M/a\s+\S+\s+coverage: 30.0% of statements in ./...'

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package dwtest

import (
	"debug/dwarf"
	"errors"
	"fmt"
	"os"
)

// Helper type for supporting queries on DIEs within a DWARF
// .debug_info section. Invoke the populate() method below passing in
// a dwarf.Reader, which will read in all DIEs and keep track of

[short] skip

# Kick off test.
go test -p=10 -vet=off -count=1 -coverprofile=cov.p ./...

# Make sure resulting profile is digestible.
go tool cover -func=cov.p

# No extraneous extra files please.
! exists _cover_.out

-- a/a.go --
package a

func init() {
	println("package 'a' init: launch the missiles!")
}

func AFunc() int {
	return 42
}
-- a/a_test.go --
package a

import "testing"

		pmain = nil
	}
	if ptest.Error != nil || ptest.Incomplete {
		ptest = nil
	}
	if pxtest != nil && (pxtest.Error != nil || pxtest.Incomplete) {
		pxtest = nil
	}
	return pmain, ptest, pxtest, err
}

// TestPackagesAndErrors returns three packages:
//   - pmain, the package main corresponding to the test binary (running tests in ptest and pxtest).