CEF/ergo
1
0
Fork 0
forked from External/ergo
Code Pull requests Activity

refactor [dk]lines, implement #144

Browse source
This commit is contained in:
Shivaram Lingamneni 2019-01-22 05:01:01 -05:00
parent f154ea9583
commit 6bdc6af186
6 changed files with 563 additions and 397 deletions
Download patch file Download diff file Expand all files Collapse all files

99
irc/utils/net_test.go
View file

@ -4,8 +4,16 @@
package utils
import "net"
import "reflect"
import "testing"
func assertEqual(supplied, expected interface{}, t *testing.T) {
if !reflect.DeepEqual(supplied, expected) {
t.Errorf("expected %v but got %v", expected, supplied)
}
}
// hostnames from https://github.com/DanielOaks/irc-parser-tests
var (
goodHostnames = []string{
@ -47,3 +55,94 @@ func TestIsHostname(t *testing.T) {
}
}
}
func TestNormalizeToNet(t *testing.T) {
a := net.ParseIP("8.8.8.8")
b := net.ParseIP("8.8.4.4")
if a == nil || b == nil {
panic("something has gone very wrong")
}
aNetwork := NormalizeIPToNet(a)
bNetwork := NormalizeIPToNet(b)
assertEqual(aNetwork.Contains(a), true, t)
assertEqual(bNetwork.Contains(b), true, t)
assertEqual(aNetwork.Contains(b), false, t)
assertEqual(bNetwork.Contains(a), false, t)
c := net.ParseIP("2001:4860:4860::8888")
d := net.ParseIP("2001:db8::1")
if c == nil || d == nil {
panic("something has gone very wrong")
}
cNetwork := NormalizeIPToNet(c)
dNetwork := NormalizeIPToNet(d)
assertEqual(cNetwork.Contains(c), true, t)
assertEqual(dNetwork.Contains(d), true, t)
assertEqual(dNetwork.Contains(c), false, t)
assertEqual(dNetwork.Contains(a), false, t)
assertEqual(cNetwork.Contains(b), false, t)
assertEqual(aNetwork.Contains(c), false, t)
assertEqual(bNetwork.Contains(c), false, t)
assertEqual(NetToNormalizedString(aNetwork), "8.8.8.8", t)
assertEqual(NetToNormalizedString(bNetwork), "8.8.4.4", t)
assertEqual(NetToNormalizedString(cNetwork), "2001:4860:4860::8888", t)
assertEqual(NetToNormalizedString(dNetwork), "2001:db8::1", t)
}
func TestNormalizedNetToString(t *testing.T) {
_, network, err := net.ParseCIDR("8.8.0.0/16")
if err != nil {
panic(err)
}
assertEqual(NetToNormalizedString(*network), "8.8.0.0/16", t)
normalized := NormalizeNet(*network)
assertEqual(normalized.Contains(net.ParseIP("8.8.4.4")), true, t)
assertEqual(normalized.Contains(net.ParseIP("1.1.1.1")), false, t)
assertEqual(NetToNormalizedString(normalized), "8.8.0.0/16", t)
_, network, err = net.ParseCIDR("8.8.4.4/32")
if err != nil {
panic(err)
}
assertEqual(NetToNormalizedString(*network), "8.8.4.4", t)
normalized = NormalizeNet(*network)
assertEqual(normalized.Contains(net.ParseIP("8.8.4.4")), true, t)
assertEqual(normalized.Contains(net.ParseIP("8.8.8.8")), false, t)
assertEqual(NetToNormalizedString(normalized), "8.8.4.4", t)
}
func TestNormalizedNet(t *testing.T) {
_, network, err := net.ParseCIDR("::ffff:8.8.4.4/128")
assertEqual(err, nil, t)
assertEqual(NetToNormalizedString(*network), "8.8.4.4", t)
normalizedNet := NormalizeIPToNet(net.ParseIP("8.8.4.4"))
assertEqual(NetToNormalizedString(normalizedNet), "8.8.4.4", t)
_, network, err = net.ParseCIDR("::ffff:8.8.0.0/112")
assertEqual(err, nil, t)
assertEqual(NetToNormalizedString(*network), "8.8.0.0/16", t)
_, v4Network, err := net.ParseCIDR("8.8.0.0/16")
assertEqual(err, nil, t)
normalizedNet = NormalizeNet(*v4Network)
assertEqual(NetToNormalizedString(normalizedNet), "8.8.0.0/16", t)
}
func TestNormalizedNetFromString(t *testing.T) {
network, err := NormalizedNetFromString("8.8.4.4/16")
assertEqual(err, nil, t)
assertEqual(NetToNormalizedString(network), "8.8.0.0/16", t)
assertEqual(network.Contains(net.ParseIP("8.8.8.8")), true, t)
network, err = NormalizedNetFromString("2001:0db8::1")
assertEqual(err, nil, t)
assertEqual(NetToNormalizedString(network), "2001:db8::1", t)
assertEqual(network.Contains(net.ParseIP("2001:0db8::1")), true, t)
}