// Copyright 2020 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package netip import ( "bytes" "encoding" "encoding/json" "strings" "testing" ) var ( mustPrefix = MustParsePrefix mustIP = MustParseAddr ) func TestPrefixValid(t *testing.T) { v4 := MustParseAddr("1.2.3.4") v6 := MustParseAddr("::1") tests := []struct { ipp Prefix want bool }{ {Prefix{v4, -2}, false}, {Prefix{v4, -1}, false}, {Prefix{v4, 0}, true}, {Prefix{v4, 32}, true}, {Prefix{v4, 33}, false}, {Prefix{v6, -2}, false}, {Prefix{v6, -1}, false}, {Prefix{v6, 0}, true}, {Prefix{v6, 32}, true}, {Prefix{v6, 128}, true}, {Prefix{v6, 129}, false}, {Prefix{Addr{}, -2}, false}, {Prefix{Addr{}, -1}, false}, {Prefix{Addr{}, 0}, false}, {Prefix{Addr{}, 32}, false}, {Prefix{Addr{}, 128}, false}, } for _, tt := range tests { got := tt.ipp.IsValid() if got != tt.want { t.Errorf("(%v).IsValid() = %v want %v", tt.ipp, got, tt.want) } } } var nextPrevTests = []struct { ip Addr next Addr prev Addr }{ {mustIP("10.0.0.1"), mustIP("10.0.0.2"), mustIP("10.0.0.0")}, {mustIP("10.0.0.255"), mustIP("10.0.1.0"), mustIP("10.0.0.254")}, {mustIP("127.0.0.1"), mustIP("127.0.0.2"), mustIP("127.0.0.0")}, {mustIP("254.255.255.255"), mustIP("255.0.0.0"), mustIP("254.255.255.254")}, {mustIP("255.255.255.255"), Addr{}, mustIP("255.255.255.254")}, {mustIP("0.0.0.0"), mustIP("0.0.0.1"), Addr{}}, {mustIP("::"), mustIP("::1"), Addr{}}, {mustIP("::%x"), mustIP("::1%x"), Addr{}}, {mustIP("::1"), mustIP("::2"), mustIP("::")}, {mustIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"), Addr{}, mustIP("ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe")}, } func TestIPNextPrev(t *testing.T) { doNextPrev(t) for _, ip := range []Addr{ mustIP("0.0.0.0"), mustIP("::"), } { got := ip.Prev() if !got.isZero() { t.Errorf("IP(%v).Prev = %v; want zero", ip, got) } } var allFF [16]byte for i := range allFF { allFF[i] = 0xff } for _, ip := range []Addr{ mustIP("255.255.255.255"), AddrFrom16(allFF), } { got := ip.Next() if !got.isZero() { t.Errorf("IP(%v).Next = %v; want zero", ip, got) } } } func BenchmarkIPNextPrev(b *testing.B) { for i := 0; i < b.N; i++ { doNextPrev(b) } } func doNextPrev(t testing.TB) { for _, tt := range nextPrevTests { gnext, gprev := tt.ip.Next(), tt.ip.Prev() if gnext != tt.next { t.Errorf("IP(%v).Next = %v; want %v", tt.ip, gnext, tt.next) } if gprev != tt.prev { t.Errorf("IP(%v).Prev = %v; want %v", tt.ip, gprev, tt.prev) } if !tt.ip.Next().isZero() && tt.ip.Next().Prev() != tt.ip { t.Errorf("IP(%v).Next.Prev = %v; want %v", tt.ip, tt.ip.Next().Prev(), tt.ip) } if !tt.ip.Prev().isZero() && tt.ip.Prev().Next() != tt.ip { t.Errorf("IP(%v).Prev.Next = %v; want %v", tt.ip, tt.ip.Prev().Next(), tt.ip) } } } func TestIPBitLen(t *testing.T) { tests := []struct { ip Addr want int }{ {Addr{}, 0}, {mustIP("0.0.0.0"), 32}, {mustIP("10.0.0.1"), 32}, {mustIP("::"), 128}, {mustIP("fed0::1"), 128}, {mustIP("::ffff:10.0.0.1"), 128}, } for _, tt := range tests { got := tt.ip.BitLen() if got != tt.want { t.Errorf("BitLen(%v) = %d; want %d", tt.ip, got, tt.want) } } } func TestPrefixContains(t *testing.T) { tests := []struct { ipp Prefix ip Addr want bool }{ {mustPrefix("9.8.7.6/0"), mustIP("9.8.7.6"), true}, {mustPrefix("9.8.7.6/16"), mustIP("9.8.7.6"), true}, {mustPrefix("9.8.7.6/16"), mustIP("9.8.6.4"), true}, {mustPrefix("9.8.7.6/16"), mustIP("9.9.7.6"), false}, {mustPrefix("9.8.7.6/32"), mustIP("9.8.7.6"), true}, {mustPrefix("9.8.7.6/32"), mustIP("9.8.7.7"), false}, {mustPrefix("9.8.7.6/32"), mustIP("9.8.7.7"), false}, {mustPrefix("::1/0"), mustIP("::1"), true}, {mustPrefix("::1/0"), mustIP("::2"), true}, {mustPrefix("::1/127"), mustIP("::1"), true}, {mustPrefix("::1/127"), mustIP("::2"), false}, {mustPrefix("::1/128"), mustIP("::1"), true}, {mustPrefix("::1/127"), mustIP("::2"), false}, // zones support {mustPrefix("::1%a/128"), mustIP("::1"), true}, // prefix zones are stripped... {mustPrefix("::1%a/128"), mustIP("::1%a"), false}, // but ip zones are not // invalid IP {mustPrefix("::1/0"), Addr{}, false}, {mustPrefix("1.2.3.4/0"), Addr{}, false}, // invalid Prefix {Prefix{mustIP("::1"), 129}, mustIP("::1"), false}, {Prefix{mustIP("1.2.3.4"), 33}, mustIP("1.2.3.4"), false}, {Prefix{Addr{}, 0}, mustIP("1.2.3.4"), false}, {Prefix{Addr{}, 32}, mustIP("1.2.3.4"), false}, {Prefix{Addr{}, 128}, mustIP("::1"), false}, // wrong IP family {mustPrefix("::1/0"), mustIP("1.2.3.4"), false}, {mustPrefix("1.2.3.4/0"), mustIP("::1"), false}, } for _, tt := range tests { got := tt.ipp.Contains(tt.ip) if got != tt.want { t.Errorf("(%v).Contains(%v) = %v want %v", tt.ipp, tt.ip, got, tt.want) } } } func TestParseIPError(t *testing.T) { tests := []struct { ip string errstr string }{ { ip: "localhost", }, { ip: "500.0.0.1", errstr: "field has value >255", }, { ip: "::gggg%eth0", errstr: "must have at least one digit", }, { ip: "fe80::1cc0:3e8c:119f:c2e1%", errstr: "zone must be a non-empty string", }, { ip: "%eth0", errstr: "missing IPv6 address", }, } for _, test := range tests { t.Run(test.ip, func(t *testing.T) { _, err := ParseAddr(test.ip) if err == nil { t.Fatal("no error") } if _, ok := err.(parseAddrError); !ok { t.Errorf("error type is %T, want parseIPError", err) } if test.errstr == "" { test.errstr = "unable to parse IP" } if got := err.Error(); !strings.Contains(got, test.errstr) { t.Errorf("error is missing substring %q: %s", test.errstr, got) } }) } } func TestParseAddrPort(t *testing.T) { tests := []struct { in string want AddrPort wantErr bool }{ {in: "1.2.3.4:1234", want: AddrPort{mustIP("1.2.3.4"), 1234}}, {in: "1.1.1.1:123456", wantErr: true}, {in: "1.1.1.1:-123", wantErr: true}, {in: "[::1]:1234", want: AddrPort{mustIP("::1"), 1234}}, {in: "[1.2.3.4]:1234", wantErr: true}, {in: "fe80::1:1234", wantErr: true}, {in: ":0", wantErr: true}, // if we need to parse this form, there should be a separate function that explicitly allows it } for _, test := range tests { t.Run(test.in, func(t *testing.T) { got, err := ParseAddrPort(test.in) if err != nil { if test.wantErr { return } t.Fatal(err) } if got != test.want { t.Errorf("got %v; want %v", got, test.want) } if got.String() != test.in { t.Errorf("String = %q; want %q", got.String(), test.in) } }) t.Run(test.in+"/AppendTo", func(t *testing.T) { got, err := ParseAddrPort(test.in) if err == nil { testAppendToMarshal(t, got) } }) // TextMarshal and TextUnmarshal mostly behave like // ParseAddrPort and String. Divergent behavior are handled in // TestAddrPortMarshalUnmarshal. t.Run(test.in+"/Marshal", func(t *testing.T) { var got AddrPort jsin := `"` + test.in + `"` err := json.Unmarshal([]byte(jsin), &got) if err != nil { if test.wantErr { return } t.Fatal(err) } if got != test.want { t.Errorf("got %v; want %v", got, test.want) } gotb, err := json.Marshal(got) if err != nil { t.Fatal(err) } if string(gotb) != jsin { t.Errorf("Marshal = %q; want %q", string(gotb), jsin) } }) } } func TestAddrPortMarshalUnmarshal(t *testing.T) { tests := []struct { in string want AddrPort }{ {"", AddrPort{}}, } for _, test := range tests { t.Run(test.in, func(t *testing.T) { orig := `"` + test.in + `"` var ipp AddrPort if err := json.Unmarshal([]byte(orig), &ipp); err != nil { t.Fatalf("failed to unmarshal: %v", err) } ippb, err := json.Marshal(ipp) if err != nil { t.Fatalf("failed to marshal: %v", err) } back := string(ippb) if orig != back { t.Errorf("Marshal = %q; want %q", back, orig) } testAppendToMarshal(t, ipp) }) } } type appendMarshaler interface { encoding.TextMarshaler AppendTo([]byte) []byte } // testAppendToMarshal tests that x's AppendTo and MarshalText methods yield the same results. // x's MarshalText method must not return an error. func testAppendToMarshal(t *testing.T, x appendMarshaler) { t.Helper() m, err := x.MarshalText() if err != nil { t.Fatalf("(%v).MarshalText: %v", x, err) } a := make([]byte, 0, len(m)) a = x.AppendTo(a) if !bytes.Equal(m, a) { t.Errorf("(%v).MarshalText = %q, (%v).AppendTo = %q", x, m, x, a) } } func TestIPv6Accessor(t *testing.T) { var a [16]byte for i := range a { a[i] = uint8(i) + 1 } ip := AddrFrom16(a) for i := range a { if got, want := ip.v6(uint8(i)), uint8(i)+1; got != want { t.Errorf("v6(%v) = %v; want %v", i, got, want) } } }