metrics: tests for resolve and more for isCompatible

Author: suyash

metrics_amd64_test.go

@@ -11,16 +11,63 @@ func TestIsCompatible64(t *testing.T) {
 		v      interface{}
 		result bool
 	}{
+		{Int32Type, math.MaxInt32 + 1, false},
+		{Int64Type, math.MaxInt32 + 1, true},
+		{Uint32Type, math.MaxInt32 + 1, true},
+		{Uint64Type, math.MaxInt32 + 1, true},
+
 		{Int32Type, math.MinInt32 - 1, false},
+		{Int64Type, math.MinInt32 - 1, true},
+		{Uint32Type, math.MinInt32 - 1, false},
+		{Uint64Type, math.MinInt32 - 1, false},
+
 		{Int32Type, math.MinInt64, false},
-		{Uint32Type, math.MaxUint32 + 1, false},
+		{Int64Type, math.MinInt64, true},
+		{Uint32Type, math.MinInt64, false},
+		{Uint64Type, math.MinInt64, false},
+
+		{Int32Type, math.MaxInt64, false},
+		{Int64Type, math.MaxInt64, true},
 		{Uint32Type, math.MaxInt64, false},
+		{Uint64Type, math.MaxInt64, true},
+
+		{Uint32Type, math.MaxUint32 + 1, false},
+		{Uint64Type, math.MaxUint32 + 1, true},
+
+		{Uint32Type, uint(math.MaxUint32 + 1), false},
+		{Uint64Type, uint(math.MaxUint32 + 1), true},
+
+		{Uint64Type, uint(math.MaxUint64), true},
+
+		{Uint64Type, uint64(math.MaxUint64), true},
+
+		{FloatType, math.MaxFloat32, true},
+		{FloatType, -math.MaxFloat32, true},
+		{DoubleType, math.MaxFloat32, true},
+		{DoubleType, -math.MaxFloat32, true},
+
+		// we cannot test for `math.MaxFloat32 + 1`
+		// or even `math.MaxFloat32 + math.MaxUint64`
+		// because in floating point those aren't significant
+		// enough additions, so the comparison will be equal
+		// for more http://stackoverflow.com/q/17588419/3673043
+
+		{FloatType, math.MaxFloat32 * 2, false},
+		{DoubleType, math.MaxFloat32 * 2, true},
+
+		{FloatType, math.MaxFloat64, false},
+		{FloatType, -math.MaxFloat64, false},
+
+		{DoubleType, math.MaxFloat64, true},
+		{DoubleType, -math.MaxFloat64, true},
 	}
 
-	for _, c := range cases {
+	for i, c := range cases {
 		r := c.t.IsCompatible(c.v)
 		if r != c.result {
-			t.Errorf("%v.IsCompatible(%v(%T)) should be %v, not %v", c.t, c.v, c.v, c.result, r)
+			f := math.MaxFloat32
+			println((f + 1) > f)
+			t.Errorf("case %v: %v.IsCompatible(%v(%T)) should be %v, not %v", i+1, c.t, c.v, c.v, c.result, r)
 		}
 	}
 }

metrics_test.go

@@ -5,6 +5,8 @@ import (
 	"testing"
 )
 
+// only tests that work on 32 bit architectures or both go here
+// tests only working on 64 bit architectures go in _amd64_test.go
 func TestIsCompatible(t *testing.T) {
 	cases := []struct {
 		t      MetricType
@@ -15,16 +17,34 @@ func TestIsCompatible(t *testing.T) {
 		{Int64Type, -1, true},
 		{Uint64Type, -1, false},
 		{Uint32Type, -1, false},
-		{Int32Type, 2147483648, false},
-		{Int64Type, 2147483648, true},
-		{Int32Type, int32(-2147483648), true},
-		{Int64Type, int64(-2147483648), true},
-		{Uint32Type, int32(-2147483648), false},
-		{Uint64Type, int64(-2147483648), false},
+
+		{Int32Type, math.MinInt32, true},
+		{Int64Type, math.MinInt32, true},
+		{Uint32Type, math.MinInt32, false},
+		{Uint64Type, math.MinInt32, false},
+
+		{Int32Type, int32(math.MinInt32), true},
+		{Int64Type, int64(math.MinInt32), true},
+		{Uint32Type, int32(math.MinInt32), false},
+		{Uint64Type, int64(math.MinInt32), false},
+
+		{Int32Type, math.MaxInt32, true},
+		{Int64Type, math.MaxInt32, true},
+		{Uint32Type, math.MaxInt32, true},
+		{Uint64Type, math.MaxInt32, true},
+
+		{Int32Type, int32(math.MaxInt32), true},
+		{Int64Type, int64(math.MaxInt32), true},
+		{Uint32Type, int32(math.MaxInt32), false},
+		{Uint64Type, int64(math.MaxInt32), false},
+
+		{Int64Type, int64(math.MaxInt64), true},
+
 		{Uint32Type, uint32(math.MaxUint32), true},
 		{Uint64Type, uint64(math.MaxUint32), true},
+
 		{Uint32Type, uint(math.MaxUint32), true},
-		{Uint64Type, uint(math.MaxUint64), true},
+
 		{Uint32Type, math.MaxUint32, true},
 		{Uint64Type, uint64(math.MaxUint64), true},
 	}
@@ -36,3 +56,38 @@ func TestIsCompatible(t *testing.T) {
 		}
 	}
 }
+
+func TestResolve(t *testing.T) {
+	cases := []struct {
+		t           MetricType
+		val, resval interface{}
+	}{
+		{Int32Type, 10, int32(10)},
+		{Int64Type, 10, int64(10)},
+		{Uint32Type, 10, uint32(10)},
+		{Uint64Type, 10, uint64(10)},
+
+		{Int32Type, int32(10), int32(10)},
+		{Int64Type, int64(10), int64(10)},
+		{Uint32Type, uint32(10), uint32(10)},
+		{Uint64Type, uint64(10), uint64(10)},
+
+		{Uint32Type, uint(10), uint32(10)},
+		{Uint64Type, uint(10), uint64(10)},
+
+		{Uint32Type, uint32(10), uint32(10)},
+		{Uint64Type, uint64(10), uint64(10)},
+
+		{FloatType, 3.14, float32(3.14)},
+		{DoubleType, 3.14, float64(3.14)},
+
+		{FloatType, float32(3.14), float32(3.14)},
+		{DoubleType, float64(3.14), float64(3.14)},
+	}
+
+	for _, c := range cases {
+		if c.t.resolve(c.val) != c.resval {
+			t.Errorf("expected %T to resolve to %T", c.val, c.resval)
+		}
+	}
+}