Write unit tests

README.md

 # go-ping
 [![GoDoc](https://godoc.org/github.com/sparrc/go-ping?status.svg)](https://godoc.org/github.com/sparrc/go-ping)
+[![Circle CI](https://circleci.com/gh/sparrc/go-ping.svg?style=svg)](https://circleci.com/gh/sparrc/go-ping)
 
 ICMP Ping library for Go, inspired by
 [go-fastping](https://github.com/tatsushid/go-fastping)

ping.go

@@ -201,8 +201,16 @@ type Statistics struct {
 
 // SetIPAddr sets the ip address of the target host.
 func (p *Pinger) SetIPAddr(ipaddr *net.IPAddr) {
+	var ipv4 bool
+	if isIPv4(ipaddr.IP) {
+		ipv4 = true
+	} else if isIPv6(ipaddr.IP) {
+		ipv4 = false
+	}
+
 	p.ipaddr = ipaddr
 	p.addr = ipaddr.String()
+	p.ipv4 = ipv4
 }
 
 // IPAddr returns the ip address of the target host.
@@ -213,12 +221,13 @@ func (p *Pinger) IPAddr() *net.IPAddr {
 // SetAddr resolves and sets the ip address of the target host, addr can be a
 // DNS name like "www.google.com" or IP like "127.0.0.1".
 func (p *Pinger) SetAddr(addr string) error {
-	ipaddr, err := net.ResolveIPAddr("ip4:icmp", addr)
+	ipaddr, err := net.ResolveIPAddr("ip", addr)
 	if err != nil {
 		return err
 	}
+
+	p.SetIPAddr(ipaddr)
 	p.addr = addr
-	p.ipaddr = ipaddr
 	return nil
 }
 

ping_test.go

+package ping
+
+import (
+	"net"
+	"testing"
+	"time"
+)
+
+func TestNewPingerValid(t *testing.T) {
+	googleaddr, err := net.ResolveIPAddr("ip", "www.google.com")
+	if err != nil {
+		t.Fatal("Can't resolve www.google.com, can't run tests")
+	}
+
+	p, err := NewPinger("www.google.com")
+	AssertNoError(t, err)
+	AssertEqualStrings(t, "www.google.com", p.Addr())
+	// DNS names should resolve into IP addresses
+	AssertNotEqualStrings(t, "www.google.com", p.IPAddr().String())
+	AssertTrue(t, isIPv4(p.IPAddr().IP))
+	AssertFalse(t, p.Privileged())
+	// Test that SetPrivileged works
+	p.SetPrivileged(true)
+	AssertTrue(t, p.Privileged())
+	// Test setting to ipv4 address
+	err = p.SetAddr("www.google.com")
+	AssertTrue(t, p.IPAddr().IP.Equal(googleaddr.IP))
+	AssertNoError(t, err)
+	AssertTrue(t, isIPv4(p.IPAddr().IP))
+	// Test setting to ipv6 address
+	err = p.SetAddr("ipv6.google.com")
+	AssertNoError(t, err)
+	AssertTrue(t, isIPv6(p.IPAddr().IP))
+
+	p, err = NewPinger("localhost")
+	AssertNoError(t, err)
+	AssertEqualStrings(t, "localhost", p.Addr())
+	// DNS names should resolve into IP addresses
+	AssertNotEqualStrings(t, "localhost", p.IPAddr().String())
+	AssertTrue(t, isIPv4(p.IPAddr().IP))
+	AssertFalse(t, p.Privileged())
+	// Test that SetPrivileged works
+	p.SetPrivileged(true)
+	AssertTrue(t, p.Privileged())
+	// Test setting to ipv4 address
+	err = p.SetAddr("www.google.com")
+	AssertTrue(t, p.IPAddr().IP.Equal(googleaddr.IP))
+	AssertNoError(t, err)
+	AssertTrue(t, isIPv4(p.IPAddr().IP))
+	// Test setting to ipv6 address
+	err = p.SetAddr("ipv6.google.com")
+	AssertNoError(t, err)
+	AssertTrue(t, isIPv6(p.IPAddr().IP))
+
+	p, err = NewPinger("127.0.0.1")
+	AssertNoError(t, err)
+	AssertEqualStrings(t, "127.0.0.1", p.Addr())
+	AssertTrue(t, isIPv4(p.IPAddr().IP))
+	AssertFalse(t, p.Privileged())
+	// Test that SetPrivileged works
+	p.SetPrivileged(true)
+	AssertTrue(t, p.Privileged())
+	// Test setting to ipv4 address
+	err = p.SetAddr("www.google.com")
+	AssertTrue(t, p.IPAddr().IP.Equal(googleaddr.IP))
+	AssertNoError(t, err)
+	AssertTrue(t, isIPv4(p.IPAddr().IP))
+	// Test setting to ipv6 address
+	err = p.SetAddr("ipv6.google.com")
+	AssertNoError(t, err)
+	AssertTrue(t, isIPv6(p.IPAddr().IP))
+
+	p, err = NewPinger("ipv6.google.com")
+	AssertNoError(t, err)
+	AssertEqualStrings(t, "ipv6.google.com", p.Addr())
+	// DNS names should resolve into IP addresses
+	AssertNotEqualStrings(t, "ipv6.google.com", p.IPAddr().String())
+	AssertTrue(t, isIPv6(p.IPAddr().IP))
+	AssertFalse(t, p.Privileged())
+	// Test that SetPrivileged works
+	p.SetPrivileged(true)
+	AssertTrue(t, p.Privileged())
+	// Test setting to ipv4 address
+	err = p.SetAddr("www.google.com")
+	AssertTrue(t, p.IPAddr().IP.Equal(googleaddr.IP))
+	AssertNoError(t, err)
+	AssertTrue(t, isIPv4(p.IPAddr().IP))
+	// Test setting to ipv6 address
+	err = p.SetAddr("ipv6.google.com")
+	AssertNoError(t, err)
+	AssertTrue(t, isIPv6(p.IPAddr().IP))
+
+	// ipv6 localhost:
+	p, err = NewPinger("::1")
+	AssertNoError(t, err)
+	AssertEqualStrings(t, "::1", p.Addr())
+	AssertTrue(t, isIPv6(p.IPAddr().IP))
+	AssertFalse(t, p.Privileged())
+	// Test that SetPrivileged works
+	p.SetPrivileged(true)
+	AssertTrue(t, p.Privileged())
+	// Test setting to ipv4 address
+	err = p.SetAddr("www.google.com")
+	AssertTrue(t, p.IPAddr().IP.Equal(googleaddr.IP))
+	AssertNoError(t, err)
+	AssertTrue(t, isIPv4(p.IPAddr().IP))
+	// Test setting to ipv6 address
+	err = p.SetAddr("ipv6.google.com")
+	AssertNoError(t, err)
+	AssertTrue(t, isIPv6(p.IPAddr().IP))
+}
+
+func TestNewPingerInvalid(t *testing.T) {
+	_, err := NewPinger("127.0.0.0.1")
+	AssertError(t, err, "127.0.0.0.1")
+
+	_, err = NewPinger("127..0.0.1")
+	AssertError(t, err, "127..0.0.1")
+
+	_, err = NewPinger("wtf")
+	AssertError(t, err, "wtf")
+
+	_, err = NewPinger(":::1")
+	AssertError(t, err, ":::1")
+
+	_, err = NewPinger("ipv5.google.com")
+	AssertError(t, err, "ipv5.google.com")
+}
+
+func TestSetIPAddr(t *testing.T) {
+	googleaddr, err := net.ResolveIPAddr("ip", "www.google.com")
+	if err != nil {
+		t.Fatal("Can't resolve www.google.com, can't run tests")
+	}
+
+	// Create a localhost ipv4 pinger
+	p, err := NewPinger("localhost")
+	AssertNoError(t, err)
+	AssertEqualStrings(t, "localhost", p.Addr())
+
+	// set IPAddr to google
+	p.SetIPAddr(googleaddr)
+	AssertEqualStrings(t, googleaddr.String(), p.Addr())
+}
+
+func TestStatisticsSunny(t *testing.T) {
+	// Create a localhost ipv4 pinger
+	p, err := NewPinger("localhost")
+	AssertNoError(t, err)
+	AssertEqualStrings(t, "localhost", p.Addr())
+
+	p.PacketsSent = 10
+	p.PacketsRecv = 10
+	p.rtts = []time.Duration{
+		time.Duration(1000),
+		time.Duration(1000),
+		time.Duration(1000),
+		time.Duration(1000),
+		time.Duration(1000),
+		time.Duration(1000),
+		time.Duration(1000),
+		time.Duration(1000),
+		time.Duration(1000),
+		time.Duration(1000),
+	}
+
+	stats := p.Statistics()
+	if stats.PacketsRecv != 10 {
+		t.Errorf("Expected %v, got %v", 10, stats.PacketsRecv)
+	}
+	if stats.PacketsSent != 10 {
+		t.Errorf("Expected %v, got %v", 10, stats.PacketsSent)
+	}
+	if stats.PacketLoss != 0 {
+		t.Errorf("Expected %v, got %v", 0, stats.PacketLoss)
+	}
+	if stats.MinRtt != time.Duration(1000) {
+		t.Errorf("Expected %v, got %v", time.Duration(1000), stats.MinRtt)
+	}
+	if stats.MaxRtt != time.Duration(1000) {
+		t.Errorf("Expected %v, got %v", time.Duration(1000), stats.MaxRtt)
+	}
+	if stats.AvgRtt != time.Duration(1000) {
+		t.Errorf("Expected %v, got %v", time.Duration(1000), stats.AvgRtt)
+	}
+	if stats.StdDevRtt != time.Duration(0) {
+		t.Errorf("Expected %v, got %v", time.Duration(0), stats.StdDevRtt)
+	}
+}
+
+func TestStatisticsLossy(t *testing.T) {
+	// Create a localhost ipv4 pinger
+	p, err := NewPinger("localhost")
+	AssertNoError(t, err)
+	AssertEqualStrings(t, "localhost", p.Addr())
+
+	p.PacketsSent = 20
+	p.PacketsRecv = 10
+	p.rtts = []time.Duration{
+		time.Duration(10),
+		time.Duration(1000),
+		time.Duration(1000),
+		time.Duration(10000),
+		time.Duration(1000),
+		time.Duration(800),
+		time.Duration(1000),
+		time.Duration(40),
+		time.Duration(100000),
+		time.Duration(1000),
+	}
+
+	stats := p.Statistics()
+	if stats.PacketsRecv != 10 {
+		t.Errorf("Expected %v, got %v", 10, stats.PacketsRecv)
+	}
+	if stats.PacketsSent != 20 {
+		t.Errorf("Expected %v, got %v", 20, stats.PacketsSent)
+	}
+	if stats.PacketLoss != 50 {
+		t.Errorf("Expected %v, got %v", 50, stats.PacketLoss)
+	}
+	if stats.MinRtt != time.Duration(10) {
+		t.Errorf("Expected %v, got %v", time.Duration(10), stats.MinRtt)
+	}
+	if stats.MaxRtt != time.Duration(100000) {
+		t.Errorf("Expected %v, got %v", time.Duration(100000), stats.MaxRtt)
+	}
+	if stats.AvgRtt != time.Duration(11585) {
+		t.Errorf("Expected %v, got %v", time.Duration(11585), stats.AvgRtt)
+	}
+	if stats.StdDevRtt != time.Duration(29603) {
+		t.Errorf("Expected %v, got %v", time.Duration(29603), stats.StdDevRtt)
+	}
+}
+
+// Test helpers
+func AssertNoError(t *testing.T, err error) {
+	if err != nil {
+		t.Errorf("Expected No Error but got %s", err)
+	}
+}
+
+func AssertError(t *testing.T, err error, info string) {
+	if err == nil {
+		t.Errorf("Expected Error but got %s, %s", err, info)
+	}
+}
+
+func AssertEqualStrings(t *testing.T, expected, actual string) {
+	if expected != actual {
+		t.Errorf("Expected %s, got %s", expected, actual)
+	}
+}
+
+func AssertNotEqualStrings(t *testing.T, expected, actual string) {
+	if expected == actual {
+		t.Errorf("Expected %s, got %s", expected, actual)
+	}
+}
+
+func AssertTrue(t *testing.T, b bool) {
+	if !b {
+		t.Error("Expected True, got False")
+	}
+}
+
+func AssertFalse(t *testing.T, b bool) {
+	if b {
+		t.Error("Expected False, got True")
+	}
+}