From e6f13d5240c9f42ebd38378a4b62102a252db732 Mon Sep 17 00:00:00 2001 From: shockerli Date: Tue, 9 Mar 2021 16:02:50 +0800 Subject: [PATCH] add int64 --- cvt.go | 13 ++++ cvt_test.go | 93 +++++++++++++++++++++++++++ cvte.go | 174 +++++++++++++++++++++++++++++++++++++-------------- cvte_test.go | 118 +++++++++++++++++++++++++++++++++- go.mod | 1 - go.sum | 4 +- 6 files changed, 350 insertions(+), 53 deletions(-) diff --git a/cvt.go b/cvt.go index aff17eb..4014bc2 100644 --- a/cvt.go +++ b/cvt.go @@ -77,3 +77,16 @@ func Uint(v interface{}, def ...uint) uint { return 0 } + +// Int64 convert an interface to a int64 type, with default value +func Int64(v interface{}, def ...int64) int64 { + if v, err := Int64E(v); err == nil { + return v + } + + if len(def) > 0 { + return def[0] + } + + return 0 +} diff --git a/cvt_test.go b/cvt_test.go index 1db5ff0..c694e5c 100644 --- a/cvt_test.go +++ b/cvt_test.go @@ -586,3 +586,96 @@ func TestUint_BaseLine(t *testing.T) { assert.Equal(t, tt.expect, v, msg) } } + +func TestInt64_HasDefault(t *testing.T) { + tests := []struct { + input interface{} + def int64 + expect int64 + }{ + // supported value, def is not used, def != expect + {int(8), 1, 8}, + {int8(8), 1, 8}, + {int16(8), 1, 8}, + {int32(8), 1, 8}, + {int64(8), 1, 8}, + {uint(8), 1, 8}, + {uint8(8), 1, 8}, + {uint16(8), 1, 8}, + {uint32(8), 1, 8}, + {uint64(8), 1, 8}, + {float32(8.31), 1, 8}, + {float64(8.31), 1, 8}, + {"8", 2, 8}, + {"8.00", 2, 8}, + {"8.01", 2, 8}, + {int(-8), 1, -8}, + {int8(-8), 1, -8}, + {int16(-8), 1, -8}, + {int32(-8), 1, -8}, + {int64(-8), 1, -8}, + {float32(-8.31), 1, -8}, + {float64(-8.31), 1, -8}, + {"-8", 1, -8}, + {"-8.01", 1, -8}, + {true, 2, 1}, + {false, 2, 0}, + {nil, 2, 0}, + {aliasTypeInt_0, 2, 0}, + {&aliasTypeInt_0, 2, 0}, + {aliasTypeInt_1, 2, 1}, + {&aliasTypeInt_1, 2, 1}, + {aliasTypeString_0, 2, 0}, + {&aliasTypeString_0, 2, 0}, + {aliasTypeString_1, 2, 1}, + {&aliasTypeString_1, 2, 1}, + {aliasTypeString_8d15, 2, 8}, + {&aliasTypeString_8d15, 2, 8}, + {aliasTypeString_8d15_minus, 1, -8}, + {&aliasTypeString_8d15_minus, 1, -8}, + + // unsupported value, def == expect + {"10a", 1, 1}, + {"a10a", 1, 1}, + {"8.01a", 1, 1}, + {"8.01 ", 1, 1}, + {"hello", 1, 1}, + {testing.T{}, 1, 1}, + {&testing.T{}, 1, 1}, + {[]int{}, 1, 1}, + {[]string{}, 1, 1}, + {[...]string{}, 1, 1}, + {map[int]string{}, 1, 1}, + } + + for i, tt := range tests { + msg := fmt.Sprintf("i = %d, input[%+v], def[%+v], expect[%+v]", i, tt.input, tt.def, tt.expect) + + v := cvt.Int64(tt.input, tt.def) + assert.Equal(t, tt.expect, v, msg) + } +} + +func TestInt64_BaseLine(t *testing.T) { + tests := []struct { + input interface{} + expect int64 + }{ + {testing.T{}, 0}, + {&testing.T{}, 0}, + {[]int{}, 0}, + {[]int{1, 2, 3}, 0}, + {[]string{}, 0}, + {[]string{"a", "b", "c"}, 0}, + {[...]string{}, 0}, + {map[int]string{}, 0}, + {"4873546382743564386435354655456575456754356765546554643456", 0}, + } + + for i, tt := range tests { + msg := fmt.Sprintf("i = %d, input[%+v], expect[%+v]", i, tt.input, tt.expect) + + v := cvt.Int64(tt.input) + assert.Equal(t, tt.expect, v, msg) + } +} diff --git a/cvte.go b/cvte.go index 8763fd3..f4a29d8 100644 --- a/cvte.go +++ b/cvte.go @@ -1,6 +1,7 @@ package cvt import ( + "errors" "fmt" "math" "reflect" @@ -8,6 +9,10 @@ import ( "strings" ) +var convErr = errors.New("convert failed") +var formatOutOfLimit = "%w, out of max limit value(%d)" +var formatExtend = "%v, %w" + // BoolE convert an interface to a bool type func BoolE(val interface{}) (bool, error) { v, rk, rv := Indirect(val) @@ -35,7 +40,7 @@ func BoolE(val interface{}) (bool, error) { return rv.Len() > 0, nil } - return false, err(val, "bool") + return false, newErr(val, "bool") } // returns the boolean value represented by the string @@ -52,51 +57,31 @@ func str2bool(str string) (bool, error) { case "off": return false, nil default: - return false, err(str, "bool") + return false, newErr(str, "bool") } } // Uint64E convert an interface to a uint64 type func Uint64E(val interface{}) (uint64, error) { - e := err(val, "uint64") - v, _, rv := Indirect(val) - - switch vv := v.(type) { - case nil: - return 0, nil - case bool: - if vv { - return 1, nil - } - return 0, nil - case string: - vvv, err := strconv.ParseFloat(vv, 64) - if err == nil && vvv >= 0 && vvv <= math.MaxUint64 { - return uint64(math.Floor(vvv)), nil - } - case uint, uint8, uint16, uint32, uint64: - return rv.Uint(), nil - case int, int8, int16, int32, int64: - if rv.Int() >= 0 { - return uint64(rv.Int()), nil - } - case float32, float64: - if rv.Float() >= 0 && rv.Float() <= math.MaxUint64 { - return uint64(math.Floor(rv.Float())), nil - } + v, e := convUint64(val) + if e := catch("uint64", val, e); e != nil { + return 0, e + } + if v > math.MaxUint64 { + return 0, fmt.Errorf(formatOutOfLimit, newErr(val, "uint64"), uint64(math.MaxUint64)) } - return 0, e + return v, nil } // Uint32E convert an interface to a uint32 type func Uint32E(val interface{}) (uint32, error) { - v, e := Uint64E(val) - if e != nil { - return 0, err(val, "uint32") + v, e := convUint64(val) + if e := catch("uint32", val, e); e != nil { + return 0, e } if v > math.MaxUint32 { - return 0, fmt.Errorf("%w, out of max limit value(%d)", err(val, "uint32"), math.MaxUint32) + return 0, fmt.Errorf(formatOutOfLimit, newErr(val, "uint32"), uint32(math.MaxUint32)) } return uint32(v), nil @@ -104,12 +89,12 @@ func Uint32E(val interface{}) (uint32, error) { // Uint16E convert an interface to a uint16 type func Uint16E(val interface{}) (uint16, error) { - v, e := Uint64E(val) - if e != nil { - return 0, err(val, "uint16") + v, e := convUint64(val) + if e := catch("uint16", val, e); e != nil { + return 0, e } if v > math.MaxUint16 { - return 0, fmt.Errorf("%w, out of max limit value(%d)", err(val, "uint16"), math.MaxUint16) + return 0, fmt.Errorf(formatOutOfLimit, newErr(val, "uint16"), uint16(math.MaxUint16)) } return uint16(v), nil @@ -117,12 +102,12 @@ func Uint16E(val interface{}) (uint16, error) { // Uint8E convert an interface to a uint8 type func Uint8E(val interface{}) (uint8, error) { - v, e := Uint64E(val) - if e != nil { - return 0, err(val, "uint8") + v, e := convUint64(val) + if e := catch("uint8", val, e); e != nil { + return 0, e } if v > math.MaxUint8 { - return 0, fmt.Errorf("%w, out of max limit value(%d)", err(val, "uint8"), math.MaxUint8) + return 0, fmt.Errorf(formatOutOfLimit, newErr(val, "uint8"), uint8(math.MaxUint8)) } return uint8(v), nil @@ -130,17 +115,104 @@ func Uint8E(val interface{}) (uint8, error) { // UintE convert an interface to a uint type func UintE(val interface{}) (uint, error) { - v, e := Uint64E(val) - if e != nil { - return 0, err(val, "uint") + v, e := convUint64(val) + if e := catch("uint", val, e); e != nil { + return 0, e } if v > uint64(^uint(0)) { - return 0, fmt.Errorf("%w, out of max limit value(%d)", err(val, "uint"), ^uint(0)) + return 0, fmt.Errorf(formatOutOfLimit, newErr(val, "uint"), ^uint(0)) } return uint(v), nil } +func convUint64(val interface{}) (uint64, error) { + v, _, rv := Indirect(val) + + switch vv := v.(type) { + case nil: + return 0, nil + case bool: + if vv { + return 1, nil + } + return 0, nil + case string: + vvv, err := strconv.ParseFloat(vv, 64) + if err == nil && vvv >= 0 && vvv <= math.MaxUint64 { + return uint64(math.Trunc(vvv)), nil + } + case []byte: + vvv, err := strconv.ParseFloat(string(vv), 64) + if err == nil && vvv >= 0 && vvv <= math.MaxUint64 { + return uint64(math.Trunc(vvv)), nil + } + case uint, uint8, uint16, uint32, uint64: + return rv.Uint(), nil + case int, int8, int16, int32, int64: + if rv.Int() >= 0 { + return uint64(rv.Int()), nil + } + case float32, float64: + if rv.Float() >= 0 && rv.Float() <= math.MaxUint64 { + return uint64(math.Trunc(rv.Float())), nil + } + } + + return 0, convErr +} + +// Int64E convert an interface to a int64 type +func Int64E(val interface{}) (int64, error) { + v, e := convInt64(val) + if e := catch("int64", val, e); e != nil { + return 0, e + } + if strconv.IntSize == 64 && v > math.MaxInt64 { + return 0, fmt.Errorf(formatOutOfLimit, newErr(val, "int64"), math.MaxInt64) + } else if strconv.IntSize == 32 && v > math.MaxInt32 { + return 0, fmt.Errorf(formatOutOfLimit, newErr(val, "int64"), math.MaxInt32) + } + + return v, nil +} + +func convInt64(val interface{}) (int64, error) { + v, _, rv := Indirect(val) + + switch vv := v.(type) { + case nil: + return 0, nil + case bool: + if vv { + return 1, nil + } + return 0, nil + case string: + vvv, err := strconv.ParseFloat(vv, 64) + if err == nil && vvv <= math.MaxInt64 { + return int64(math.Trunc(vvv)), nil + } + case []byte: + vvv, err := strconv.ParseFloat(string(vv), 64) + if err == nil && vvv <= math.MaxInt64 { + return int64(math.Trunc(vvv)), nil + } + case uint, uint8, uint16, uint32, uint64, uintptr: + if rv.Uint() <= math.MaxInt64 { + return int64(rv.Uint()), nil + } + case int, int8, int16, int32, int64: + return rv.Int(), nil + case float32, float64: + if rv.Float() <= math.MaxInt64 { + return int64(math.Trunc(rv.Float())), nil + } + } + + return 0, convErr +} + // Indirect returns the value with base type func Indirect(a interface{}) (val interface{}, k reflect.Kind, v reflect.Value) { if a == nil { @@ -198,6 +270,16 @@ func Indirect(a interface{}) (val interface{}, k reflect.Kind, v reflect.Value) return } -func err(val interface{}, t string) error { +func newErr(val interface{}, t string) error { return fmt.Errorf("unable to convert %#v of type %T to %s", val, val, t) } + +func catch(t string, val interface{}, e error) error { + if e != nil { + if errors.Is(e, convErr) { + return newErr(val, t) + } + return fmt.Errorf(formatExtend, newErr(val, t), e) + } + return nil +} diff --git a/cvte_test.go b/cvte_test.go index 0a6883d..b250e53 100644 --- a/cvte_test.go +++ b/cvte_test.go @@ -10,9 +10,17 @@ import ( "github.com/shockerli/cvt" ) +// alias type: bool +type AliasTypeBool bool + // alias type: int type AliasTypeInt int +var ( + aliasTypeBool_true AliasTypeBool = true + aliasTypeBool_false AliasTypeBool = false +) + var ( aliasTypeInt_0 AliasTypeInt = 0 aliasTypeInt_1 AliasTypeInt = 1 @@ -36,7 +44,7 @@ func TestBoolE(t *testing.T) { expect bool isErr bool }{ - // true/scale + // false/scale {0, false, false}, {float64(0.00), false, false}, {int(0.00), false, false}, @@ -45,16 +53,17 @@ func TestBoolE(t *testing.T) { {uint64(0.00), false, false}, {uint8(0.00), false, false}, {nil, false, false}, + {false, false, false}, {"false", false, false}, {"FALSE", false, false}, {"False", false, false}, {"f", false, false}, {"F", false, false}, - {false, false, false}, {"off", false, false}, {"Off", false, false}, {"0", false, false}, {"0.00", false, false}, + {[]byte("false"), false, false}, {[]byte("Off"), false, false}, {aliasTypeInt_0, false, false}, {&aliasTypeInt_0, false, false}, @@ -62,6 +71,8 @@ func TestBoolE(t *testing.T) { {&aliasTypeString_0, false, false}, {aliasTypeString_off, false, false}, {&aliasTypeString_off, false, false}, + {aliasTypeBool_false, false, false}, + {&aliasTypeBool_false, false, false}, // false/slice/array/map {[]int{}, false, false}, @@ -71,24 +82,27 @@ func TestBoolE(t *testing.T) { {map[string]string{}, false, false}, // true/scale + {true, true, false}, {"true", true, false}, {"TRUE", true, false}, {"True", true, false}, {"t", true, false}, {"T", true, false}, {1, true, false}, - {true, true, false}, {-1, true, false}, {"on", true, false}, {"On", true, false}, {0.01, true, false}, {"0.01", true, false}, + {[]byte("true"), true, false}, {aliasTypeInt_1, true, false}, {&aliasTypeInt_1, true, false}, {aliasTypeString_1, true, false}, {&aliasTypeString_1, true, false}, {aliasTypeString_on, true, false}, {&aliasTypeString_on, true, false}, + {aliasTypeBool_true, true, false}, + {&aliasTypeBool_true, true, false}, // true/slice/array/map {[]int{1, 2, 3}, true, false}, @@ -149,6 +163,9 @@ func TestUint64E(t *testing.T) { {"8", 8, false}, {"8.00", 8, false}, {"8.01", 8, false}, + {[]byte("8"), 8, false}, + {[]byte("8.00"), 8, false}, + {[]byte("8.01"), 8, false}, {nil, 0, false}, {aliasTypeInt_0, 0, false}, {&aliasTypeInt_0, 0, false}, @@ -160,6 +177,10 @@ func TestUint64E(t *testing.T) { {&aliasTypeString_1, 1, false}, {aliasTypeString_8d15, 8, false}, {&aliasTypeString_8d15, 8, false}, + {aliasTypeBool_true, 1, false}, + {&aliasTypeBool_true, 1, false}, + {aliasTypeBool_false, 0, false}, + {&aliasTypeBool_false, 0, false}, // errors {int(-8), 0, true}, @@ -542,3 +563,94 @@ func TestUintE(t *testing.T) { assert.Equal(t, tt.expect, v, msg) } } + +func TestInt64E(t *testing.T) { + tests := []struct { + input interface{} + expect int64 + isErr bool + }{ + {int(8), 8, false}, + {int8(8), 8, false}, + {int16(8), 8, false}, + {int32(8), 8, false}, + {int64(8), 8, false}, + {uint(8), 8, false}, + {uint8(8), 8, false}, + {uint16(8), 8, false}, + {uint32(8), 8, false}, + {uint64(8), 8, false}, + {float32(8.31), 8, false}, + {float64(8.31), 8, false}, + {true, 1, false}, + {false, 0, false}, + {int(-8), -8, false}, + {int8(-8), -8, false}, + {int16(-8), -8, false}, + {int32(-8), -8, false}, + {int64(-8), -8, false}, + {float32(-8.31), -8, false}, + {float64(-8.31), -8, false}, + {"-8", -8, false}, + {"-8.01", -8, false}, + {"8", 8, false}, + {"8.00", 8, false}, + {"8.01", 8, false}, + {[]byte("-8"), -8, false}, + {[]byte("-8.01"), -8, false}, + {[]byte("8"), 8, false}, + {[]byte("8.00"), 8, false}, + {[]byte("8.01"), 8, false}, + {uint32(math.MaxUint32), int64(math.MaxUint32), false}, + {nil, 0, false}, + {aliasTypeInt_0, 0, false}, + {&aliasTypeInt_0, 0, false}, + {aliasTypeInt_1, 1, false}, + {&aliasTypeInt_1, 1, false}, + {aliasTypeString_0, 0, false}, + {&aliasTypeString_0, 0, false}, + {aliasTypeString_1, 1, false}, + {&aliasTypeString_1, 1, false}, + {aliasTypeString_8d15, 8, false}, + {&aliasTypeString_8d15, 8, false}, + {aliasTypeString_8d15_minus, -8, false}, + {&aliasTypeString_8d15_minus, -8, false}, + {aliasTypeBool_true, 1, false}, + {&aliasTypeBool_true, 1, false}, + {aliasTypeBool_false, 0, false}, + {&aliasTypeBool_false, 0, false}, + + // errors + {"10a", 0, true}, + {"a10a", 0, true}, + {"8.01a", 0, true}, + {"8.01 ", 0, true}, + {"4873546382743564386435354655456575456754356765546554643456", 0, true}, + {float64(4873546382743564386435354655456575456754356765546554643456), 0, true}, + {uint64(math.MaxUint64), 0, true}, + {"hello", 0, true}, + {testing.T{}, 0, true}, + {&testing.T{}, 0, true}, + {[]int{}, 0, true}, + {[]string{}, 0, true}, + {[...]string{}, 0, true}, + {map[int]string{}, 0, true}, + } + + for i, tt := range tests { + msg := fmt.Sprintf("i = %d, input[%+v], expect[%v], isErr[%v]", i, tt.input, tt.expect, tt.isErr) + + v, err := cvt.Int64E(tt.input) + if tt.isErr { + assert.Error(t, err, msg) + continue + } + + assert.NoError(t, err, msg) + assert.Equal(t, tt.expect, v, msg) + + // Non-E test with no default value: + v = cvt.Int64(tt.input) + assert.Equal(t, tt.expect, v, msg) + } +} diff --git a/go.mod b/go.mod index e053fa2..b1e7d59 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,6 @@ go 1.15 require ( github.com/davecgh/go-spew v1.1.1 - github.com/stretchr/objx v0.3.0 // indirect github.com/stretchr/testify v1.7.0 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect ) diff --git a/go.sum b/go.sum index 246b4aa..801080b 100644 --- a/go.sum +++ b/go.sum @@ -5,11 +5,9 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.3.0 h1:NGXK3lHquSN08v5vWalVI/L8XU9hdzE/G6xsrze47As= -github.com/stretchr/objx v0.3.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=