asMap(Map{})
	isMap(Map{})

	asSlice(slice)
	isSlice(slice)
	asSlice(make(Slice, 5))
	isSlice(make(Slice, 5))
	asSlice([]byte{1, 2, 3})
	asSlice([]byte{1, 2, 3}[0:2])
	asSlice(slice[0:4])
	isSlice(slice[0:4])
	asSlice(slice[3:8])
	isSlice(slice[3:8])
	asSlice(nil)
	asSlice(Slice(nil))
	isSlice(Slice(nil))
	slice = nil
	asSlice(Slice{1, 2, 3})
	isSlice(Slice{1, 2, 3})
	asSlice(Slice{})

		"uint128.not",
		"uint128.or",
		"uint128.subOne",
		"uint128.xor",
	}
	switch runtime.GOARCH {
	case "amd64", "arm64":
		// These don't inline on 32-bit.
		wantInlinable = append(wantInlinable,
			"Addr.AsSlice",
			"Addr.Next",
			"Addr.Prev",
		)
	}

	for _, want := range wantInlinable {
		if !got[want] {
			t.Errorf("%q is no longer inlinable", want)
			continue
		}
		delete(got, want)
	}

				{
					Name:      "name",
					Namespace: "ns",
					Hostname:  "a.example.com",
					Addresses: []*workloadapi.NetworkAddress{{
						Network: testNW,
						Address: netip.AddrFrom4([4]byte{1, 2, 3, 4}).AsSlice(),
					}},
					Ports: []*workloadapi.Port{{
						ServicePort: 80,
						TargetPort:  80,
					}},
					SubjectAltNames: []string{"san1"},
				},
				{
					Name:      "name",
					Namespace: "ns",

		Comment:  comment,
		IP:       net.IP(ip.AsSlice()),
		Protocol: &ipProto,
		Replace:  replace,
	})
	if err != nil {
		return fmt.Errorf("failed to add IP %s to ipset %s: %w", ip, name, err)
	}
	return nil
}

func (m *realDeps) deleteIP(name string, ip netip.Addr, ipProto uint8) error {
	err := netlink.IpsetDel(name, &netlink.IPSetEntry{
		IP:       net.IP(ip.AsSlice()),
		Protocol: &ipProto,
	})
	if err != nil {

		Network: a.Network(vip, make(labels.Instance, 0)).String(),
		Address: ip.AsSlice(),
	}, nil
}

func (a *index) toNetworkAddressFromIP(ip netip.Addr) *workloadapi.NetworkAddress {
	return &workloadapi.NetworkAddress{
		Network: a.Network(ip.String(), make(labels.Instance, 0)).String(),
		Address: ip.AsSlice(),
	}
}

	ids := []Identity{}
	for _, host := range strings.Split(hosts, ",") {
		if ipa, _ := netip.ParseAddr(host); ipa.IsValid() {
			// Use the 4-byte representation of the IP address when possible.
			ip := ipa.AsSlice()
			if ipa.Is4In6() {
				eip := ipa.As4()
				ip = eip[:]
			}
			ids = append(ids, Identity{Type: TypeIP, Value: ip})
		} else if strings.HasPrefix(host, spiffe.URIPrefix) {

func TestBuildSubjectAltNameExtension(t *testing.T) {
	uriIdentity := Identity{Type: TypeURI, Value: []byte("spiffe://test.domain.com/ns/default/sa/default")}
	ipIdentity := Identity{Type: TypeIP, Value: netip.MustParseAddr("10.0.0.1").AsSlice()}
	dnsIdentity := Identity{Type: TypeDNS, Value: []byte("test.domain.com")}

	testCases := map[string]struct {
		hosts       string
		expectedExt *pkix.Extension
	}{
		"URI host": {

	if b4 := b.To4(); b4 != nil {
		b = b4
	}
	aAsSlice := a.AsSlice()
	if len(aAsSlice) != len(b) {
		return 0
	}
	// If IPv6, only up to the prefix (first 64 bits)
	if len(aAsSlice) > 8 {
		aAsSlice = aAsSlice[:8]
		b = b[:8]
	}
	for len(aAsSlice) > 0 {
		if aAsSlice[0] == b[0] {
			cpl += 8
			aAsSlice = aAsSlice[1:]
			b = b[1:]
			continue
		}
		bits := 8

*/

package runtime

import (
	"bytes"
	"io"
)

// Splice is the interface that wraps the Splice method.
//
// Splice moves data from given slice without copying the underlying data for
// efficiency purpose. Therefore, the caller should make sure the underlying
// data is not changed later.
type Splice interface {
	Splice([]byte)
	io.Writer
	Reset()
	Bytes() []byte
}

// SortStrings sorts the specified string slice in place. It returns the same
// slice that was provided in order to facilitate method chaining.
func SortStrings(s []string) []string {
	sort.Strings(s)
	return s
}

// ContainsString checks if a given slice of strings contains the provided string.
// If a modifier func is provided, it is called with the slice item before the comparation.