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"]

    assertEqualCharNodes(traverser.depthFirstPreOrder(charactersOf("")), "");
    assertEqualCharNodes(traverser.depthFirstPreOrder(charactersOf("bc")), "bdc");
    assertEqualCharNodes(traverser.depthFirstPreOrder(charactersOf("a")), "abdc");
    assertEqualCharNodes(traverser.depthFirstPreOrder(charactersOf("acdb")), "abdc");
    assertEqualCharNodes(traverser.depthFirstPreOrder(charactersOf("db")), "db");
  }

  @Test

    assertEqualCharNodes(traverser.depthFirstPreOrder(charactersOf("")), "");
    assertEqualCharNodes(traverser.depthFirstPreOrder(charactersOf("bc")), "bdc");
    assertEqualCharNodes(traverser.depthFirstPreOrder(charactersOf("a")), "abdc");
    assertEqualCharNodes(traverser.depthFirstPreOrder(charactersOf("acdb")), "abdc");
    assertEqualCharNodes(traverser.depthFirstPreOrder(charactersOf("db")), "db");
  }

  @Test

// 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"

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")
	}

			"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)

	(*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.

	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)

	for i = 0; i < out; i++ {
		if output8[i] != u8(i+13) {
			bad8("before8", i, length, in, out)
			return
		}
	}
	// copied part
	for ; i < out+n; i++ {
		if output8[i] != u8(i+in-out) {
			bad8("copied8", i, length, in, out)
			return
		}
	}
	// after
	for ; i < len(output8); i++ {
		if output8[i] != u8(i+13) {
			bad8("after8", i, length, in, out)
			return
		}
	}
}