(*reflect.StringHeader)(unsafe.Pointer(&bad2)).Data = uintptr(unsafe.Pointer(&b[1]))

	for _, test := range []struct {
		a, b interface{}
	}{
		{SI{s: bad1, i: 1}, SI{s: bad2, i: 2}},
		{SS{s: bad1, t: "a"}, SS{s: bad2, t: "aa"}},
		{SS{s: "a", t: bad1}, SS{s: "b", t: bad2}},
		// This one would panic because the length of both strings match, and we check
		// the body of the bad strings before the body of the good strings.

type T2 int

func NewT2(x int) T2 { return T2(x) }

func main() {
	switch (T1{}) {
	case NewT1(1):
		panic("bad1")
	case NewT1(0):
		// ok
	default:
		panic("bad2")
	}

	switch T2(0) {
	case NewT2(2):
		panic("bad3")
	case NewT2(0):
		// ok
	default:
		panic("bad4")
	}

// implicit conversions merit scrutiny
var s string
var bad1 string = 1  // ERROR "conver|incompatible|invalid|cannot"
var bad2 = s + 1     // ERROR "conver|incompatible|invalid|cannot"
var bad3 = s + 'a'   // ERROR "conver|incompatible|invalid|cannot"
var bad4 = "a" + 1   // ERROR "literals|incompatible|convert|invalid"
var bad5 = "a" + 'a' // ERROR "literals|incompatible|convert|invalid"

var bad6 int = 1.5       // ERROR "convert|truncate"

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

// Test case for go.dev/issue/11377: Better synchronization of
// parser after certain syntax errors.

package p

func bad1() {
    if f()) /* ERROR "expected ';', found '\)'" */ {
        return
    }
}

// There shouldn't be any errors down below.

func F1() {}
func F2() {}
func F3() {}
func F4() {}
func F5() {}

	a.AuthenticateToken(context.Background(), "bad1")
	a.AuthenticateToken(context.Background(), "bad2")
	a.AuthenticateToken(context.Background(), "bad3")
	fakeClock.Step(2 * time.Microsecond)
	a.AuthenticateToken(context.Background(), "bad1")
	a.AuthenticateToken(context.Background(), "bad2")
	a.AuthenticateToken(context.Background(), "bad3")
	fakeClock.Step(2 * time.Microsecond)

			"metadata": map[string]interface{}{
				"name": "good",
				"Name": "bad1",
				"nAme": "bad2",
				"naMe": "bad3",
				"namE": "bad4",

				"namespace": "good",
				"Namespace": "bad1",
				"nAmespace": "bad2",
				"naMespace": "bad3",
				"namEspace": "bad4",

				"creationTimestamp": "a",
			},
		}}

		meta, _, err := GetObjectMeta(u.Object, true)

    }

    static class TypeWithUnannotatedProperties extends DefaultTask {
        String bad1
        File bad2
        @Input
        String useful
    }

    def "warns about and ignores properties that are not annotated"() {
        when:

		b.Fatalf("target fails inconsistently")
	}
	bad1 := b.search(r1)
	if bad1 == nil {
		// Search failed due to MaxSet limit.
		return nil
	}
	b.Add = b.Add[:old]

	// bad0 and bad1 together provoke the failure.
	return append(bad0, bad1...)
}

// Run runs a set of trials selecting changes with the given suffix,
// plus the ones in b.Add and not the ones in b.Skip.

        expect:
        nameSorted == caseSensitiveSorted

        where:
        children << [
            ["bAdA", "BaDb"],
            ["bAdA", "BaDb", "Badc"],
            ["bad", "c", "ab"],
            ["Bad", "c", "aB"],
            ["Bad", "c", "AB"],
            ["Bad", "cA", "AB"],

    }

    static final List<List<String>> CHILDREN_LISTS = [
        ["bAdA"],
        ["bAdA", "BaDb"],
        ["bAdA", "BaDb", "Badc"],
        ["bAdA/something", "BaDb/other", "Badc/different"],
        ["bad/mine", "c/other", "ab/second"],
        ["Bad/mine", "c/other", "aB/second"],
        ["Bad/mine", "c/other", "AB/second"],
        ["Bad/mine", "cA/other", "AB/second"],
        ["c", "b/something", "a/very/long/suffix"]