Change Humanable.ToUint64() to report whether it overflowed

Author: mhagger

counts/counts.go

@@ -14,8 +14,8 @@ func NewCount32(n uint64) Count32 {
 	return Count32(n)
 }
 
-func (n Count32) ToUint64() uint64 {
-	return uint64(n)
+func (n Count32) ToUint64() (uint64, bool) {
+	return uint64(n), n == math.MaxUint32
 }
 
 // Return the sum of two Count32s, capped at math.MaxUint32.
@@ -62,8 +62,8 @@ func NewCount64(n uint64) Count64 {
 	return Count64(n)
 }
 
-func (n Count64) ToUint64() uint64 {
-	return uint64(n)
+func (n Count64) ToUint64() (uint64, bool) {
+	return uint64(n), n == math.MaxUint64
 }
 
 // Return the sum of two Count64s, capped at math.MaxUint64.

counts/counts_test.go

@@ -11,25 +11,43 @@ import (
 func TestCount32(t *testing.T) {
 	assert := assert.New(t)
 
+	var value uint64
+	var overflow bool
+
 	c := counts.NewCount32(0)
-	assert.Equalf(uint64(0), c.ToUint64(), "NewCount32(0).ToUint64() should be 0")
+	value, overflow = c.ToUint64()
+	assert.Equalf(uint64(0), value, "NewCount32(0).ToUint64() should be 0")
+	assert.False(overflow, "NewCount32(0).ToUint64() does not overflow")
 
 	c.Increment(counts.Count32(0xf0000000))
-	assert.Equalf(uint64(0xf0000000), c.ToUint64(), "Count32(0xf0000000).ToUint64() value")
+	value, overflow = c.ToUint64()
+	assert.Equalf(uint64(0xf0000000), value, "Count32(0xf0000000).ToUint64() value")
+	assert.False(overflow, "NewCount32(0xf0000000).ToUint64() does not overflow")
 
 	c.Increment(counts.Count32(0xf0000000))
-	assert.Equalf(uint64(0xffffffff), c.ToUint64(), "Count32(0xffffffff).ToUint64() value")
+	value, overflow = c.ToUint64()
+	assert.Equalf(uint64(0xffffffff), value, "Count32(0xffffffff).ToUint64() value")
+	assert.True(overflow, "NewCount32(0xffffffff).ToUint64() overflows")
 }
 
 func TestCount64(t *testing.T) {
 	assert := assert.New(t)
 
+	var value uint64
+	var overflow bool
+
 	c := counts.NewCount64(0)
-	assert.Equalf(uint64(0), c.ToUint64(), "NewCount64(0).ToUint64() should be 0")
+	value, overflow = c.ToUint64()
+	assert.Equalf(uint64(0), value, "NewCount64(0).ToUint64() should be 0")
+	assert.False(overflow, "NewCount64(0).ToUint64() does not overflow")
 
 	c.Increment(counts.Count64(0xf000000000000000))
-	assert.Equalf(uint64(0xf000000000000000), c.ToUint64(), "Count64(0xf000000000000000).ToUint64() value")
+	value, overflow = c.ToUint64()
+	assert.Equalf(uint64(0xf000000000000000), value, "Count64(0xf000000000000000).ToUint64() value")
+	assert.False(overflow, "NewCount64(0xf000000000000000).ToUint64() does not overflow")
 
 	c.Increment(counts.Count64(0xf000000000000000))
-	assert.Equalf(uint64(0xffffffffffffffff), c.ToUint64(), "Count64(0xffffffffffffffff).ToUint64() value")
+	value, overflow = c.ToUint64()
+	assert.Equalf(uint64(0xffffffffffffffff), value, "Count64(0xffffffffffffffff).ToUint64() value")
+	assert.True(overflow, "NewCount64(0xffffffffffffffff).ToUint64() overflows")
 }

counts/human.go

@@ -7,8 +7,12 @@ import (
 
 // A quantity that can be made human-readable using Human().
 type Humanable interface {
+	// Return the value and units as separate strings.
 	Human(Humaner, string) (string, string)
-	ToUint64() uint64
+
+	// Return the value as a uint64, and a boolean telling whether it
+	// overflowed.
+	ToUint64() (uint64, bool)
 }
 
 // An object that can format a Humanable in human-readable format.

counts/human_test.go

@@ -114,15 +114,15 @@ func TestLimits32(t *testing.T) {
 
 	c := counts.NewCount32(0xffffffff)
 	number, unit := c.Human(counts.Metric, "cd")
-	assert.Equalf("∞", number, "Number for Count32(%d) in metric", c.ToUint64())
-	assert.Equalf("cd", unit, "Unit for Count32(%d) in metric", c.ToUint64())
+	assert.Equalf("∞", number, "Number for Count32(0xffffffff) in metric")
+	assert.Equalf("cd", unit, "Unit for Count32(0xffffffff) in metric")
 }
 
 func TestLimits64(t *testing.T) {
 	assert := assert.New(t)
 
 	c := counts.NewCount64(0xffffffffffffffff)
 	number, unit := c.Human(counts.Metric, "B")
-	assert.Equalf("∞", number, "Number for Count64(%d) in metric", c.ToUint64())
-	assert.Equalf("B", unit, "Unit for Count64(%d) in metric", c.ToUint64())
+	assert.Equalf("∞", number, "Number for Count64(0xffffffffffffffff) in metric")
+	assert.Equalf("B", unit, "Unit for Count64(0xffffffffffffffff) in metric")
 }

sizes/output.go

@@ -159,7 +159,8 @@ func (l *item) Footnote(nameStyle NameStyle) string {
 // return the string that should be used as its "level of concern" and
 // `true`; otherwise, return `"", false`.
 func (l *item) levelOfConcern(threshold Threshold) (string, bool) {
-	alert := Threshold(float64(l.value.ToUint64()) / l.scale)
+	value, _ := l.value.ToUint64()
+	alert := Threshold(float64(value) / l.scale)
 	if alert < threshold {
 		return "", false
 	}