want := &http.Request{
		Method:     "GET",
		Host:       "example.com",
		URL:        &url.URL{Path: "/"},
		Header:     http.Header{},
		Proto:      "HTTP/1.1",
		ProtoMajor: 1,
		ProtoMinor: 1,
		RemoteAddr: "192.0.2.1:1234",
		RequestURI: "/",
	}
	got.Body = nil // before DeepEqual
	want = want.WithContext(context.Background())
	if !reflect.DeepEqual(got, want) {

		realIP       string
		forwardedFor string
		remoteAddr   string
		expected     []string
	}{{
		name:     "no headers, missing remoteAddr",
		expected: []string{},
	}, {
		name:       "no headers, just remoteAddr host:port",
		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"},
	}, {

	testCases := []struct {
		name       string
		remoteAddr string
		expected   bool
	}{
		{
			name:       "Localhost IPv4",
			remoteAddr: "127.0.0.1:8080",
			expected:   true,
		},
		{
			name:       "Localhost IPv6",
			remoteAddr: "[::1]:8080",
			expected:   true,
		},
		{
			name:       "Private IPv4",
			remoteAddr: "192.168.1.100:8080",
			expected:   false,
		},
		{

	remoteAddr := ctx.RemoteAddress()
	xfccHeader := ctx.Header(xfccparser.ForwardedClientCertHeader)
	if len(remoteAddr) == 0 || len(xfccHeader) == 0 {
		return nil, fmt.Errorf("caller from %s does not have Xfcc header", remoteAddr)
	}
	// First check if client is trusted client so that we can "trust" the Xfcc Header.
	if !isTrustedAddress(remoteAddr, features.TrustedGatewayCIDR) {

	}

	if remoteIP, remotePort, err := net.SplitHostPort(req.RemoteAddr); err == nil {
		env = append(env, "REMOTE_ADDR="+remoteIP, "REMOTE_HOST="+remoteIP, "REMOTE_PORT="+remotePort)
	} else {
		// could not parse ip:port, let's use whole RemoteAddr and leave REMOTE_PORT undefined
		env = append(env, "REMOTE_ADDR="+req.RemoteAddr, "REMOTE_HOST="+req.RemoteAddr)
	}

	if hostDomain, _, err := net.SplitHostPort(req.Host); err == nil {

			},
			ExpectedMap: publicAddressCIDRMap,
		},

		{
			Request: http.Request{
				RemoteAddr: internalIP,
			},
			ExpectedMap: internalAddressCIDRMap,
		},
		{
			Request: http.Request{
				RemoteAddr: publicIP,
			},
			ExpectedMap: publicAddressCIDRMap,
		},
		{
			Request: http.Request{
				RemoteAddr: "invalidIP",
			},
			ExpectedMap: publicAddressCIDRMap,
		},
	}

			if err != nil {
				t.Fatal(err)
			}
			defer c.Close()
			if c.LocalAddr().Network() != network || c.RemoteAddr().Network() != network {
				t.Fatalf("got %s->%s; want %s->%s", c.LocalAddr().Network(), c.RemoteAddr().Network(), network, network)
			}
			c.SetDeadline(time.Now().Add(someTimeout))
			c.SetReadDeadline(time.Now().Add(someTimeout))

		"REQUEST_METHOD":  "GET",
		"REQUEST_URI":     "/path?a=b",
		"CONTENT_LENGTH":  "123",
		"REMOTE_ADDR":     "5.6.7.8",
	}
	req, err := RequestFromMap(env)
	if err != nil {
		t.Fatalf("RequestFromMap: %v", err)
	}
	if e, g := "5.6.7.8:0", req.RemoteAddr; e != g {
		t.Errorf("RemoteAddr: got %q; want %q", g, e)
	}
}

func TestResponse(t *testing.T) {
	var tests = []struct {

	} else {
		testIsTCPAddr(t, "LocalAddr", c.LocalAddr())
		testIsTCPAddr(t, "RemoteAddr", c.RemoteAddr())
	}
	if c, ok := newFileConn(newFD("udp", -1)).(*UDPConn); !ok {
		t.Errorf("newFileConn: udp conn type mismatch: %T", c)
	} else {
		testIsUDPAddr(t, "LocalAddr", c.LocalAddr())
		testIsUDPAddr(t, "RemoteAddr", c.RemoteAddr())
	}
}

func testIsTCPAddr(t *testing.T, method string, addr Addr) {

		}
	}

	return addr
}

// GetSourceIPRaw retrieves the IP from the request headers
// and falls back to r.RemoteAddr when necessary.
// however returns without bracketing.
func GetSourceIPRaw(r *http.Request) string {
	addr := GetSourceIPFromHeaders(r)
	if addr == "" {
		addr = r.RemoteAddr
	}

	// Default to remote address if headers not set.
	raddr, _, _ := net.SplitHostPort(addr)
	if raddr == "" {