From dc11ac417b7bf8e6c1cd5fb2fbfcda94349828ab Mon Sep 17 00:00:00 2001 From: Ggicci Date: Wed, 27 Dec 2023 17:04:55 -0500 Subject: [PATCH] test: cover 100% internal package --- internal/stringable_test.go | 173 ++++++++++++++++++++++++++++++++---- 1 file changed, 157 insertions(+), 16 deletions(-) diff --git a/internal/stringable_test.go b/internal/stringable_test.go index 1919487..ac4ebf6 100644 --- a/internal/stringable_test.go +++ b/internal/stringable_test.go @@ -1,6 +1,7 @@ package internal import ( + "fmt" "reflect" "testing" "time" @@ -8,20 +9,6 @@ import ( "github.com/stretchr/testify/assert" ) -func TestString(t *testing.T) { - var s string - sv := (*String)(&s) - sv.FromString("Alice") - assert.Equal(t, "Alice", s) -} - -func TestInt(t *testing.T) { - var i int - iv := (*Int)(&i) - iv.FromString("18") - assert.Equal(t, 18, i) -} - func TestNewStringable_string(t *testing.T) { var s string = "hello" rvString := reflect.ValueOf(s) @@ -39,6 +26,81 @@ func TestNewStringable_string(t *testing.T) { assert.Equal(t, "world", s) } +func TestNewStringable_bool(t *testing.T) { + var b bool = true + rvBool := reflect.ValueOf(b) + assert.Panics(t, func() { + NewStringable(rvBool) + }) + + rvBoolPointer := reflect.ValueOf(&b) + sv, err := NewStringable(rvBoolPointer) + assert.NoError(t, err) + got, err := sv.ToString() + assert.NoError(t, err) + assert.Equal(t, "true", got) + sv.FromString("false") + assert.Equal(t, false, b) + + assert.Error(t, sv.FromString("hello")) +} + +func TestNewStringable_int(t *testing.T) { + testInteger[int](t, 2045, "hello") +} + +func TestNewStringable_int8(t *testing.T) { + testInteger[int8](t, int8(127), "128") +} + +func TestNewStringable_int16(t *testing.T) { + testInteger[int16](t, int16(32767), "32768") +} + +func TestNewStringable_int32(t *testing.T) { + testInteger[int32](t, int32(2147483647), "2147483648") +} + +func TestNewStringable_int64(t *testing.T) { + testInteger[int64](t, int64(9223372036854775807), "9223372036854775808") +} + +func TestNewStringable_uint(t *testing.T) { + testInteger[uint](t, uint(2045), "-1") +} + +func TestNewStringable_uint8(t *testing.T) { + testInteger[uint8](t, uint8(255), "256") +} + +func TestNewStringable_uint16(t *testing.T) { + testInteger[uint16](t, uint16(65535), "65536") +} + +func TestNewStringable_uint32(t *testing.T) { + testInteger[uint32](t, uint32(4294967295), "4294967296") +} + +func TestNewStringable_uint64(t *testing.T) { + testInteger[uint64](t, uint64(18446744073709551615), "18446744073709551616") +} + +func TestNewStringable_float32(t *testing.T) { + testInteger[float32](t, float32(3.1415926), "hello") +} + +func TestNewStringable_float64(t *testing.T) { + testInteger[float64](t, float64(3.14159265358979323846264338327950288419716939937510582097494459), "hello") +} + +func TestNewStringable_complex64(t *testing.T) { + testInteger[complex64](t, complex64(3.1415926+2.71828i), "hello") +} + +func TestNewStringable_complex128(t *testing.T) { + testInteger[complex128](t, complex128(3.14159265358979323846264338327950288419716939937510582097494459+2.71828182845904523536028747135266249775724709369995957496696763i), "hello") +} + func TestNewStringable_Time(t *testing.T) { var now = time.Now() rvTime := reflect.ValueOf(now) @@ -49,6 +111,85 @@ func TestNewStringable_Time(t *testing.T) { rvTimePointer := reflect.ValueOf(&now) sv, err := NewStringable(rvTimePointer) assert.NoError(t, err) - assert.NoError(t, sv.FromString("1991-11-10T08:00:00+08:00")) - assert.Equal(t, "1991-11-10T00:00:00Z", now.Format(time.RFC3339)) + + // RFC3339Nano + testTime(t, sv, "1991-11-10T08:00:00+08:00", time.Date(1991, 11, 10, 8, 0, 0, 0, time.FixedZone("Asia/Shanghai", +8*3600)), "1991-11-10T00:00:00Z") + // Date string + testTime(t, sv, "1991-11-10", time.Date(1991, 11, 10, 0, 0, 0, 0, time.UTC), "1991-11-10T00:00:00Z") + + // Unix timestamp + testTime(t, sv, "678088800", time.Date(1991, 6, 28, 6, 0, 0, 0, time.UTC), "1991-06-28T06:00:00Z") + + // Unix timestamp fraction + testTime(t, sv, "678088800.123456789", time.Date(1991, 6, 28, 6, 0, 0, 123456789, time.UTC), "1991-06-28T06:00:00.123456789Z") + + // Unsupported format + assert.Error(t, sv.FromString("hello")) +} + +func TestNewStringable_ByteSlice(t *testing.T) { + var b []byte = []byte("hello") + rvByteSlice := reflect.ValueOf(b) + assert.NotPanics(t, func() { + NewStringable(rvByteSlice) + }) + + rvByteSlicePointer := reflect.ValueOf(&b) + sv, err := NewStringable(rvByteSlicePointer) + assert.NoError(t, err) + got, err := sv.ToString() + assert.NoError(t, err) + assert.Equal(t, "aGVsbG8=", got) + + sv.FromString("d29ybGQ=") + assert.Equal(t, []byte("world"), b) + + assert.Error(t, sv.FromString("hello")) +} + +func TestNewStringable_ErrUnsupportedType(t *testing.T) { + type MyStruct struct{ Name string } + var s MyStruct + rvStruct := reflect.ValueOf(s) + assert.Panics(t, func() { + NewStringable(rvStruct) + }) + rvStructPointer := reflect.ValueOf(&s) + sv, err := NewStringable(rvStructPointer) + assert.ErrorIs(t, err, ErrUnsupportedType) + assert.Nil(t, sv) +} + +type Numeric interface { + int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64 | complex64 | complex128 +} + +func testInteger[T Numeric](t *testing.T, vSuccess T, invalidStr string) { + rv := reflect.ValueOf(vSuccess) + assert.Panics(t, func() { + NewStringable(rv) + }) + + rvPointer := reflect.ValueOf(&vSuccess) + sv, err := NewStringable(rvPointer) + assert.NoError(t, err) + got, err := sv.ToString() + assert.NoError(t, err) + assert.Equal(t, fmt.Sprintf("%v", vSuccess), got) + sv.FromString("2") + assert.Equal(t, T(2), vSuccess) + + assert.Error(t, sv.FromString(invalidStr)) +} + +func testTime(t *testing.T, sv Stringable, fromStr string, expected time.Time, expectedToStr string) { + assert.NoError(t, sv.FromString(fromStr)) + assert.True(t, equalTime(expected, time.Time(*sv.(*Time)))) + ts, err := sv.ToString() + assert.NoError(t, err) + assert.Equal(t, expectedToStr, ts) +} + +func equalTime(expected, actual time.Time) bool { + return expected.UTC() == actual.UTC() }