zishuo/go-easy-utils
1
0
Fork 0
mirror of https://github.com/jefferyjob/go-easy-utils.git synced 2025-10-06 15:37:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

Feature/cover unit test (#81)

Browse Source
This commit is contained in:
libin
2024-07-31 19:51:01 +08:00
committed by GitHub
parent 0990bbce4d
commit a59af60d9a
60 changed files with 2571 additions and 2606 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
anyUtil/any_to_float_x_test.go
View File

@@ -1,52 +1,52 @@
package anyUtil
import (
"errors"
"math"
"testing"
)
//func TestAnyToFloat64Test(t *testing.T) {
// fmt.Println(AnyToFloat64([]int{}))
//}
func TestAnyToFloat32(t *testing.T) {
tests := []struct {
testCases := []struct {
name string
input any
want float32
err error
}{
{nil, 0, nil},
{float32(3.14), 3.14, nil},
{float64(6.28), 6.28, nil},
{int(42), 42, nil},
{int8(8), 8, nil},
{int16(16), 16, nil},
{int32(32), 32, nil},
{int64(64), 64, nil},
{uint(24), 24, nil},
{uint8(8), 8, nil},
{uint16(16), 16, nil},
{uint32(32), 32, nil},
{uint64(64), 64, nil},
{"3.14", 3.14, nil},
{math.MaxFloat64, 0, ErrValOut},
{make(chan int), 0, ErrType},
{"nil", nil, 0, nil},
{"float32", float32(3.14), 3.14, nil},
{"float64", float64(6.28), 6.28, nil},
{"int", int(42), 42, nil},
{"int8", int8(8), 8, nil},
{"int16", int16(16), 16, nil},
{"int32", int32(32), 32, nil},
{"int64", int64(64), 64, nil},
{"uint", uint(24), 24, nil},
{"uint8", uint8(8), 8, nil},
{"uint16", uint16(16), 16, nil},
{"uint32", uint32(32), 32, nil},
{"uint64", uint64(64), 64, nil},
{"string", "3.14", 3.14, nil},
{"math.MaxFloat64", math.MaxFloat64, 0, ErrValOut},
{"channel", make(chan int), 0, ErrType},
}
for _, test := range tests {
got, err := AnyToFloat32(test.input)
if got != test.want {
t.Errorf("AnyToFloat32(%v) = %v; want %v", test.input, got, test.want)
}
if err != test.err {
if err != nil && test.err != nil {
if err.Error() != test.err.Error() {
for _, test := range testCases {
t.Run(test.name, func(t *testing.T) {
got, err := AnyToFloat32(test.input)
if got != test.want {
t.Errorf("AnyToFloat32(%v) = %v; want %v", test.input, got, test.want)
}
if !errors.Is(err, test.err) {
if err != nil && test.err != nil {
if err.Error() != test.err.Error() {
t.Errorf("AnyToFloat32(%v) error = %v; want %v", test.input, err, test.err)
}
} else {
t.Errorf("AnyToFloat32(%v) error = %v; want %v", test.input, err, test.err)
}
} else {
t.Errorf("AnyToFloat32(%v) error = %v; want %v", test.input, err, test.err)
}
}
})
}
}
@@ -54,47 +54,49 @@ func TestAnyToFloat64(t *testing.T) {
iPtr := 90
tests := []struct {
name string
input any
want float64
err error
}{
{nil, 0, nil},
//{float32(3.14), 3.14, nil},
{float64(6.28), 6.28, nil},
{int(42), 42, nil},
{int8(8), 8, nil},
{int16(16), 16, nil},
{int32(32), 32, nil},
{int64(64), 64, nil},
{uint(24), 24, nil},
{uint8(8), 8, nil},
{uint16(16), 16, nil},
{uint32(32), 32, nil},
{uint64(64), 64, nil},
{"3.14", 3.14, nil},
{true, 1, nil},
{false, 0, nil},
{complex64(1 + 2i), 1, nil},
{complex128(1 + 2i), 1, nil},
{&iPtr, 90, nil},
{(*int)(nil), 0, nil},
{"abc", 0, ErrSyntax},
{[]int{}, 0, ErrType},
{"nil", nil, 0, nil},
{"float64", float64(6.28), 6.28, nil},
{"int", int(42), 42, nil},
{"int8", int8(8), 8, nil},
{"int16", int16(16), 16, nil},
{"int32", int32(32), 32, nil},
{"int64", int64(64), 64, nil},
{"uint", uint(24), 24, nil},
{"uint8", uint8(8), 8, nil},
{"uint16", uint16(16), 16, nil},
{"uint32", uint32(32), 32, nil},
{"uint64", uint64(64), 64, nil},
{"string", "3.14", 3.14, nil},
{"true", true, 1, nil},
{"false", false, 0, nil},
{"complex64", complex64(1 + 2i), 1, nil},
{"complex128", complex128(1 + 2i), 1, nil},
{"pointer", &iPtr, 90, nil},
{"nil pointer", (*int)(nil), 0, nil},
{"invalid string", "abc", 0, ErrSyntax},
{"slice", []int{}, 0, ErrType},
}
for _, test := range tests {
got, err := AnyToFloat64(test.input)
if got != test.want {
t.Errorf("AnyToFloat64(%v) = %v; want %v", test.input, got, test.want)
}
if err != test.err {
if err != nil && test.err != nil {
if err.Error() != test.err.Error() {
t.Run(test.name, func(t *testing.T) {
got, err := AnyToFloat64(test.input)
if got != test.want {
t.Errorf("AnyToFloat64(%v) = %v; want %v", test.input, got, test.want)
}
if err != test.err {
if err != nil && test.err != nil {
if err.Error() != test.err.Error() {
t.Errorf("AnyToFloat64(%v) error = %v; want %v", test.input, err, test.err)
}
} else {
t.Errorf("AnyToFloat64(%v) error = %v; want %v", test.input, err, test.err)
}
} else {
t.Errorf("AnyToFloat64(%v) error = %v; want %v", test.input, err, test.err)
}
}
})
}
}