diff --git a/README.md b/README.md
index ee0cff3..4bb2230 100644
--- a/README.md
+++ b/README.md
@@ -6,9 +6,10 @@
-[](https://github.com/duke-git/lancet/releases)
+[](https://github.com/duke-git/lancet/releases)
[](https://pkg.go.dev/github.com/duke-git/lancet)
[](https://goreportcard.com/report/github.com/duke-git/lancet)
+[](https://codecov.io/gh/duke-git/lancet)
[](https://github.com/duke-git/lancet/blob/main/LICENSE)
diff --git a/README_zh-CN.md b/README_zh-CN.md
index d16945f..78cebe4 100644
--- a/README_zh-CN.md
+++ b/README_zh-CN.md
@@ -6,9 +6,10 @@
-[](https://github.com/duke-git/lancet/releases)
+[](https://github.com/duke-git/lancet/releases)
[](https://pkg.go.dev/github.com/duke-git/lancet)
[](https://goreportcard.com/report/github.com/duke-git/lancet)
+[](https://codecov.io/gh/duke-git/lancet)
[](https://github.com/duke-git/lancet/blob/main/LICENSE)
diff --git a/convertor/convertor_test.go b/convertor/convertor_test.go
index 7c84a9e..d0c3764 100644
--- a/convertor/convertor_test.go
+++ b/convertor/convertor_test.go
@@ -2,9 +2,10 @@ package convertor
import (
"fmt"
- "github.com/duke-git/lancet/utils"
"reflect"
"testing"
+
+ "github.com/duke-git/lancet/utils"
)
func TestToChar(t *testing.T) {
@@ -58,8 +59,12 @@ func TestToBytes(t *testing.T) {
}
func TestToInt(t *testing.T) {
- cases := []interface{}{"123", "-123", 123, "abc", false, "111111111111111111111111111111111111111"}
- expected := []int64{123, -123, 123, 0, 0, 0}
+ cases := []interface{}{"123", "-123", 123,
+ uint(123), uint8(123), uint16(123), uint32(123), uint64(123),
+ float32(12.3), float64(12.3),
+ "abc", false, "111111111111111111111111111111111111111"}
+
+ expected := []int64{123, -123, 123, 123, 123, 123, 123, 123, 12, 12, 0, 0, 0}
for i := 0; i < len(cases); i++ {
res, _ := ToInt(cases[i])
@@ -71,8 +76,14 @@ func TestToInt(t *testing.T) {
}
func TestToFloat(t *testing.T) {
- cases := []interface{}{"", "-1", "-.11", "1.23e3", ".123e10", "abc"}
- expected := []float64{0, -1, -0.11, 1230, 0.123e10, 0}
+ cases := []interface{}{
+ "", "-1", "-.11", "1.23e3", ".123e10", "abc",
+ int(0), int8(1), int16(-1), int32(123), int64(123),
+ uint(123), uint8(123), uint16(123), uint32(123), uint64(123),
+ float64(12.3), float32(12.3),
+ }
+ expected := []float64{0, -1, -0.11, 1230, 0.123e10, 0,
+ 0, 1, -1, 123, 123, 123, 123, 123, 123, 123, 12.3, 12.300000190734863}
for i := 0; i < len(cases); i++ {
res, _ := ToFloat(cases[i])
@@ -84,41 +95,37 @@ func TestToFloat(t *testing.T) {
}
func TestToString(t *testing.T) {
- // basic type
- toString(t, "a1", "a1")
- toString(t, 111, "111")
- toString(t, 111.01, "111.01")
- toString(t, true, "true")
- //toString(t, 1.5+10i, "(1.5+10i)")
-
- // slice
- aSlice := []int{1, 2, 3}
- toString(t, aSlice, "[1,2,3]")
-
// map
aMap := make(map[string]int)
aMap["a"] = 1
aMap["b"] = 2
aMap["c"] = 3
- toString(t, aMap, "{\"a\":1,\"b\":2,\"c\":3}")
-
// struct
type TestStruct struct {
Name string
}
aStruct := TestStruct{Name: "TestStruct"}
- toString(t, aStruct, "{\"Name\":\"TestStruct\"}")
-}
-func toString(t *testing.T, test interface{}, expected string) {
- res := ToString(test)
- if res != expected {
- utils.LogFailedTestInfo(t, "ToString", test, expected, res)
- t.FailNow()
+ cases := []interface{}{
+ int(0), int8(1), int16(-1), int32(123), int64(123),
+ uint(123), uint8(123), uint16(123), uint32(123), uint64(123),
+ float64(12.3), float32(12.3),
+ true, false,
+ []int{1, 2, 3}, aMap, aStruct, []byte{104, 101, 108, 108, 111}}
+
+ expected := []string{"0", "1", "-1", "123", "123", "123", "123", "123",
+ "123", "123", "12.3", "12.300000190734863", "true", "false",
+ "[1,2,3]", "{\"a\":1,\"b\":2,\"c\":3}", "{\"Name\":\"TestStruct\"}", "hello"}
+
+ for i := 0; i < len(cases); i++ {
+ res := ToString(cases[i])
+ if res != expected[i] {
+ utils.LogFailedTestInfo(t, "ToString", cases[i], expected[i], res)
+ t.FailNow()
+ }
}
}
-
func TestToJson(t *testing.T) {
// map
aMap := make(map[string]int)
diff --git a/formatter/formatter_test.go b/formatter/formatter_test.go
index f29713c..ff742b9 100644
--- a/formatter/formatter_test.go
+++ b/formatter/formatter_test.go
@@ -9,6 +9,8 @@ import (
func TestComma(t *testing.T) {
comma(t, "", "", "")
comma(t, "aa", "", "")
+ comma(t, "aa.a", "", "")
+ comma(t, []int{1}, "", "")
comma(t, "123", "", "123")
comma(t, "12345", "", "12,345")
comma(t, 12345, "", "12,345")
diff --git a/netutil/request_test.go b/netutil/request_test.go
index 3871993..639ef32 100644
--- a/netutil/request_test.go
+++ b/netutil/request_test.go
@@ -11,6 +11,11 @@ import (
)
func TestHttpGet(t *testing.T) {
+ _, e := HttpGet("", nil)
+ if e == nil {
+ t.FailNow()
+ }
+
url := "https://gutendex.com/books?"
queryParams := make(map[string]interface{})
queryParams["ids"] = "1"
diff --git a/random/random_test.go b/random/random_test.go
index 1528233..b248bcf 100644
--- a/random/random_test.go
+++ b/random/random_test.go
@@ -2,10 +2,11 @@ package random
import (
"fmt"
- "github.com/duke-git/lancet/utils"
"reflect"
"regexp"
"testing"
+
+ "github.com/duke-git/lancet/utils"
)
func TestRandString(t *testing.T) {
@@ -21,26 +22,44 @@ func TestRandString(t *testing.T) {
}
func TestRandInt(t *testing.T) {
- randInt := RandInt(1, 10)
+ res1 := RandInt(1, 10)
+ if res1 < 1 || res1 >= 10 {
+ utils.LogFailedTestInfo(t, "RandInt", "RandInt(1, 10)", "RandInt(1, 10) should between [1, 10) ", res1)
+ t.FailNow()
+ }
- if randInt < 1 || randInt >= 10 {
- utils.LogFailedTestInfo(t, "RandInt", "RandInt(1, 10)", "RandInt(1, 10) should between [1, 10) ", randInt)
+ res2 := RandInt(1, 1)
+ if res2 != 1 {
+ utils.LogFailedTestInfo(t, "RandInt", "RandInt(1, 1)", "RandInt(1, 1) should be 1 ", res2)
+ t.FailNow()
+ }
+
+ res3 := RandInt(10, 1)
+ if res3 < 1 || res3 >= 10 {
+ utils.LogFailedTestInfo(t, "RandInt", "RandInt(10, 1)", "RandInt(10, 1) should between [1, 10) ", res3)
t.FailNow()
}
}
func TestRandBytes(t *testing.T) {
randBytes := RandBytes(4)
-
if len(randBytes) != 4 {
utils.LogFailedTestInfo(t, "RandBytes", "RandBytes(4)", "RandBytes(4) should return 4 element of []bytes", randBytes)
t.FailNow()
}
-
v := reflect.ValueOf(randBytes)
et := v.Type().Elem()
if v.Kind() != reflect.Slice || et.Kind() != reflect.Uint8 {
utils.LogFailedTestInfo(t, "RandBytes", "RandBytes(4)", "RandBytes(4) should return 4 element of []bytes", randBytes)
t.FailNow()
}
+
+ randErr := RandBytes(0)
+ if randErr != nil {
+ utils.LogFailedTestInfo(t, "RandBytes", "RandBytes(0)", "RandBytes(0) should return nil", randErr)
+ t.FailNow()
+ }
+
+
+
}
diff --git a/slice/slice.go b/slice/slice.go
index 8bedb49..1bf06f0 100644
--- a/slice/slice.go
+++ b/slice/slice.go
@@ -137,17 +137,16 @@ func Map(slice, function interface{}) interface{} {
// The function signature should be func(index int, value1, value2 interface{}) interface{} .
func Reduce(slice, function, zero interface{}) interface{} {
sv := sliceValue(slice)
+ elementType := sv.Type().Elem()
len := sv.Len()
if len == 0 {
return zero
} else if len == 1 {
- return sv.Index(0)
+ return sv.Index(0).Interface()
}
- elementType := sv.Type().Elem()
fn := functionValue(function)
-
if checkSliceCallbackFuncSignature(fn, elementType, elementType, elementType) {
t := elementType.String()
panic("Reduce function must be of type func(int, " + t + ", " + t + ")" + t)
diff --git a/slice/slice_test.go b/slice/slice_test.go
index c9cc1e4..6942a70 100644
--- a/slice/slice_test.go
+++ b/slice/slice_test.go
@@ -14,6 +14,15 @@ func TestContain(t *testing.T) {
var t2 []string
contain(t, t2, "1", false)
+
+ m := make(map[string]int)
+ m["a"] = 1
+ contain(t, m, "a", true)
+ contain(t, m, "b", false)
+
+ s := "hello"
+ contain(t, s, "h", true)
+ contain(t, s, "s", false)
}
func contain(t *testing.T, test interface{}, value interface{}, expected bool) {
@@ -167,28 +176,21 @@ func TestMap(t *testing.T) {
}
func TestReduce(t *testing.T) {
- s1 := []int{1, 2, 3, 4}
- f1 := func(i, v1, v2 int) int {
+ cases := [][]int{
+ {},
+ {1},
+ {1, 2, 3, 4}}
+ expected := []int{0, 1, 10}
+ f := func(i, v1, v2 int) int {
return v1 + v2
}
- e1 := 10
- r1 := Reduce(s1, f1, 0)
- if e1 != r1 {
- utils.LogFailedTestInfo(t, "Reduce", s1, e1, r1)
- t.FailNow()
+ for i := 0; i < len(cases); i++ {
+ res := Reduce(cases[i], f, 0)
+ if res != expected[i] {
+ utils.LogFailedTestInfo(t, "Reduce", cases[i], expected[i], res)
+ t.FailNow()
+ }
}
-
- // failed Reduce function should be func(i int, v1, v2 int) int
- //s1 := []int{1, 2, 3, 4}
- //f1 := func(i string, v1, v2 int) int { //i should be int
- // return v1+v2
- //}
- //e1 := 10
- //r1 := Reduce(s1, f1, 0)
- //if e1 != r1 {
- // utils.LogFailedTestInfo(t, "Reduce", s1, e1, r1)
- // t.FailNow()
- //}
}
func TestIntSlice(t *testing.T) {