{"-1234", "% 8.5d", "  -01234"},
	{"-1234", "% 8.6d", " -001234"},

	{"1234", "%.3x", "4d2"},
	{"1234", "%.4x", "04d2"},
	{"1234", "%.5x", "004d2"},
	{"1234", "%.6x", "0004d2"},
	{"-1234", "%.3x", "-4d2"},
	{"-1234", "%.4x", "-04d2"},
	{"-1234", "%.5x", "-004d2"},
	{"-1234", "%.6x", "-0004d2"},

	{"1234", "%8.3x", "     4d2"},
	{"1234", "%8.4x", "    04d2"},
	{"1234", "%8.5x", "   004d2"},

			svcFunc: func(svc *v1.Service) {
				svc.Spec.Type = v1.ServiceTypeLoadBalancer
				svc.Spec.ExternalIPs = []string{"1.2.3.4"}
				svc.Spec.LoadBalancerSourceRanges = []string{" 1.2.3.4/28"}
				svc.Status.LoadBalancer.Ingress = []v1.LoadBalancerIngress{{
					IP: "1.2.3.4",
				}}
			},
			services:            0,
			epPerService:        0,
			expectedFilterRules: 4,
			expectedNatRules:    5,
		},

spec:
  gatewayClassName: acme-lb
  addresses:
  - value: 1200:0000:AB00:1234:0000:2552:7777:1313
  - value: 21DA:D3:0:2F3B:2AA:FF:FE28:9C5A
  - value: "2001:db8:3c4d:15:0:d234:3eee::"
  - value: "1234::"
  - value: "1.1.1.1"
  - value: "1.2.3.4"
  - value: "0.0.0.0"
  - value: "9.255.255.255"
  - value: "11.0.0.0"
  - type: IPAddress
    value: "255.255.255.255"
  - type: "Hostname"
    value: "example.com"
  listeners:

    # rule[1] `from`: TCP field, `to`: HTTP field.
    - from:
        - source:
            ipBlocks: ["1.2.3.4"]
      to:
        - operation:
            methods: ["GET"]
    # rule[2] `from`: TCP field, `to`: TCP field.
    - from:
        - source:
            ipBlocks: ["1.2.3.4"]
      to:
        - operation:
            ports: ["80"]
    # rule[3] `from`: nil, `to`: nil, `when`: HTTP field.

			servers: []serverInfo{{
				id:             "server-1",
				ports:          []corev1.EndpointPort{{Name: "foo", Port: 8080, Protocol: "TCP"}},
				newIP:          "1.2.3.4",
				expectEndpoint: "1.2.3.4:8080",
			}},
			expectLeases: []string{"1.2.3.4"},
		},
	}
	for _, test := range tests {
		t.Run(test.testName, func(t *testing.T) {
			fakeReconciler := NewFakePeerEndpointReconciler(t, s)

        when:
        expectResourceRead(name, "1234")
        def result = resource.withContent(action)

        then:
        result.result == null
        result.bytesRead == 4
        1 * action.execute(_) >> { InputStream input -> input.text }
        0 * _

        when:
        expectResourceRead(name, "1234")
        result = resource.withContent(action)

        then:

				Timeout:       0,
				Netmask:       0xffffffff,
				AddressFamily: unix.AF_INET,
				Address:       netutils.ParseIPSloppy("1.2.3.4"),
				PEName:        "",
			},
			VirtualServer{
				Address:   netutils.ParseIPSloppy("1.2.3.4"),
				Protocol:  "",
				Port:      0,
				Scheduler: "lc",
				Flags:     ServiceFlags(0),
				Timeout:   0,
			},
			false,
			"",
		},

	const d16 = "0123456789ABCDEF"
	k := 0x1234
	var x [4]byte
	
	x[0] = d16[k>>12&0xf]
	x[1] = d16[k>>8&0xf]
	x[2] = d16[k>>4&0xf]
	x[3] = d16[k&0xf]
	
	if x != [4]byte{'1','2','3','4'} {
		fmt.Println(x)
		panic("x != [4]byte{'1','2','3','4'}")
	}

package main

func main() {
	if a := Get(); a != dummyID(1234) {
		panic("FAIL")
	}
}

func dummyID(x int) [Size]interface{} {
	var out [Size]interface{}
	out[0] = x
	return out
}

const Size = 32

type OutputID [Size]interface{}

//go:noinline
func Get() OutputID {
	return dummyID(1234)

			}},
			SecurityContext:    &v1.PodSecurityContext{},
			SchedulerName:      v1.DefaultSchedulerName,
			EnableServiceLinks: &enableServiceLinks,
		},
		Status: v1.PodStatus{
			PodIP: "1.2.3.4",
			PodIPs: []v1.PodIP{
				{
					IP: "1.2.3.4",
				},
			},
		},
	}
	json, err := runtime.Encode(clientscheme.Codecs.LegacyCodec(v1.SchemeGroupVersion), pod)
	if err != nil {
		t.Errorf("unexpected error: %v", err)
	}