remoteAddr: "1.2.3.4:555",
		expected:   []string{"1.2.3.4"},
	}, {
		name:       "no headers, just remoteAddr host",
		remoteAddr: "1.2.3.4",
		expected:   []string{"1.2.3.4"},
	}, {
		name:         "empty forwarded-for chain",
		forwardedFor: " ",
		remoteAddr:   "1.2.3.4",
		expected:     []string{"1.2.3.4"},
	}, {
		name:         "invalid forwarded-for chain",

    with client.websocket_connect("/ws/1234") as connection, client.websocket_connect(
        "/ws/5678"
    ) as connection_two:
        connection.send_text("Hello from 1234")
        data1 = connection.receive_text()
        assert data1 == "You wrote: Hello from 1234"
        data2 = connection_two.receive_text()
        client1_says = "Client #1234 says: Hello from 1234"
        assert data2 == client1_says

		{Pod: &kubecontainer.Pod{
			ID: "1234",
			Containers: []*kubecontainer.Container{
				createTestContainer("c1", kubecontainer.ContainerStateRunning),
			},
		}},
	}
	pleg.Relist()
	expected := []*PodLifecycleEvent{
		{ID: "1234", Type: ContainerDied, Data: "c2"},
		{ID: "1234", Type: ContainerRemoved, Data: "c2"},
		{ID: "1234", Type: ContainerRemoved, Data: "c3"},
	}

func (p S3) Put(i int64) { p.l = i }

func f7() {
	s := S3{1, 2, 3, 4}
	var i I2 = s
	i.Put(5)
	check(i.Get() == 4, "f7 i")
	check(s.l == 4, "f7 s")
}

func f8() {
	s := S3{1, 2, 3, 4}
	var i I2 = &s
	i.Put(5)
	check(i.Get() == 4, "f8 i")
	check(s.l == 4, "f8 s")
}

func f9() {
	s := &S3{1, 2, 3, 4}
	var i I2 = s
	i.Put(5)
	check(i.Get() == 4, "f9 i")

		"",
	},
	{
		"simple",
		"1 (a)",
		"1.(.a.)",
	},
	{
		"simple define",
		lines(
			"#define A 1234",
			"A",
		),
		"1234.\n",
	},
	{
		"define without value",
		"#define A",
		"",
	},
	{
		"macro without arguments",
		"#define A() 1234\n" + "A()\n",
		"1234.\n",
	},
	{
		"macro with just parens as body",
		"#define A () \n" + "A\n",
		"(.).\n",
	},
	{

					ObjectMeta: metav1.ObjectMeta{Namespace: "one", Name: "alfa"},
					Spec: v1.ServiceSpec{
						Type:      v1.ServiceTypeClusterIP,
						ClusterIP: "hit",
						Ports: []v1.ServicePort{
							{Port: 1234, TargetPort: intstr.FromInt32(1234)},
						},
					},
				},
			},
			endpoints: matchingEndpoints,

			clusterMode:  expectation{error: true},
			endpointMode: expectation{error: true},
		},
		{
			name: "cluster ip",

package main

type Service struct {
	rpc [2]int
}

func (s *Service) Serve(a int64) {
	if a != 1234 {
		print(a, " not 1234\n")
		panic("fail")
	}
}

var arith Service

func main() {
	c := make(chan string)
	a := new(Service)
	go a.Serve(1234)
	_ = c

apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
address: 1.2.3.4

			hostport:     "cp.k8s.io:1234",
			expectedHost: "cp.k8s.io",
			expectedPort: "1234",
		},
		{
			name:         "valid ip4",
			hostport:     "1.2.3.4",
			expectedHost: "1.2.3.4",
			expectedPort: "",
		},
		{
			name:         "valid ipv4:port",
			hostport:     "1.2.3.4:1234",
			expectedHost: "1.2.3.4",
			expectedPort: "1234",
		},
		{
			name:         "valid ipv6",

    assertEquals("::102:304", InetAddresses.toAddrString(InetAddresses.forString("::1.2.3.4")));
  }

  public void testToUriStringIPv4() {
    String ipStr = "1.2.3.4";
    InetAddress ip = InetAddresses.forString(ipStr);
    assertEquals("1.2.3.4", InetAddresses.toUriString(ip));
  }

  public void testToUriStringIPv6() {