a7 = A[vc] // ERROR "non-integer|must be integer"

	s1 = S[i]
	s2 = S[f]
	s3 = S[f2] // ERROR "truncated|must be integer"
	s4 = S[c]
	s5 = S[c2] // ERROR "truncated|must be integer"
	s6 = S[vf] // ERROR "non-integer|must be integer"
	s7 = S[vc] // ERROR "non-integer|must be integer"

	t1 = T[i]
	t2 = T[f]
	t3 = T[f2] // ERROR "truncated|must be integer"
	t4 = T[c]

	manager.RegisterPod(podWithConfigMaps("ns2", "name2", s2))
	// Create and delete a pod with some other configMaps.
	s3 := configMapsToAttach{
		containerEnvConfigMaps: []envConfigMaps{
			{envVarNames: []string{"s6"}},
			{envFromNames: []string{"s60"}},
		},
	}
	manager.RegisterPod(podWithConfigMaps("ns3", "name", s3))
	manager.UnregisterPod(podWithConfigMaps("ns3", "name", s3))

	existingMaps := map[string][]string{

        def s6 = updateDir(single, tooMany)
        assertDirectorySnapshot(s6, dir1)
        assertDirectorySnapshot(s6, child)
        assertDirectorySnapshot(s6, tooMany)
        assertHasNoMetadata(s6, dir2)
        assertHasNoMetadata(s6, tooFew)
        assertPartialDirectoryNode(s6, parent)
        flatten(s6) == [parent.path, "1:dir1", "2:child1", "1:dir12"]
    }

func (c *sigctxt) s3() uint64  { return c.regs().sc_regs.s3 }
func (c *sigctxt) s4() uint64  { return c.regs().sc_regs.s4 }
func (c *sigctxt) s5() uint64  { return c.regs().sc_regs.s5 }
func (c *sigctxt) s6() uint64  { return c.regs().sc_regs.s6 }
func (c *sigctxt) s7() uint64  { return c.regs().sc_regs.s7 }
func (c *sigctxt) s8() uint64  { return c.regs().sc_regs.s8 }
func (c *sigctxt) s9() uint64  { return c.regs().sc_regs.s9 }

			expected: "test1 test2\n",
		},
		{
			name:     "mixed",
			input:    []interface{}{"s1", "s2", []string{"s3", "s4"}, "", "s5", []string{}, []string{"s6"}, "s7"},
			expected: "s1 s2 s3 s4  s5  s6 s7\n",
		},
	}
	testBuffer := NewLineBuffer()
	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			testBuffer.Reset()
			testBuffer.Write(testCase.input...)

	S1 /* ERROR "invalid recursive type: S1 refers to itself" */ struct{ S1 }
	S2 struct{ _ *S2 }
	S3 struct{ *S3 }

	S4 /* ERROR "invalid recursive type" */ struct{ S5 }
	S5 struct{ S6 }
	S6 S4

	// pointers
	P0 *P0
	PP *struct{ PP.f /* ERROR "PP.f is not a type" */ }

	// functions
	F0 func(F0)
	F1 func() F1
	F2 func(F2) F2

	// interfaces

		S0 /* ERROR "redeclared" */ int
	}
	S3 struct {
		x S2
	}
	S4/* ERROR "invalid recursive type" */ struct {
		S4
	}
	S5 /* ERROR "invalid recursive type" */ struct {
		S6
	}
	S6 struct {
		field S7
	}
	S7 struct {
		S5
	}

	L1 []L1
	L2 []int

	A1 [10.0]int
	A2 /* ERROR "invalid recursive type" */ [10]A2

	// string
	s0 = "foo"
	s1 = +"foo" /* ERROR "not defined" */
	s2 = -s0 /* ERROR "not defined" */
	s3 = !s0 /* ERROR "not defined" */
	s4 = ^s0 /* ERROR "not defined" */
	s5 = *s4
	s6 = &s4
	s7 = *s6
	s8 = <-s7
	s9 = ~ /* ERROR "cannot use ~ outside of interface or type constraint" */ s0

	// channel
	ch chan int
	rc <-chan float64
	sc chan <- string
	ch0 = +ch /* ERROR "not defined" */

		s5 := ldr.SymSize(ctxt.ArchSyms.LinkEditGOT)
		s6 := ldr.SymSize(ldr.Lookup(".machosymstr", 0))
		s7 := ldr.SymSize(ldr.Lookup(".machocodesig", 0))

		if ctxt.LinkMode != LinkExternal {
			ms := newMachoSeg("__LINKEDIT", 0)
			ms.vaddr = uint64(Rnd(int64(Segdata.Vaddr+Segdata.Length), *FlagRound))
			ms.vsize = uint64(s1 + s2 + s3 + s4 + s5 + s6 + s7)
			ms.fileoffset = uint64(linkoff)
			ms.filesize = ms.vsize

	*Loop
}

// From reflect test:
// The X in S6 and S7 annihilate, but they also block the X in S8.S9.
type S5 struct {
	S6
	S7
	S8
}

type S6 struct {
	X int
}

type S7 S6

type S8 struct {
	S9
}

type S9 struct {
	X int
	Y int
}

// From reflect test:
// The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.