netaddress_test.go raw
1 package btcwire
2
3 import (
4 "bytes"
5 "errors"
6 "testing"
7 )
8
9 func TestNewNetAddress(t *testing.T) {
10 tests := []struct {
11 host string
12 port uint16
13 wantString string
14 }{
15 {"127.0.0.1", 8333, "127.0.0.1:8333"},
16 {"0.0.0.0", 0, "0.0.0.0:0"},
17 {"255.255.255.255", 65535, "255.255.255.255:65535"},
18 {"192.168.1.20", 18333, "192.168.1.20:18333"},
19 {"::1", 8333, "[::1]:8333"},
20 {"::", 0, "[::]:0"},
21 {"2001:db8::1", 18333, "[2001:db8::1]:18333"},
22 {"2001:0db8:0000:0000:0000:0000:0000:0001", 1, "[2001:db8::1]:1"},
23 {"::ffff:1.2.3.4", 8333, "1.2.3.4:8333"},
24 {"[::1]", 8333, "[::1]:8333"},
25 {"[2001:db8::1]", 2, "[2001:db8::1]:2"},
26 {"2001:DB8::1", 3, "[2001:db8::1]:3"},
27 {"1:2:3:4:5:6:7:8", 4, "[1:2:3:4:5:6:7:8]:4"},
28 {"1:2:3:4:5:6:1.2.3.4", 5, "[1:2:3:4:5:6:102:304]:5"},
29 {"2001:db8:0:0:1:0:0:1", 6, "[2001:db8::1:0:0:1]:6"},
30 {"fe80::", 7, "[fe80::]:7"},
31 }
32 for _, tc := range tests {
33 t.Run(tc.host, func(t *testing.T) {
34 addr, err := NewNetAddress(tc.host, tc.port)
35 if err != nil {
36 t.Fatalf("NewNetAddress(%q): %v", tc.host, err)
37 }
38 if got := addr.String(); got != tc.wantString {
39 t.Fatalf("String() = %q, want %q", got, tc.wantString)
40 }
41 })
42 }
43 }
44
45 func TestNewNetAddressIPv4Mapped(t *testing.T) {
46 addr, err := NewNetAddress("127.0.0.1", 8333)
47 if err != nil {
48 t.Fatalf("NewNetAddress: %v", err)
49 }
50 want := [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 127, 0, 0, 1}
51 if addr.IP != want {
52 t.Fatalf("IP = %x, want %x", addr.IP, want)
53 }
54 if got := addr.IPString(); got != "127.0.0.1" {
55 t.Fatalf("IPString() = %q, want %q", got, "127.0.0.1")
56 }
57 }
58
59 func TestNewNetAddressErrors(t *testing.T) {
60 hosts := []string{
61 "",
62 "1.2.3",
63 "1.2.3.4.5",
64 "1.2.3.256",
65 "1.2.3.-1",
66 "1.2.3.04",
67 "example.com",
68 ":::",
69 "1::2::3",
70 "1:2:3:4:5:6:7:8:9",
71 "12345::1",
72 "::g",
73 "[::1",
74 }
75 for _, host := range hosts {
76 t.Run(host, func(t *testing.T) {
77 if _, err := NewNetAddress(host, 1); !errors.Is(err, ErrInvalidAddress) {
78 t.Fatalf("NewNetAddress(%q) error = %v, want ErrInvalidAddress", host, err)
79 }
80 })
81 }
82 }
83
84 func TestNetAddressWire(t *testing.T) {
85 addr, err := NewNetAddress("127.0.0.1", 8080)
86 if err != nil {
87 t.Fatalf("NewNetAddress: %v", err)
88 }
89 addr.Services = ServiceNodeNetwork | ServiceNodeCompactFilters
90 var e Encoder
91 addr.encode(&e)
92 want := []byte{
93 // Services, little endian: 1 | 1<<6 = 0x41.
94 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
95 // IPv4-mapped 127.0.0.1.
96 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
97 0x00, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x01,
98 // Port 8080 big endian.
99 0x1f, 0x90,
100 }
101 if !bytes.Equal(e.Bytes(), want) {
102 t.Fatalf("encoded = %x, want %x", e.Bytes(), want)
103 }
104 var got NetAddress
105 d := NewDecoder(want)
106 if err := got.decode(d); err != nil {
107 t.Fatalf("decode: %v", err)
108 }
109 if got != *addr {
110 t.Fatalf("decoded %+v, want %+v", got, *addr)
111 }
112 }
113
114 func TestNetAddressWireRoundTrip(t *testing.T) {
115 hosts := []string{
116 "127.0.0.1", "10.0.0.255", "::1", "::", "2001:db8::dead:beef",
117 "::ffff:192.168.1.1", "fe80::1:2:3:4",
118 }
119 for _, host := range hosts {
120 addr, err := NewNetAddress(host, 8333)
121 if err != nil {
122 t.Fatalf("NewNetAddress(%q): %v", host, err)
123 }
124 addr.Services = ServiceNodeWitness
125 var e Encoder
126 addr.encode(&e)
127 var got NetAddress
128 d := NewDecoder(e.Bytes())
129 if err := got.decode(d); err != nil {
130 t.Fatalf("%s: decode: %v", host, err)
131 }
132 if got != *addr {
133 t.Fatalf("%s: decoded %+v, want %+v", host, got, *addr)
134 }
135 if d.Remaining() != 0 {
136 t.Fatalf("%s: %d bytes left", host, d.Remaining())
137 }
138 }
139 }
140
141 func TestNetAddressDecodeTruncated(t *testing.T) {
142 addr, err := NewNetAddress("127.0.0.1", 8333)
143 if err != nil {
144 t.Fatalf("NewNetAddress: %v", err)
145 }
146 var e Encoder
147 addr.encode(&e)
148 full := e.Bytes()
149 for n := 0; n < len(full); n++ {
150 var got NetAddress
151 if err := got.decode(NewDecoder(full[:n])); err == nil {
152 t.Fatalf("decoding %d of %d bytes succeeded", n, len(full))
153 }
154 }
155 }
156
157 func TestNetAddressIsZero(t *testing.T) {
158 var zero NetAddress
159 if !zero.IsZero() {
160 t.Fatal("zero NetAddress is not IsZero")
161 }
162 zero.Services = ServiceNodeNetwork
163 if !zero.IsZero() {
164 t.Fatal("services alone should not make an address non-zero")
165 }
166 addr := mustAddress(t, "127.0.0.1", 0)
167 if addr.IsZero() {
168 t.Fatal("address with non-zero IP reported IsZero")
169 }
170 addr = mustAddress(t, "0.0.0.0", 1)
171 if addr.IsZero() {
172 t.Fatal("address with non-zero port reported IsZero")
173 }
174 }
175