package main

import "encoding/binary"

//go:noinline
func Id(a [8]byte) (x [8]byte) {
	binary.LittleEndian.PutUint64(x[:], binary.LittleEndian.Uint64(a[:]))
	return
}

var a = [8]byte{1, 2, 3, 4, 5, 6, 7, 8}

func main() {
	x := Id(a)
	if x != a {
		panic("FAIL")
	}

			wantError: true,
		},
		{
			key:    "source.ip",
			values: []string{"1.2.3.4", "5.6.7.0/24"},
		},
		{
			key:       "source.ip",
			values:    []string{"a.b.c.d"},
			wantError: true,
		},
		{
			key:    "remote.ip",
			values: []string{"1.2.3.4", "5.6.7.0/24"},
		},
		{
			key:       "remote.ip",
			values:    []string{"a.b.c.d"},
			wantError: true,
		},

func TestApplicInsert(t *testing.T) {
	applicInsert(t, []int32{24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25})
	applicInsert(t, []int32{1, 2, 3, 4})
	applicInsert(t, []int32{1, 2, 3, 4, 5, 6, 7, 8, 9})
	applicInsert(t, []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25})

---
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: httpbin-8
  namespace: foo
spec:
  rules:
    - from:
        - source:
            ipBlocks: ["1.2.3.4", "5.6.7.0/24"]
---
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: httpbin-9
  namespace: foo
spec:
  rules:
    - when:
        - key: "request.headers[X-abc]"

// is not a requirement for correctness and not checked in this test.
// We do check the emitted symbol contents are correct, though.

package main

func main() {
	F([10]int{1, 2, 3, 4, 5, 6}, [20]int{1, 2, 3, 4, 5, 6})
}

//go:noinline
func F(x, y interface{}) {
	x1 := x.([10]int)
	y1 := y.([20]int)
	for i := range y1 {
		if i < 6 {
			if x1[i] != i+1 || y1[i] != i+1 {
				panic("FAIL")

	}
}

func TestDtoi(t *testing.T) {
	for _, tt := range []struct {
		in  string
		out int
		off int
		ok  bool
	}{
		{"", 0, 0, false},
		{"0", 0, 1, true},
		{"65536", 65536, 5, true},
		{"123456789", big, 8, false},
		{"-0", 0, 0, false},
		{"-1234", 0, 0, false},
	} {
		n, i, ok := dtoi(tt.in)
		if n != tt.out || i != tt.off || ok != tt.ok {

		// nested aggregates, no ...
		{
			func() int { return testTracebackArgs8a(testArgsType8a{1, 2, 3, 4, 5, 6, 7, 8, [2]int{9, 10}}) },
			"testTracebackArgs8a({0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, {0x9, 0xa}})",
		},
		// nested aggregates, ... in inner but not outer
		{
			func() int { return testTracebackArgs8b(testArgsType8b{1, 2, 3, 4, 5, 6, 7, 8, [3]int{9, 10, 11}}) },

 *
 * @author Dimitris Andreou
 */
public class AbstractStreamingHasherTest extends TestCase {
  public void testBytes() {
    Sink sink = new Sink(4); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    sink.putByte((byte) 1);
    sink.putBytes(new byte[] {2, 3, 4, 5, 6});
    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();

	config := &runtimeapi.PodSandboxConfig{
		Linux: &runtimeapi.LinuxPodSandboxConfig{},
	}

	getPodWithOverhead := func() *v1.Pod {
		return &v1.Pod{
			ObjectMeta: metav1.ObjectMeta{
				UID:       "12345678",
				Name:      "bar",
				Namespace: "new",
			},
			Spec: v1.PodSpec{
				Containers: []v1.Container{
					{
						Resources: v1.ResourceRequirements{
							Requests: v1.ResourceList{

	"127.1",
	// IPv4 field has value >255.
	"192.168.300.1",
	// IPv4 with too many fields.
	"192.168.0.1.5.6",
	// IPv6 with not enough fields.
	"1:2:3:4:5:6:7",
	// IPv6 with too many fields.
	"1:2:3:4:5:6:7:8:9",
	// IPv6 with 8 fields and a :: expander.
	"1:2:3:4::5:6:7:8",
	// IPv6 with a field bigger than 2b.
	"fe801::1",
	// IPv6 with non-hex values in field.
	"fe80:tail:scal:e::",