| package util |
| |
| /* |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| http://www.apache.org/licenses/LICENSE-2.0 |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| */ |
| |
| // Package rfc contains functions implementing RFC 7234, 2616, and other RFCs. |
| // When changing functions, be sure they still conform to the corresponding RFC. |
| // When adding symbols, document the RFC and section they correspond to. |
| |
| import ( |
| "fmt" |
| "net" |
| "testing" |
| ) |
| |
| func TestCoalesceIPs(t *testing.T) { |
| ips := []net.IP{ |
| net.ParseIP("192.168.1.1"), |
| net.ParseIP("192.168.1.2"), |
| net.ParseIP("192.168.1.3"), |
| net.ParseIP("192.168.2.1"), |
| net.ParseIP("192.168.2.2"), |
| net.ParseIP("192.168.2.3"), |
| net.ParseIP("192.168.2.4"), |
| } |
| |
| nets := CoalesceIPs(ips, 2, 24) |
| |
| for _, ipnet := range nets { |
| if ipnet.String() != "192.168.1.0/24" && ipnet.String() != "192.168.2.0/24" { |
| t.Errorf("expected '192.168.1.0/24' and '192.168.2.0/24', actual: %+v\n", ipnet) |
| } |
| } |
| |
| nets = CoalesceIPs(nil, 0, 0) |
| if nets != nil { |
| t.Errorf("expected nil output when passing in no IPs, got: %+v", nets) |
| } |
| nets = CoalesceIPs([]net.IP{}, 0, 0) |
| if nets != nil { |
| t.Errorf("expected nil output when passing in no IPs, got: %+v", nets) |
| } |
| } |
| |
| func TestCoalesceIPsSmallerThanNum(t *testing.T) { |
| ips := []net.IP{ |
| net.ParseIP("192.168.1.1"), |
| net.ParseIP("192.168.1.2"), |
| net.ParseIP("192.168.1.3"), |
| net.ParseIP("192.168.2.1"), |
| net.ParseIP("192.168.2.2"), |
| net.ParseIP("192.168.2.3"), |
| net.ParseIP("192.168.2.4"), |
| } |
| |
| nets := CoalesceIPs(ips, 4, 24) |
| |
| expecteds := map[string]struct{}{ |
| "192.168.1.1/32": {}, |
| "192.168.1.2/32": {}, |
| "192.168.1.3/32": {}, |
| "192.168.2.0/24": {}, |
| } |
| |
| for _, ipnet := range nets { |
| if _, ok := expecteds[ipnet.String()]; !ok { |
| t.Errorf("expected: %+v actual: %+v\n", expecteds, ipnet) |
| } |
| delete(expecteds, ipnet.String()) |
| } |
| } |
| |
| func TestCoalesceIPsV6(t *testing.T) { |
| ips := []net.IP{ |
| net.ParseIP("2001:db8::1"), |
| net.ParseIP("2001:db8::2"), |
| net.ParseIP("2001:db8::3"), |
| net.ParseIP("2001:db8::4:1"), |
| net.ParseIP("2001:db8::4:2"), |
| net.ParseIP("2001:db8::4:3"), |
| } |
| |
| nets := CoalesceIPs(ips, 3, 112) |
| |
| expecteds := map[string]struct{}{ |
| "2001:db8::/112": {}, |
| "2001:db8::4:0/112": {}, |
| } |
| |
| for _, ipnet := range nets { |
| if _, ok := expecteds[ipnet.String()]; !ok { |
| t.Errorf("expected: %+v actual: %+v\n", expecteds, ipnet) |
| } |
| delete(expecteds, ipnet.String()) |
| } |
| } |
| |
| func TestCoalesceIPsV6SmallerThanNum(t *testing.T) { |
| ips := []net.IP{ |
| net.ParseIP("2001:db8::1"), |
| net.ParseIP("2001:db8::2"), |
| net.ParseIP("2001:db8::3"), |
| net.ParseIP("2001:db8::4:1"), |
| net.ParseIP("2001:db8::4:2"), |
| net.ParseIP("2001:db8::4:3"), |
| net.ParseIP("2001:db8::4:4"), |
| } |
| |
| nets := CoalesceIPs(ips, 4, 112) |
| |
| expecteds := map[string]struct{}{ |
| "2001:db8::1/128": {}, |
| "2001:db8::2/128": {}, |
| "2001:db8::3/128": {}, |
| "2001:db8::4:0/112": {}, |
| } |
| |
| for _, ipnet := range nets { |
| if _, ok := expecteds[ipnet.String()]; !ok { |
| t.Errorf("expected: %+v actual: %+v\n", expecteds, ipnet) |
| } |
| delete(expecteds, ipnet.String()) |
| } |
| } |
| |
| func TestRangeStr(t *testing.T) { |
| inputExpecteds := map[string]string{ |
| "192.168.1.0/24": "192.168.1.0-192.168.1.255", |
| "192.168.1.0/16": "192.168.0.0-192.168.255.255", |
| "192.168.1.42/32": "192.168.1.42", |
| "2001:db8::4:42/128": "2001:db8::4:42", |
| "2001:db8::4:0/112": "2001:db8::4:0-2001:db8::4:ffff", |
| } |
| for input, expected := range inputExpecteds { |
| _, ipn, err := net.ParseCIDR(input) |
| if err != nil { |
| t.Fatal(err.Error()) |
| } |
| |
| // t.Errorf("ipn: " + ipn.String()) |
| |
| actual := RangeStr(ipn) |
| if expected != actual { |
| t.Errorf("expected: '" + expected + "' actual '" + actual + "'") |
| } |
| } |
| } |
| |
| func TestFirstIP(t *testing.T) { |
| inputExpecteds := map[string]string{ |
| "192.168.1.0/24": "192.168.1.0", |
| "192.168.1.0/16": "192.168.0.0", |
| "192.168.1.42/32": "192.168.1.42", |
| "2001:db8::4:42/128": "2001:db8::4:42", |
| "2001:db8::4:0/112": "2001:db8::4:0", |
| } |
| for input, expected := range inputExpecteds { |
| _, ipn, err := net.ParseCIDR(input) |
| if err != nil { |
| t.Fatal(err.Error()) |
| } |
| |
| // t.Errorf("ipn: " + ipn.String()) |
| |
| actual := FirstIP(ipn).String() |
| if expected != actual { |
| t.Errorf("expected: '" + expected + "' actual '" + actual + "'") |
| } |
| } |
| } |
| |
| func TestLastIP(t *testing.T) { |
| inputExpecteds := map[string]string{ |
| "192.168.1.0/24": "192.168.1.255", |
| "192.168.1.0/16": "192.168.255.255", |
| "192.168.1.42/32": "192.168.1.42", |
| "2001:db8::4:42/128": "2001:db8::4:42", |
| "2001:db8::4:0/112": "2001:db8::4:ffff", |
| } |
| for input, expected := range inputExpecteds { |
| _, ipn, err := net.ParseCIDR(input) |
| if err != nil { |
| t.Fatal(err.Error()) |
| } |
| |
| // t.Errorf("ipn: " + ipn.String()) |
| |
| actual := LastIP(ipn).String() |
| if expected != actual { |
| t.Errorf("expected: '" + expected + "' actual '" + actual + "'") |
| } |
| } |
| } |
| |
| func TestIP4ToNum(t *testing.T) { |
| var tests = []struct { |
| ip string |
| number uint32 |
| }{ |
| {"127.0.0.1", uint32(2130706433)}, |
| {"127.0.0.4", uint32(2130706436)}, |
| {"127.255.255.255", uint32(2147483647)}, |
| } |
| for _, tt := range tests { |
| t.Run(tt.ip, func(t *testing.T) { |
| n, err := IP4ToNum(tt.ip) |
| if err != nil { |
| t.Errorf("unexpected error: %v", err) |
| |
| } |
| if n != tt.number { |
| t.Errorf("got %v, want %v", n, tt.number) |
| } |
| }) |
| } |
| |
| _, err := IP4ToNum("invalid") |
| if err == nil { |
| t.Error("Expected an error passing invalid input, but didn't get one") |
| } |
| _, err = IP4ToNum("127.0.0.invalid") |
| if err == nil { |
| t.Error("Expected an error passing invalid input, but didn't get one") |
| } |
| } |
| |
| func TestIP4InRange(t *testing.T) { |
| var tests = []struct { |
| ip string |
| ipRange string |
| inRange bool |
| }{ |
| {"111.0.0.1", "127.0.0.0-127.255.255.255", false}, |
| {"128.0.0.1", "127.0.0.0-127.255.255.255", false}, |
| {"127.0.0.1", "127.0.0.0-127.255.255.255", true}, |
| {"127.0.0.1", "127.0.0.1", true}, |
| } |
| for _, tt := range tests { |
| t.Run(fmt.Sprintf("%v in range %v", tt.ip, tt.inRange), func(t *testing.T) { |
| exists, err := IP4InRange(tt.ip, tt.ipRange) |
| if err != nil { |
| t.Errorf("unexpected error: %v", err) |
| |
| } |
| if exists != tt.inRange { |
| t.Errorf("got %v, want %v", exists, tt.inRange) |
| } |
| }) |
| } |
| |
| _, err := IP4InRange("127.0.0.1", "127.0.0.0-127.0.0.2-127.0.1.2") |
| if err == nil { |
| t.Error("Expected an error passing an invalid range, but didn't get one") |
| } |
| _, err = IP4InRange("invalid", "127.0.0.0-127.0.0.2") |
| if err == nil { |
| t.Error("Expected an error passing an invalid ip, but didn't get one") |
| } |
| _, err = IP4InRange("127.0.0.1", "invalid-127.0.0.2") |
| if err == nil { |
| t.Error("Expected an error passing an invalid range start, but didn't get one") |
| } |
| _, err = IP4InRange("127.0.0.1", "127.0.0.0-invalid") |
| if err == nil { |
| t.Error("Expected an error passing an invalid range end, but didn't get one") |
| } |
| |
| } |
