mirror of
https://github.com/jefferyjob/go-easy-utils.git
synced 2025-10-05 15:06:50 +08:00
Feature/cover unit test (#81)
This commit is contained in:
libin
@@ -2,255 +2,226 @@ package anyUtil
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"math"
|
||||
"testing"
|
||||
)
|
||||
|
||||
//func TestAnyToIntDemo(t *testing.T) {
|
||||
// fmt.Println(AnyToInt(math.MinInt32))
|
||||
//}
|
||||
|
||||
func TestAnyToInt(t *testing.T) {
|
||||
type testCase struct {
|
||||
iPtr := 90
|
||||
testCases := []struct {
|
||||
name string
|
||||
input any
|
||||
expected int
|
||||
err error
|
||||
}{
|
||||
// 测试整数输入
|
||||
{name: "number", input: 42, expected: 42, err: nil},
|
||||
{name: "int", input: int(42), expected: 42, err: nil},
|
||||
{name: "int64", input: int64(42), expected: 42, err: nil},
|
||||
{name: "int32", input: int32(42), expected: 42, err: nil},
|
||||
{name: "int", input: int(42), expected: 42, err: nil},
|
||||
{name: "int64", input: uint64(42), expected: 42, err: nil},
|
||||
{name: "int32", input: uint32(42), expected: 42, err: nil},
|
||||
{name: "uint", input: uint(42), expected: 42, err: nil},
|
||||
{name: "iPtr", input: &iPtr, expected: 90, err: nil},
|
||||
|
||||
// 测试浮点数输入
|
||||
{name: "float64", input: float64(42.0), expected: 42, err: nil},
|
||||
{name: "float32", input: float32(42.0), expected: 42, err: nil},
|
||||
{name: "float64_小数点", input: float64(42.5), expected: 42, err: nil},
|
||||
|
||||
// 测试非数值类型
|
||||
{name: "string", input: "rand string", expected: 0, err: ErrSyntax},
|
||||
{name: "nil", input: nil, expected: 0, err: nil},
|
||||
|
||||
// 布尔
|
||||
{name: "true", input: true, expected: 1, err: nil},
|
||||
{name: "false", input: false, expected: 0, err: nil},
|
||||
|
||||
// 空指针
|
||||
{name: "nil point", input: (*int)(nil), expected: 0, err: nil},
|
||||
}
|
||||
|
||||
testCases := []testCase{
|
||||
{input: 123, expected: 123, err: nil},
|
||||
{input: int8(123), expected: 123, err: nil},
|
||||
{input: int16(123), expected: 123, err: nil},
|
||||
{input: int32(123), expected: 123, err: nil},
|
||||
{input: int64(123), expected: 123, err: nil},
|
||||
{input: uint(123), expected: 123, err: nil},
|
||||
{input: uint8(123), expected: 123, err: nil},
|
||||
{input: uint16(123), expected: 123, err: nil},
|
||||
{input: uint32(123), expected: 123, err: nil},
|
||||
{input: uint64(123), expected: 123, err: nil},
|
||||
{input: float32(123.45), expected: 123, err: nil},
|
||||
{input: float64(123.45), expected: 123, err: nil},
|
||||
{input: "123", expected: 123, err: nil},
|
||||
{input: "abc", expected: 0, err: ErrSyntax},
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
actual, err := AnyToInt(tc.input)
|
||||
|
||||
if err != nil && tc.err == nil {
|
||||
t.Errorf("AnyToInt(%v) returned unexpected error: %v", tc.input, err)
|
||||
continue
|
||||
}
|
||||
|
||||
if err == nil && tc.err != nil {
|
||||
t.Errorf("AnyToInt(%v) expected error but got nil", tc.input)
|
||||
continue
|
||||
}
|
||||
|
||||
if err != nil && tc.err != nil && err.Error() != tc.err.Error() {
|
||||
t.Errorf("AnyToInt(%v) returned wrong error. Expected %v, but got %v", tc.input, tc.err, err)
|
||||
continue
|
||||
}
|
||||
|
||||
if actual != tc.expected {
|
||||
t.Errorf("AnyToInt(%v) returned %v, expected %v", tc.input, actual, tc.expected)
|
||||
}
|
||||
for _, test := range testCases {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
res, err := AnyToInt(test.input)
|
||||
if res != test.expected || !errors.Is(err, test.err) {
|
||||
t.Errorf("AnyToInt(%v) = (%d, %v); want (%d, %v)", test.input, res, err, test.expected, test.err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnyToInt8(t *testing.T) {
|
||||
// Test cases
|
||||
testCases := []struct {
|
||||
name string
|
||||
input any
|
||||
expected int8
|
||||
err error
|
||||
}{
|
||||
{
|
||||
name: "positive integer",
|
||||
input: 42,
|
||||
expected: 42,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "negative integer",
|
||||
input: -42,
|
||||
expected: -42,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "positive integer out of range",
|
||||
input: 128,
|
||||
expected: 0,
|
||||
err: ErrValOut,
|
||||
},
|
||||
{
|
||||
name: "negative integer out of range",
|
||||
input: -129,
|
||||
expected: 0,
|
||||
err: ErrValOut,
|
||||
},
|
||||
{
|
||||
name: "float",
|
||||
input: 3.14,
|
||||
expected: 3,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "string",
|
||||
input: "42",
|
||||
expected: 42,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "string out of range",
|
||||
input: "128",
|
||||
expected: 0,
|
||||
err: ErrValOut,
|
||||
},
|
||||
{
|
||||
name: "invalid string",
|
||||
input: "invalid",
|
||||
expected: 0,
|
||||
err: ErrSyntax,
|
||||
},
|
||||
// 测试整数输入
|
||||
{name: "number", input: 42, expected: 42, err: nil},
|
||||
{name: "int", input: int(42), expected: 42, err: nil},
|
||||
{name: "int64", input: int64(42), expected: 42, err: nil},
|
||||
{name: "int32", input: int32(42), expected: 42, err: nil},
|
||||
{name: "int", input: int(42), expected: 42, err: nil},
|
||||
{name: "int64", input: uint64(42), expected: 42, err: nil},
|
||||
{name: "int32", input: uint32(42), expected: 42, err: nil},
|
||||
{name: "uint", input: uint(42), expected: 42, err: nil},
|
||||
|
||||
// 测试浮点数输入
|
||||
{name: "float64", input: float64(42.0), expected: 42, err: nil},
|
||||
{name: "float32", input: float32(42.0), expected: 42, err: nil},
|
||||
{name: "float64_小数点", input: float64(42.5), expected: 42, err: nil},
|
||||
|
||||
// 测试非数值类型
|
||||
{name: "string", input: "rand string", expected: 0, err: ErrSyntax},
|
||||
{name: "nil", input: nil, expected: 0, err: nil},
|
||||
|
||||
// 溢出
|
||||
{name: "MinInt8", input: math.MinInt8 - 1, expected: 0, err: ErrValOut},
|
||||
{name: "MaxInt8", input: math.MaxInt8 + 1, expected: 0, err: ErrValOut},
|
||||
}
|
||||
|
||||
// Run test cases
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
actual, err := AnyToInt8(tc.input)
|
||||
|
||||
// Check error
|
||||
if err != nil {
|
||||
if !errors.Is(err, tc.err) {
|
||||
t.Errorf("Expected error: %v, but got: %v", tc.err, err)
|
||||
}
|
||||
//if err.Error() != tc.err.Error() {
|
||||
// t.Errorf("Expected error: %v, but got: %v", tc.err, err)
|
||||
//}
|
||||
}
|
||||
|
||||
// Check result
|
||||
if actual != tc.expected {
|
||||
t.Errorf("Expected result: %v, but got: %v", tc.expected, actual)
|
||||
for _, test := range testCases {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
res, err := AnyToInt8(test.input)
|
||||
if res != test.expected || !errors.Is(err, test.err) {
|
||||
t.Errorf("AnyToInt8(%v) = (%d, %v); want (%d, %v)", test.input, res, err, test.expected, test.err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnyToInt16(t *testing.T) {
|
||||
tests := []struct {
|
||||
input any
|
||||
want int16
|
||||
err error
|
||||
testCases := []struct {
|
||||
name string
|
||||
input any
|
||||
expected int16
|
||||
err error
|
||||
}{
|
||||
{int(12345), 12345, nil},
|
||||
{int8(123), 123, nil},
|
||||
{int16(12345), 12345, nil},
|
||||
{int32(12345), 12345, nil},
|
||||
{int64(12345), 12345, nil},
|
||||
{uint(12345), 12345, nil},
|
||||
{uint8(123), 123, nil},
|
||||
{uint16(12345), 12345, nil},
|
||||
{uint32(12345), 12345, nil},
|
||||
{uint64(12345), 12345, nil},
|
||||
{float32(123.45), 123, nil},
|
||||
{float64(123.45), 123, nil},
|
||||
{"12345", 12345, nil},
|
||||
{math.MinInt16 - 1, 0, ErrValOut},
|
||||
{"not a number", 0, ErrSyntax},
|
||||
// 测试整数输入
|
||||
{name: "number", input: 42, expected: 42, err: nil},
|
||||
{name: "int", input: int(42), expected: 42, err: nil},
|
||||
{name: "int64", input: int64(42), expected: 42, err: nil},
|
||||
{name: "int32", input: int32(42), expected: 42, err: nil},
|
||||
{name: "int", input: int(42), expected: 42, err: nil},
|
||||
{name: "int64", input: uint64(42), expected: 42, err: nil},
|
||||
{name: "int32", input: uint32(42), expected: 42, err: nil},
|
||||
{name: "uint", input: uint(42), expected: 42, err: nil},
|
||||
|
||||
// 测试浮点数输入
|
||||
{name: "float64", input: float64(42.0), expected: 42, err: nil},
|
||||
{name: "float32", input: float32(42.0), expected: 42, err: nil},
|
||||
{name: "float64_小数点", input: float64(42.5), expected: 42, err: nil},
|
||||
|
||||
// 测试非数值类型
|
||||
{name: "string", input: "rand string", expected: 0, err: ErrSyntax},
|
||||
{name: "nil", input: nil, expected: 0, err: nil},
|
||||
|
||||
// 溢出
|
||||
{name: "MinInt16", input: math.MinInt16 - 1, expected: 0, err: ErrValOut},
|
||||
{name: "MaxInt16", input: math.MaxInt16 + 1, expected: 0, err: ErrValOut},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
got, err := AnyToInt16(tt.input)
|
||||
|
||||
if got != tt.want {
|
||||
t.Errorf("AnyToInt16(%v) = %v, want %v", tt.input, got, tt.want)
|
||||
}
|
||||
|
||||
if !errors.Is(err, tt.err) {
|
||||
t.Errorf("AnyToInt16(%v) error = %v, want error %v", tt.input, err, tt.err)
|
||||
}
|
||||
for _, test := range testCases {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
res, err := AnyToInt16(test.input)
|
||||
if res != test.expected || !errors.Is(err, test.err) {
|
||||
t.Errorf("AnyToInt16(%v) = (%d, %v); want (%d, %v)", test.input, res, err, test.expected, test.err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnyToInt32(t *testing.T) {
|
||||
testCases := []struct {
|
||||
input any
|
||||
expectedValue int32
|
||||
expectedError error
|
||||
name string
|
||||
input any
|
||||
expected int32
|
||||
err error
|
||||
}{
|
||||
{int(123), 123, nil},
|
||||
{int64(2147483647), 2147483647, nil},
|
||||
{int64(2147483648), 0, ErrValOut},
|
||||
{int64(-2147483648), -2147483648, nil},
|
||||
{int64(-2147483649), 0, ErrValOut},
|
||||
{float64(123.45), 123, nil},
|
||||
{"123", 123, nil},
|
||||
{"-2147483649", 0, ErrValOut},
|
||||
{struct{}{}, 0, ErrType},
|
||||
// 测试整数输入
|
||||
{name: "number", input: 42, expected: 42, err: nil},
|
||||
{name: "int", input: int(42), expected: 42, err: nil},
|
||||
{name: "int64", input: int64(42), expected: 42, err: nil},
|
||||
{name: "int32", input: int32(42), expected: 42, err: nil},
|
||||
{name: "int", input: int(42), expected: 42, err: nil},
|
||||
{name: "int64", input: uint64(42), expected: 42, err: nil},
|
||||
{name: "int32", input: uint32(42), expected: 42, err: nil},
|
||||
{name: "uint", input: uint(42), expected: 42, err: nil},
|
||||
|
||||
// 测试浮点数输入
|
||||
{name: "float64", input: float64(42.0), expected: 42, err: nil},
|
||||
{name: "float32", input: float32(42.0), expected: 42, err: nil},
|
||||
{name: "float64_小数点", input: float64(42.5), expected: 42, err: nil},
|
||||
|
||||
// 测试非数值类型
|
||||
{name: "string", input: "rand string", expected: 0, err: ErrSyntax},
|
||||
{name: "nil", input: nil, expected: 0, err: nil},
|
||||
|
||||
// 溢出
|
||||
{name: "MinInt32", input: math.MinInt32 - 1, expected: 0, err: ErrValOut},
|
||||
{name: "MaxInt32", input: math.MaxInt32 + 1, expected: 0, err: ErrValOut},
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
actualValue, actualError := AnyToInt32(testCase.input)
|
||||
if actualValue != testCase.expectedValue {
|
||||
t.Errorf("Unexpected value. Input: %v, Expected: %d, Actual: %d", testCase.input, testCase.expectedValue, actualValue)
|
||||
}
|
||||
if (actualError == nil && testCase.expectedError != nil) || (actualError != nil && testCase.expectedError == nil) || (actualError != nil && actualError.Error() != testCase.expectedError.Error()) {
|
||||
t.Errorf("Unexpected error. Input: %v, Expected: %v, Actual: %v", testCase.input, testCase.expectedError, actualError)
|
||||
}
|
||||
for _, test := range testCases {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
res, err := AnyToInt32(test.input)
|
||||
if res != test.expected || !errors.Is(err, test.err) {
|
||||
t.Errorf("AnyToInt32(%v) = (%d, %v); want (%d, %v)", test.input, res, err, test.expected, test.err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnyToInt64(t *testing.T) {
|
||||
iPtr := 90
|
||||
|
||||
testCases := []struct {
|
||||
name string
|
||||
input any
|
||||
expected int64
|
||||
err bool
|
||||
err error
|
||||
}{
|
||||
// test cases for int values
|
||||
{int(42), int64(42), false},
|
||||
{int8(42), int64(42), false},
|
||||
{int16(42), int64(42), false},
|
||||
{int32(42), int64(42), false},
|
||||
{int64(42), int64(42), false},
|
||||
// test cases for uint values
|
||||
{uint(42), int64(42), false},
|
||||
{uint8(42), int64(42), false},
|
||||
{uint16(42), int64(42), false},
|
||||
{uint32(42), int64(42), false},
|
||||
{uint64(42), int64(42), false},
|
||||
// test cases for float values
|
||||
{float32(42.42), int64(42), false},
|
||||
{float64(42.42), int64(42), false},
|
||||
// test cases for string values
|
||||
{"42", int64(42), false},
|
||||
{"-42", int64(-42), false},
|
||||
{"42.42", int64(0), true}, // invalid syntax
|
||||
// unsupported type
|
||||
{struct{}{}, int64(0), true},
|
||||
// 测试整数输入
|
||||
{name: "number", input: 42, expected: 42, err: nil},
|
||||
{name: "int", input: int(42), expected: 42, err: nil},
|
||||
{name: "int64", input: int64(42), expected: 42, err: nil},
|
||||
{name: "int32", input: int32(42), expected: 42, err: nil},
|
||||
{name: "int", input: int(42), expected: 42, err: nil},
|
||||
{name: "int64", input: uint64(42), expected: 42, err: nil},
|
||||
{name: "int32", input: uint32(42), expected: 42, err: nil},
|
||||
{name: "uint", input: uint(42), expected: 42, err: nil},
|
||||
|
||||
// 测试浮点数输入
|
||||
{name: "float64", input: float64(42.0), expected: 42, err: nil},
|
||||
{name: "float32", input: float32(42.0), expected: 42, err: nil},
|
||||
{name: "float64_小数点", input: float64(42.5), expected: 42, err: nil},
|
||||
|
||||
// 测试非数值类型
|
||||
{name: "string", input: "rand string", expected: 0, err: ErrSyntax},
|
||||
{name: "nil", input: nil, expected: 0, err: nil},
|
||||
|
||||
// 布尔
|
||||
{name: "true", input: true, expected: 1, err: nil},
|
||||
{name: "false", input: false, expected: 0, err: nil},
|
||||
|
||||
// 空指针
|
||||
{name: "nil point", input: (*int)(nil), expected: 0, err: nil},
|
||||
|
||||
// complex
|
||||
{complex64(1 + 2i), 1, false},
|
||||
{complex128(1 + 2i), 1, false},
|
||||
// point
|
||||
{(*int)(nil), 0, false},
|
||||
{nil, 0, false},
|
||||
{&iPtr, 90, false},
|
||||
// bool
|
||||
{true, 1, false},
|
||||
{false, 0, false},
|
||||
{name: "complex128", input: complex(3.14, 1.59), expected: 3, err: nil},
|
||||
{name: "complex64", input: complex(float32(2.71), float32(1.41)), expected: 2, err: nil},
|
||||
|
||||
// 其他
|
||||
{name: "struct", input: struct{ Name string }{Name: "test"}, expected: 0, err: ErrType},
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
actual, err := AnyToInt64(testCase.input)
|
||||
if err != nil && !testCase.err {
|
||||
t.Errorf("unexpected error: %s", err)
|
||||
}
|
||||
if actual != testCase.expected {
|
||||
t.Errorf("expected %d but got %d", testCase.expected, actual)
|
||||
}
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
res, err := AnyToInt64(tc.input)
|
||||
assert.Equal(t, tc.err, err)
|
||||
assert.Equal(t, tc.expected, res)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user