}
		}
		w = t.NumElem() * t.Elem().width
		t.align = t.Elem().align

		// ABIInternal only allows "trivial" arrays (i.e., length 0 or 1)
		// to be passed by register.
		switch t.NumElem() {
		case 0:
			t.intRegs = 0
			t.floatRegs = 0
		case 1:
			t.intRegs = t.Elem().intRegs
			t.floatRegs = t.Elem().floatRegs
		default:
			t.intRegs = math.MaxUint8
			t.floatRegs = math.MaxUint8
		}

ip6tables -t nat -X ISTIO_INBOUND
ip6tables -t mangle -F ISTIO_INBOUND
ip6tables -t mangle -X ISTIO_INBOUND
ip6tables -t mangle -F ISTIO_DIVERT
ip6tables -t mangle -X ISTIO_DIVERT
ip6tables -t mangle -F ISTIO_TPROXY
ip6tables -t mangle -X ISTIO_TPROXY
ip6tables -t nat -F ISTIO_REDIRECT
ip6tables -t nat -X ISTIO_REDIRECT
ip6tables -t nat -F ISTIO_IN_REDIRECT
ip6tables -t nat -X ISTIO_IN_REDIRECT
iptables -t nat -D OUTPUT -p udp -j ISTIO_OUTPUT

		if err != nil {
			t.Fatal(err)
		}
		if len(got) > 0 {
			t.Errorf("got %d bytes, expected 0", len(got))
		}
	})
}

func TestSliceCap(t *testing.T) {
	t.Run("small", func(t *testing.T) {
		c := SliceCap[int](10)
		if c != 10 {
			t.Errorf("got capacity %d, want %d", c, 10)
		}
	})

	t.Run("large", func(t *testing.T) {
		c := SliceCap[byte](1 << 30)
		if c < 0 {

		// advanced to the next line.
		t.outBuf = append(t.outBuf, '\r', '\n')
	}
}

func (t *Terminal) eraseNPreviousChars(n int) {
	if n == 0 {
		return
	}

	if t.pos < n {
		n = t.pos
	}
	t.pos -= n
	t.moveCursorToPos(t.pos)

	copy(t.line[t.pos:], t.line[n+t.pos:])
	t.line = t.line[:len(t.line)-n]
	if t.echo {
		t.writeLine(t.line[t.pos:])
		for i := 0; i < n; i++ {

	t.Parallel()
	t.Errorf("FAIL - %s", t.Name())
}

func TestParallelFailingSubtestsA(t *testing.T) {
	t.Parallel()
	t.Run("TestFailingSubtestsA1", func(t *testing.T) {
		t.Errorf("FAIL - %s", t.Name())
	})
	t.Run("TestFailingSubtestsA2", func(t *testing.T) {
		t.Errorf("FAIL - %s", t.Name())
	})
}

func TestFailingSubtestsA(t *testing.T) {
	t.Run("TestFailingSubtestsA1", func(t *testing.T) {

		c := s.Connect()
		s.Verify(c.RequestResponseAck(t, &discovery.DiscoveryRequest{ResourceNames: []string{rootResourceName}}), expectRoot)
		c.ExpectNoResponse(t)
		s.Verify(c.RequestResponseAck(t, &discovery.DiscoveryRequest{ResourceNames: []string{testResourceName}}), expectCert)
		c.ExpectNoResponse(t)
	})
	t.Run("multiplexed multiple single", func(t *testing.T) {
		s := setupSDS(t)
		c := s.Connect()

		defer timeout(1 * time.Minute)()
		testServerInCongestion(t, local, remote)
		assertNoActive(t, connRemoteLocal)
		assertNoActive(t, connLocalToRemote)
	})
	t.Run("testGenericsStreamRoundtrip", func(t *testing.T) {
		defer timeout(1 * time.Minute)()
		testGenericsStreamRoundtrip(t, local, remote)
		assertNoActive(t, connRemoteLocal)
		assertNoActive(t, connLocalToRemote)
	})

    void, void, void>
#define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
    void, void, void>
#define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
    void, void, void>
#define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
    void, void, void>
#define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \

var sink interface{}

func f1() {
	var t T
	f := t.noescape // ERROR "t.noescape does not escape"
	f()
}

func f2() {
	var t T       // ERROR "moved to heap"
	f := t.escape // ERROR "t.escape does not escape"
	f()
}

func f3() {
	var t T        // ERROR "moved to heap"
	f := t.returns // ERROR "t.returns does not escape"
	sink = f()
}

type T struct{}

ip6tables -t nat -X ISTIO_INBOUND
ip6tables -t mangle -F ISTIO_INBOUND
ip6tables -t mangle -X ISTIO_INBOUND
ip6tables -t mangle -F ISTIO_DIVERT
ip6tables -t mangle -X ISTIO_DIVERT
ip6tables -t mangle -F ISTIO_TPROXY
ip6tables -t mangle -X ISTIO_TPROXY
ip6tables -t nat -F ISTIO_REDIRECT
ip6tables -t nat -X ISTIO_REDIRECT
ip6tables -t nat -F ISTIO_IN_REDIRECT
ip6tables -t nat -X ISTIO_IN_REDIRECT
iptables -t nat -D OUTPUT -p udp -j ISTIO_OUTPUT