_[A, B /* ERROR missing type constraint */ ] int
        _[A, /* ERROR missing type parameter name */ interface{}] int
        _[A, B, C /* ERROR missing type constraint */ ] int
        _[A B, C /* ERROR missing type constraint */ ] int
        _[A B, /* ERROR missing type parameter name */ interface{}] int
        _[A B, /* ERROR missing type parameter name */ interface{}, C D] int

}

// Identifier and expression arity must match.
const _ /* ERROR "missing init expr for _" */
const _ = 1, 2 /* ERROR "extra init expr 2" */

const _ /* ERROR "missing init expr for _" */ int
const _ int = 1, 2 /* ERROR "extra init expr 2" */

const (
	_ /* ERROR "missing init expr for _" */
	_ = 1, 2 /* ERROR "extra init expr 2" */

	_ /* ERROR "missing init expr for _" */ int
	_ int = 1, 2 /* ERROR "extra init expr 2" */
)

        0 * listener._
    }

    def "containsAll of missing elements is tracked"() {
        when:
        def result = set.containsAll(Arrays.asList('missing', 'alsoMissing'))

        then:
        !result
        1 * listener.onAccess('missing')
        1 * listener.onAccess('alsoMissing')
        0 * listener._
    }

    def "containsAll of missing and existing elements is tracked"() {
        when:

    File existingFile;

    @Param({"true", "false"})
    boolean missing;

    @Setup(Level.Trial)
    public void setup() throws IOException {
        this.tempDirPath = Files.createTempDirectory("file-walking");
        this.tempDirFile = tempDirPath.toFile();

        this.missingPath = tempDirPath.resolve("aaa-missing/bbb-missing/ccc-missing/ddd-missing/missing.txt");
        this.missingFile = missingPath.toFile();

! go get example.net/missing/subdir@v0.1.0
stderr '^go: module example.net/missing@v0.1.0 found \(replaced by ./missing\), but does not contain package example.net/missing/subdir$'

go get example.net/missing@v0.1.0


# Getting the subdirectory should continue to fail even if the corresponding
# module is already present in the build list.

! go get example.net/missing/subdir@v0.1.0

)

// go.dev/issue/60812
type (
	_ [t]struct{}
	_ [[]t]struct{}
	_ [[t]t]struct{}
	_ [t /* ERROR "missing type parameter name or invalid array length" */ [t]]struct{}
	_ [t t[t], t /* ERROR "missing type parameter name" */ [t]]struct{}
	_ [t /* ERROR "missing type parameter name" */ [t], t t[t]]struct{}
	_ [t /* ERROR "missing type parameter name" */ [t], t[t]]struct{} // report only first error

	os.Exit(m.Run())
}

func TestPassFlagToTest(t *testing.T) {
	wantNames := genflags.ShortTestFlags()

	missing := map[string]bool{}
	for _, name := range wantNames {
		if !passFlagToTest[name] {
			missing[name] = true
		}
	}
	if len(missing) > 0 {
		t.Errorf("passFlagToTest is missing entries: %v", missing)
	}

	extra := maps.Clone(passFlagToTest)
	for _, name := range wantNames {
		delete(extra, name)
	}

        given:
        def repo = addRepo1()

        when:
        resolver.resolve(moduleComponentId, componentRequestMetaData, result)

        then:
        1 * localAccess.resolveComponentMetaData(moduleComponentId, componentRequestMetaData, _) >> { id, meta, result ->
            result.missing()
            result.authoritative = false
        }

// license that can be found in the LICENSE file.

package p

func _ () {
	if {} // ERROR "missing condition in if statement"

	if
	{} // ERROR "missing condition in if statement"

	if ; {} // ERROR "missing condition in if statement"

	if foo; {} // ERROR "missing condition in if statement"

	if foo; // ERROR "missing condition in if statement"
	{}

	if foo {}

	if ; foo {}

        key1       | reportedValue1  | key2           | reportedValue2 | expectedResult
        'existing' | 'existingValue' | 'other'        | 'otherValue'   | true
        'existing' | 'existingValue' | 'missing'      | null           | false
        'missing'  | null            | 'otherMissing' | null           | false
    }

    def "remove(#key) is tracked"() {
        when:
        def result = getMapUnderTestToWrite().remove(key)