Convert all the asserts to test tables
diff --git a/bytes_test.go b/bytes_test.go
index 8dd737b..50aede9 100644
--- a/bytes_test.go
+++ b/bytes_test.go
@@ -4,12 +4,6 @@
"testing"
)
-func assert(t *testing.T, name string, got interface{}, expected interface{}) {
- if got != expected {
- t.Errorf("Expected %#v for %s, got %#v", expected, name, got)
- }
-}
-
func TestByteParsing(t *testing.T) {
tests := []struct {
in string
@@ -75,85 +69,57 @@
}
func TestBytes(t *testing.T) {
- assert(t, "bytes(0)", Bytes(0), "0B")
- assert(t, "bytes(1)", Bytes(1), "1B")
- assert(t, "bytes(803)", Bytes(803), "803B")
- assert(t, "bytes(999)", Bytes(999), "999B")
-}
+ testList{
+ {"bytes(0)", Bytes(0), "0B"},
+ {"bytes(1)", Bytes(1), "1B"},
+ {"bytes(803)", Bytes(803), "803B"},
+ {"bytes(999)", Bytes(999), "999B"},
-func TestK(t *testing.T) {
- assert(t, "bytes(1024)", Bytes(1024), "1.0KB")
- assert(t, "bytes(1MB - 1)", Bytes(MByte-Byte), "1000KB")
-}
+ {"bytes(1024)", Bytes(1024), "1.0KB"},
+ {"bytes(1MB - 1)", Bytes(MByte - Byte), "1000KB"},
-func TestM(t *testing.T) {
- assert(t, "bytes(1MB)", Bytes(1024*1024), "1.0MB")
- assert(t, "bytes(1GB - 1K)", Bytes(GByte-KByte), "1000MB")
-}
+ {"bytes(1MB)", Bytes(1024 * 1024), "1.0MB"},
+ {"bytes(1GB - 1K)", Bytes(GByte - KByte), "1000MB"},
-func TestG(t *testing.T) {
- assert(t, "bytes(1GB)", Bytes(GByte), "1.0GB")
- assert(t, "bytes(1TB - 1M)", Bytes(TByte-MByte), "1000GB")
-}
+ {"bytes(1GB)", Bytes(GByte), "1.0GB"},
+ {"bytes(1TB - 1M)", Bytes(TByte - MByte), "1000GB"},
-func TestT(t *testing.T) {
- assert(t, "bytes(1TB)", Bytes(TByte), "1.0TB")
- assert(t, "bytes(1PB - 1T)", Bytes(PByte-TByte), "999TB")
-}
+ {"bytes(1TB)", Bytes(TByte), "1.0TB"},
+ {"bytes(1PB - 1T)", Bytes(PByte - TByte), "999TB"},
-func TestP(t *testing.T) {
- assert(t, "bytes(1PB)", Bytes(PByte), "1.0PB")
- assert(t, "bytes(1PB - 1T)", Bytes(EByte-PByte), "999PB")
-}
+ {"bytes(1PB)", Bytes(PByte), "1.0PB"},
+ {"bytes(1PB - 1T)", Bytes(EByte - PByte), "999PB"},
-func TestE(t *testing.T) {
- assert(t, "bytes(1EB)", Bytes(EByte), "1.0EB")
- // Overflows.
- // assert(t, "bytes(1EB - 1P)", Bytes((KByte*EByte)-PByte), "1023EB")
-}
+ {"bytes(1EB)", Bytes(EByte), "1.0EB"},
+ // Overflows.
+ // {"bytes(1EB - 1P)", Bytes((KByte*EByte)-PByte), "1023EB"},
-func TestIIBytes(t *testing.T) {
- assert(t, "bytes(0)", IBytes(0), "0B")
- assert(t, "bytes(1)", IBytes(1), "1B")
- assert(t, "bytes(803)", IBytes(803), "803B")
- assert(t, "bytes(1023)", IBytes(1023), "1023B")
-}
+ {"bytes(0)", IBytes(0), "0B"},
+ {"bytes(1)", IBytes(1), "1B"},
+ {"bytes(803)", IBytes(803), "803B"},
+ {"bytes(1023)", IBytes(1023), "1023B"},
-func TestIK(t *testing.T) {
- assert(t, "bytes(1024)", IBytes(1024), "1.0KiB")
- assert(t, "bytes(1MB - 1)", IBytes(MiByte-IByte), "1024KiB")
-}
+ {"bytes(1024)", IBytes(1024), "1.0KiB"},
+ {"bytes(1MB - 1)", IBytes(MiByte - IByte), "1024KiB"},
-func TestIM(t *testing.T) {
- assert(t, "bytes(1MB)", IBytes(1024*1024), "1.0MiB")
- assert(t, "bytes(1GB - 1K)", IBytes(GiByte-KiByte), "1024MiB")
-}
+ {"bytes(1MB)", IBytes(1024 * 1024), "1.0MiB"},
+ {"bytes(1GB - 1K)", IBytes(GiByte - KiByte), "1024MiB"},
-func TestIG(t *testing.T) {
- assert(t, "bytes(1GB)", IBytes(GiByte), "1.0GiB")
- assert(t, "bytes(1TB - 1M)", IBytes(TiByte-MiByte), "1024GiB")
-}
+ {"bytes(1GB)", IBytes(GiByte), "1.0GiB"},
+ {"bytes(1TB - 1M)", IBytes(TiByte - MiByte), "1024GiB"},
-func TestIT(t *testing.T) {
- assert(t, "bytes(1TB)", IBytes(TiByte), "1.0TiB")
- assert(t, "bytes(1PB - 1T)", IBytes(PiByte-TiByte), "1023TiB")
-}
+ {"bytes(1TB)", IBytes(TiByte), "1.0TiB"},
+ {"bytes(1PB - 1T)", IBytes(PiByte - TiByte), "1023TiB"},
-func TestIP(t *testing.T) {
- assert(t, "bytes(1PB)", IBytes(PiByte), "1.0PiB")
- assert(t, "bytes(1PB - 1T)", IBytes(EiByte-PiByte), "1023PiB")
-}
+ {"bytes(1PB)", IBytes(PiByte), "1.0PiB"},
+ {"bytes(1PB - 1T)", IBytes(EiByte - PiByte), "1023PiB"},
-func TestIE(t *testing.T) {
- assert(t, "bytes(1EiB)", IBytes(EiByte), "1.0EiB")
- // Overflows.
- // assert(t, "bytes(1EB - 1P)", IBytes((KIByte*EIByte)-PiByte), "1023EB")
-}
+ {"bytes(1EiB)", IBytes(EiByte), "1.0EiB"},
+ // Overflows.
+ // {"bytes(1EB - 1P)", IBytes((KIByte*EIByte)-PiByte), "1023EB"},
-func TestIHalf(t *testing.T) {
- assert(t, "bytes(5.5GiB)", IBytes(5.5*GiByte), "5.5GiB")
-}
+ {"bytes(5.5GiB)", IBytes(5.5 * GiByte), "5.5GiB"},
-func TestHalf(t *testing.T) {
- assert(t, "bytes(5.5GB)", Bytes(5.5*GByte), "5.5GB")
+ {"bytes(5.5GB)", Bytes(5.5 * GByte), "5.5GB"},
+ }.validate(t)
}
diff --git a/comma_test.go b/comma_test.go
index a4c72fd..887a8e6 100644
--- a/comma_test.go
+++ b/comma_test.go
@@ -5,27 +5,29 @@
)
func TestCommas(t *testing.T) {
- assert(t, "0", Comma(0), "0")
- assert(t, "10", Comma(10), "10")
- assert(t, "100", Comma(100), "100")
- assert(t, "1,000", Comma(1000), "1,000")
- assert(t, "10,000", Comma(10000), "10,000")
- assert(t, "100,000", Comma(100000), "100,000")
- assert(t, "10,000,000", Comma(10000000), "10,000,000")
- assert(t, "10,100,000", Comma(10100000), "10,100,000")
- assert(t, "10,010,000", Comma(10010000), "10,010,000")
- assert(t, "10,001,000", Comma(10001000), "10,001,000")
- assert(t, "123,456,789", Comma(123456789), "123,456,789")
- assert(t, "-123,456,789", Comma(-123456789), "-123,456,789")
- assert(t, "-10,100,000", Comma(-10100000), "-10,100,000")
- assert(t, "-10,010,000", Comma(-10010000), "-10,010,000")
- assert(t, "-10,001,000", Comma(-10001000), "-10,001,000")
- assert(t, "-10,000,000", Comma(-10000000), "-10,000,000")
- assert(t, "-100,000", Comma(-100000), "-100,000")
- assert(t, "-10,000", Comma(-10000), "-10,000")
- assert(t, "-1,000", Comma(-1000), "-1,000")
- assert(t, "-100", Comma(-100), "-100")
- assert(t, "-10", Comma(-10), "-10")
+ testList{
+ {"0", Comma(0), "0"},
+ {"10", Comma(10), "10"},
+ {"100", Comma(100), "100"},
+ {"1,000", Comma(1000), "1,000"},
+ {"10,000", Comma(10000), "10,000"},
+ {"100,000", Comma(100000), "100,000"},
+ {"10,000,000", Comma(10000000), "10,000,000"},
+ {"10,100,000", Comma(10100000), "10,100,000"},
+ {"10,010,000", Comma(10010000), "10,010,000"},
+ {"10,001,000", Comma(10001000), "10,001,000"},
+ {"123,456,789", Comma(123456789), "123,456,789"},
+ {"-123,456,789", Comma(-123456789), "-123,456,789"},
+ {"-10,100,000", Comma(-10100000), "-10,100,000"},
+ {"-10,010,000", Comma(-10010000), "-10,010,000"},
+ {"-10,001,000", Comma(-10001000), "-10,001,000"},
+ {"-10,000,000", Comma(-10000000), "-10,000,000"},
+ {"-100,000", Comma(-100000), "-100,000"},
+ {"-10,000", Comma(-10000), "-10,000"},
+ {"-1,000", Comma(-1000), "-1,000"},
+ {"-100", Comma(-100), "-100"},
+ {"-10", Comma(-10), "-10"},
+ }.validate(t)
}
func BenchmarkCommas(b *testing.B) {
diff --git a/common_test.go b/common_test.go
new file mode 100644
index 0000000..1684ae5
--- /dev/null
+++ b/common_test.go
@@ -0,0 +1,18 @@
+package humanize
+
+import (
+ "testing"
+)
+
+type testList []struct {
+ name, exp, got string
+}
+
+func (tl testList) validate(t *testing.T) {
+ for _, test := range tl {
+ if test.got != test.exp {
+ t.Errorf("On %v, expected %v, but got %v",
+ test.name, test.exp, test.got)
+ }
+ }
+}
diff --git a/ordinals_test.go b/ordinals_test.go
index 717c41d..51d85ee 100644
--- a/ordinals_test.go
+++ b/ordinals_test.go
@@ -5,16 +5,18 @@
)
func TestOrdinals(t *testing.T) {
- assert(t, "0", Ordinal(0), "0th")
- assert(t, "1", Ordinal(1), "1st")
- assert(t, "2", Ordinal(2), "2nd")
- assert(t, "3", Ordinal(3), "3rd")
- assert(t, "4", Ordinal(4), "4th")
- assert(t, "10", Ordinal(10), "10th")
- assert(t, "11", Ordinal(11), "11th")
- assert(t, "12", Ordinal(12), "12th")
- assert(t, "13", Ordinal(13), "13th")
- assert(t, "101", Ordinal(101), "101st")
- assert(t, "102", Ordinal(102), "102nd")
- assert(t, "103", Ordinal(103), "103rd")
+ testList{
+ {"0", Ordinal(0), "0th"},
+ {"1", Ordinal(1), "1st"},
+ {"2", Ordinal(2), "2nd"},
+ {"3", Ordinal(3), "3rd"},
+ {"4", Ordinal(4), "4th"},
+ {"10", Ordinal(10), "10th"},
+ {"11", Ordinal(11), "11th"},
+ {"12", Ordinal(12), "12th"},
+ {"13", Ordinal(13), "13th"},
+ {"101", Ordinal(101), "101st"},
+ {"102", Ordinal(102), "102nd"},
+ {"103", Ordinal(103), "103rd"},
+ }.validate(t)
}
