Merge pull request #6 from github/more-tests

Add some more tests

Author: mhagger

.gitignore

@@ -1,3 +1,2 @@
 /.gopath
 /bin
-/vendor

Gopkg.lock

@@ -2,3 +2,8 @@
 #
 # Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
 # for detailed Gopkg.toml documentation.
+
+[prune]
+  unused-packages = true
+  go-tests = true
+  non-go = true

Gopkg.toml

@@ -21,7 +21,7 @@ all: bin/git-sizer
 .PHONY: bin/git-sizer
 bin/git-sizer:
 	mkdir -p bin
-	$(GO) build $(GOFLAGS) -o $@ $(PACKAGE)
+	cd $(GOPATH)/src/$(PACKAGE) && $(GO) build $(GOFLAGS) -o $(ROOTDIR)/$@ $(PACKAGE)
 
 # Cross-compile for a bunch of common platforms. Note that this
 # doesn't work with USE_ISATTY:
@@ -43,7 +43,7 @@ define PLATFORM_template =
 .PHONY: bin/git-sizer-$(1)-$(2)$(3)
 bin/git-sizer-$(1)-$(2)$(3):
 	mkdir -p bin
-	GOOS=$(1) GOARCH=$(2) $$(GO) build $$(GOFLAGS) -o $$@ $$(PACKAGE)
+	cd $$(GOPATH)/src/$$(PACKAGE) && GOOS=$(1) GOARCH=$(2) $$(GO) build $$(GOFLAGS) -o $$(ROOTDIR)/$$@ $$(PACKAGE)
 endef
 
 $(eval $(call PLATFORM_template,linux,amd64))
@@ -60,7 +60,7 @@ test: bin/git-sizer gotest
 
 .PHONY: gotest
 gotest:
-	$(GO) test -timeout 60s $(GOFLAGS) ./...
+	cd $(GOPATH)/src/$(PACKAGE) && $(GO) test -timeout 60s $(GOFLAGS) ./...
 
 .PHONY: gofmt
 gofmt:

Makefile

@@ -1,4 +1,4 @@
-package sizes
+package counts
 
 import (
 	"math"
@@ -33,8 +33,8 @@ func (n1 *Count32) Increment(n2 Count32) {
 	*n1 = n1.Plus(n2)
 }
 
-// Adjust `*n1` to be `max(*n1, n2)` and return true iff n2 was
-// bigger. Favor `*n1` if they are equal.
+// AdjustMaxIfNecessary adjusts `*n1` to be `max(*n1, n2)`. Return
+// true iff `n2` was greater than `*n1`.
 func (n1 *Count32) AdjustMaxIfNecessary(n2 Count32) bool {
 	if n2 > *n1 {
 		*n1 = n2
@@ -44,8 +44,8 @@ func (n1 *Count32) AdjustMaxIfNecessary(n2 Count32) bool {
 	}
 }
 
-// Adjust `*n1` to be `max(*n1, n2)` and return true iff n2 was
-// bigger. Favor `n2` if they are equal.
+// AdjustMaxIfPossible adjusts `*n1` to be `max(*n1, n2)`. Return true
+// iff `n2` was greater than or equal to `*n1`.
 func (n1 *Count32) AdjustMaxIfPossible(n2 Count32) bool {
 	if n2 >= *n1 {
 		*n1 = n2
@@ -81,8 +81,8 @@ func (n1 *Count64) Increment(n2 Count64) {
 	*n1 = n1.Plus(n2)
 }
 
-// Adjust `*n1` to be `max(*n1, n2)` and return true iff n2 was
-// bigger. Favor `*n1` if they are equal.
+// AdjustMaxIfNecessary adjusts `*n1` to be `max(*n1, n2)`. Return
+// true iff `n2` was greater than `*n1`.
 func (n1 *Count64) AdjustMaxIfNecessary(n2 Count64) bool {
 	if n2 > *n1 {
 		*n1 = n2
@@ -92,8 +92,8 @@ func (n1 *Count64) AdjustMaxIfNecessary(n2 Count64) bool {
 	}
 }
 
-// Adjust `*n1` to be `max(*n1, n2)` and return true iff n2 was
-// bigger. Favor `n2` if they are equal.
+// AdjustMaxIfPossible adjusts `*n1` to be `max(*n1, n2)`. Return true
+// iff `n2` was greater than or equal to `*n1`.
 func (n1 *Count64) AdjustMaxIfPossible(n2 Count64) bool {
 	if n2 > *n1 {
 		*n1 = n2

sizes/count.go renamed to counts/counts.go

@@ -0,0 +1,35 @@
+package counts_test
+
+import (
+	"testing"
+
+	"github.com/github/git-sizer/counts"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCount32(t *testing.T) {
+	assert := assert.New(t)
+
+	c := counts.NewCount32(0)
+	assert.Equalf(uint64(0), c.ToUint64(), "NewCount32(0).ToUint64() should be 0")
+
+	c.Increment(counts.Count32(0xf0000000))
+	assert.Equalf(uint64(0xf0000000), c.ToUint64(), "Count32(0xf0000000).ToUint64() value")
+
+	c.Increment(counts.Count32(0xf0000000))
+	assert.Equalf(uint64(0xffffffff), c.ToUint64(), "Count32(0xffffffff).ToUint64() value")
+}
+
+func TestCount64(t *testing.T) {
+	assert := assert.New(t)
+
+	c := counts.NewCount64(0)
+	assert.Equalf(uint64(0), c.ToUint64(), "NewCount64(0).ToUint64() should be 0")
+
+	c.Increment(counts.Count64(0xf000000000000000))
+	assert.Equalf(uint64(0xf000000000000000), c.ToUint64(), "Count64(0xf000000000000000).ToUint64() value")
+
+	c.Increment(counts.Count64(0xf000000000000000))
+	assert.Equalf(uint64(0xffffffffffffffff), c.ToUint64(), "Count64(0xffffffffffffffff).ToUint64() value")
+}

counts/counts_test.go

@@ -0,0 +1,89 @@
+package counts
+
+import (
+	"fmt"
+	"math"
+)
+
+type Prefix struct {
+	Name       string
+	Multiplier uint64
+}
+
+type Humaner interface {
+	Human([]Prefix, string) (string, string)
+	ToUint64() uint64
+}
+
+var MetricPrefixes []Prefix
+
+func init() {
+	MetricPrefixes = []Prefix{
+		{"", 1},
+		{"k", 1e3},
+		{"M", 1e6},
+		{"G", 1e9},
+		{"T", 1e12},
+		{"P", 1e15},
+	}
+}
+
+var BinaryPrefixes []Prefix
+
+func init() {
+	BinaryPrefixes = []Prefix{
+		{"", 1 << (10 * 0)},
+		{"Ki", 1 << (10 * 1)},
+		{"Mi", 1 << (10 * 2)},
+		{"Gi", 1 << (10 * 3)},
+		{"Ti", 1 << (10 * 4)},
+		{"Pi", 1 << (10 * 5)},
+	}
+}
+
+// Format values, aligned, in `len(unit) + 10` or fewer characters
+// (except for extremely large numbers).
+func Human(n uint64, prefixes []Prefix, unit string) (string, string) {
+	prefix := prefixes[0]
+	wholePart := n
+	for _, p := range prefixes {
+		w := n / p.Multiplier
+		if w >= 1 {
+			wholePart = w
+			prefix = p
+		}
+	}
+
+	if prefix.Multiplier == 1 {
+		return fmt.Sprintf("%d", n), unit
+	} else {
+		mantissa := float64(n) / float64(prefix.Multiplier)
+		var format string
+
+		if wholePart >= 100 {
+			// `mantissa` can actually be up to 1023.999.
+			format = "%.0f"
+		} else if wholePart >= 10 {
+			format = "%.1f"
+		} else {
+			format = "%.2f"
+		}
+		return fmt.Sprintf(format, mantissa), prefix.Name + unit
+	}
+}
+
+func (n Count32) Human(prefixes []Prefix, unit string) (string, string) {
+	if n == math.MaxUint32 {
+		return "∞", unit
+	} else {
+		return Human(uint64(n), prefixes, unit)
+	}
+}
+
+func (n Count64) Human(prefixes []Prefix, unit string) (string, string) {
+	if n == math.MaxUint64 {
+		return "∞", unit
+	} else {
+		return Human(uint64(n), prefixes, unit)
+	}
+}

counts/human.go

@@ -0,0 +1,128 @@
+package counts_test
+
+import (
+	"testing"
+
+	"github.com/github/git-sizer/counts"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type humanTest struct {
+	n            uint64
+	number, unit string
+}
+
+func TestMetric(t *testing.T) {
+	assert := assert.New(t)
+
+	for _, ht := range []humanTest{
+		{0, "0", "cd"},
+		{1, "1", "cd"},
+		{999, "999", "cd"},
+		{1000, "1.00", "kcd"},
+		{1094, "1.09", "kcd"},
+		{1096, "1.10", "kcd"},
+		{9990, "9.99", "kcd"},
+		{9999, "10.00", "kcd"}, // Not ideal, but ok
+		{10000, "10.0", "kcd"},
+		{10060, "10.1", "kcd"},
+		{99999, "100.0", "kcd"}, // Not ideal, but ok
+		{100000, "100", "kcd"},
+		{999999, "1000", "kcd"}, // Not ideal, but ok
+		{1000000, "1.00", "Mcd"},
+		{9999999, "10.00", "Mcd"}, // Not ideal, but ok
+		{10000000, "10.0", "Mcd"},
+		{99999999, "100.0", "Mcd"}, // Not ideal, but ok
+		{100000000, "100", "Mcd"},
+		{999999999, "1000", "Mcd"}, // Not ideal, but ok
+		{1000000000, "1.00", "Gcd"},
+		{9999999999, "10.00", "Gcd"}, // Not ideal, but ok
+		{10000000000, "10.0", "Gcd"},
+		{99999999999, "100.0", "Gcd"}, // Not ideal, but ok
+		{100000000000, "100", "Gcd"},
+		{999999999999, "1000", "Gcd"}, // Not ideal, but ok
+		{1000000000000, "1.00", "Tcd"},
+		{999999999999999, "1000", "Tcd"}, // Not ideal, but ok
+		{1000000000000000, "1.00", "Pcd"},
+		{999999999999999999, "1000", "Pcd"},
+		{1000000000000000000, "1000", "Pcd"},
+		{9999999999999999999, "10000", "Pcd"},
+		{10000000000000000000, "10000", "Pcd"},
+		{12345678900000000000, "12346", "Pcd"}, // Not ideal, but ok
+		{0xffffffffffffffff, "18447", "Pcd"},   // Not ideal, but ok
+	} {
+		number, unit := counts.Human(ht.n, counts.MetricPrefixes, "cd")
+		assert.Equalf(ht.number, number, "Number for %d in metric", ht.n)
+		assert.Equalf(ht.unit, unit, "Unit for %d in metric", ht.n)
+		if ht.n < 0xffffffff {
+			c := counts.NewCount32(ht.n)
+			number, unit := c.Human(counts.MetricPrefixes, "cd")
+			assert.Equalf(ht.number, number, "Number for Count32(%d) in metric", ht.n)
+			assert.Equalf(ht.unit, unit, "Unit for Count32(%d) in metric", ht.n)
+		}
+		if ht.n < 0xffffffffffffffff {
+			c := counts.NewCount64(ht.n)
+			number, unit := c.Human(counts.MetricPrefixes, "cd")
+			assert.Equalf(ht.number, number, "Number for Count64(%d) in metric", ht.n)
+			assert.Equalf(ht.unit, unit, "Unit for Count64(%d) in metric", ht.n)
+		}
+	}
+}
+
+func TestBinary(t *testing.T) {
+	assert := assert.New(t)
+
+	for _, ht := range []humanTest{
+		{0, "0", "B"},
+		{1, "1", "B"},
+		{1023, "1023", "B"},
+		{1024, "1.00", "KiB"},
+		{1234, "1.21", "KiB"},
+		{1048575, "1024", "KiB"}, // Not ideal, but ok
+		{1048576, "1.00", "MiB"},
+		{1073741823, "1024", "MiB"}, // Not ideal, but ok
+		{1073741824, "1.00", "GiB"},
+		{1099511627775, "1024", "GiB"}, // Not ideal, but ok
+		{1099511627776, "1.00", "TiB"},
+		{1125899906842623, "1024", "TiB"}, // Not ideal, but ok
+		{1125899906842624, "1.00", "PiB"},
+		{1152921504606846975, "1024", "PiB"},
+		{1152921504606846976, "1024", "PiB"},
+		{0xffffffffffffffff, "16384", "PiB"},
+	} {
+		number, unit := counts.Human(ht.n, counts.BinaryPrefixes, "B")
+		assert.Equalf(ht.number, number, "Number for %d in binary", ht.n)
+		assert.Equalf(ht.unit, unit, "Unit for %d in binary", ht.n)
+		if ht.n < 0xffffffff {
+			c := counts.NewCount32(ht.n)
+			number, unit := c.Human(counts.BinaryPrefixes, "B")
+			assert.Equalf(ht.number, number, "Number for Count32(%d) in binary", ht.n)
+			assert.Equalf(ht.unit, unit, "Unit for Count32(%d) in binary", ht.n)
+		}
+		if ht.n < 0xffffffffffffffff {
+			c := counts.NewCount64(ht.n)
+			number, unit := c.Human(counts.BinaryPrefixes, "B")
+			assert.Equalf(ht.number, number, "Number for Count64(%d) in binary", ht.n)
+			assert.Equalf(ht.unit, unit, "Unit for Count64(%d) in binary", ht.n)
+		}
+	}
+}
+
+func TestLimits32(t *testing.T) {
+	assert := assert.New(t)
+
+	c := counts.NewCount32(0xffffffff)
+	number, unit := c.Human(counts.MetricPrefixes, "cd")
+	assert.Equalf("∞", number, "Number for Count32(%d) in metric", c.ToUint64())
+	assert.Equalf("cd", unit, "Unit for Count32(%d) in metric", c.ToUint64())
+}
+
+func TestLimits64(t *testing.T) {
+	assert := assert.New(t)
+
+	c := counts.NewCount64(0xffffffffffffffff)
+	number, unit := c.Human(counts.MetricPrefixes, "B")
+	assert.Equalf("∞", number, "Number for Count64(%d) in metric", c.ToUint64())
+	assert.Equalf("B", unit, "Unit for Count64(%d) in metric", c.ToUint64())
+}