add ut cases for package gconv (#2272)

* improve gconv.go code coverage * improve gconv_convert.go code coverage * improve gconv_float.go code coverage * improve gconv_map.go code coverage * improve gconv_maps.go code coverage * improve gconv_maptomap.go code coverage * improve gconv_maptomaps.go code coverage
2025-04-05 11:18:50 +08:00 · 2022-11-07 17:53:51 +08:00 · 2022-11-07 17:53:51 +08:00 · 9f12673631
commit 9f12673631
parent d37b75442d
4 changed files with 223 additions and 2 deletions
--- a/util/gconv/gconv_z_unit_all_test.go
+++ b/util/gconv/gconv_z_unit_all_test.go
@ -7,6 +7,7 @@
 package gconv_test

 import (
+	"github.com/gogf/gf/v2/container/gvar"
 	"math"
 	"testing"
 	"time"
@ -583,6 +584,7 @@ func Test_Float32_All(t *testing.T) {
 		t.AssertEQ(gconv.Float32([2]int{1, 2}), float32(0))
 		t.AssertEQ(gconv.Float32([]interface{}{}), float32(0))
 		t.AssertEQ(gconv.Float32([]map[int]int{}), float32(0))
+		t.AssertEQ(gconv.Float32(gvar.New(float32(0))), float32(0))

 		var countryCapitalMap = make(map[string]string)
 		/* map插入key - value对,各个国家对应的首都 */
@ -618,6 +620,7 @@ func Test_Float64_All(t *testing.T) {
 		t.AssertEQ(gconv.Float64([2]int{1, 2}), float64(0))
 		t.AssertEQ(gconv.Float64([]interface{}{}), float64(0))
 		t.AssertEQ(gconv.Float64([]map[int]int{}), float64(0))
+		t.AssertEQ(gconv.Float64(gvar.New(float64(0))), float64(0))

 		var countryCapitalMap = make(map[string]string)
 		/* map插入key - value对,各个国家对应的首都 */
@ -716,6 +719,7 @@ func Test_Bytes_All(t *testing.T) {
 		t.AssertEQ(gconv.Bytes(int32(0)), []uint8{0, 0, 0, 0})
 		t.AssertEQ(gconv.Bytes("s"), []uint8{115})
 		t.AssertEQ(gconv.Bytes([]byte("s")), []uint8{115})
+		t.AssertEQ(gconv.Bytes(gvar.New([]byte("s"))), []uint8{115})
 	})
 }

@ -748,6 +752,7 @@ func Test_Convert_All(t *testing.T) {
 		t.AssertEQ(gconv.Convert([]byte{}, "[]byte"), []uint8{})
 		t.AssertEQ(gconv.Convert([]string{}, "[]string"), []string{})
 		t.AssertEQ(gconv.Convert([2]int{1, 2}, "[]int"), []int{1, 2})
+		t.AssertEQ(gconv.Convert([2]uint8{1, 2}, "[]uint8"), []uint8{1, 2})
 		t.AssertEQ(gconv.Convert("1989-01-02", "Time", "Y-m-d"), gconv.Time("1989-01-02", "Y-m-d"))
 		t.AssertEQ(gconv.Convert(1989, "Time"), gconv.Time("1970-01-01 08:33:09 +0800 CST"))
 		t.AssertEQ(gconv.Convert(gtime.Now(), "gtime.Time", 1), *gtime.New())
@ -758,6 +763,63 @@ func Test_Convert_All(t *testing.T) {
 		t.AssertEQ(gconv.Convert(1989, "Duration"), time.Duration(int64(1989)))
 		t.AssertEQ(gconv.Convert("1989", "Duration"), time.Duration(int64(1989)))
 		t.AssertEQ(gconv.Convert("1989", ""), "1989")
+
+		var intNum int = 1
+		t.Assert(gconv.Convert(&intNum, "*int"), int(1))
+		var int8Num int8 = 1
+		t.Assert(gconv.Convert(int8Num, "*int8"), int(1))
+		t.Assert(gconv.Convert(&int8Num, "*int8"), int(1))
+		var int16Num int16 = 1
+		t.Assert(gconv.Convert(int16Num, "*int16"), int(1))
+		t.Assert(gconv.Convert(&int16Num, "*int16"), int(1))
+		var int32Num int32 = 1
+		t.Assert(gconv.Convert(int32Num, "*int32"), int(1))
+		t.Assert(gconv.Convert(&int32Num, "*int32"), int(1))
+		var int64Num int64 = 1
+		t.Assert(gconv.Convert(int64Num, "*int64"), int(1))
+		t.Assert(gconv.Convert(&int64Num, "*int64"), int(1))
+
+		var uintNum uint = 1
+		t.Assert(gconv.Convert(&uintNum, "*uint"), int(1))
+		var uint8Num uint8 = 1
+		t.Assert(gconv.Convert(uint8Num, "*uint8"), int(1))
+		t.Assert(gconv.Convert(&uint8Num, "*uint8"), int(1))
+		var uint16Num uint16 = 1
+		t.Assert(gconv.Convert(uint16Num, "*uint16"), int(1))
+		t.Assert(gconv.Convert(&uint16Num, "*uint16"), int(1))
+		var uint32Num uint32 = 1
+		t.Assert(gconv.Convert(uint32Num, "*uint32"), int(1))
+		t.Assert(gconv.Convert(&uint32Num, "*uint32"), int(1))
+		var uint64Num uint64 = 1
+		t.Assert(gconv.Convert(uint64Num, "*uint64"), int(1))
+		t.Assert(gconv.Convert(&uint64Num, "*uint64"), int(1))
+
+		var float32Num float32 = 1.1
+		t.Assert(gconv.Convert(float32Num, "*float32"), float32(1.1))
+		t.Assert(gconv.Convert(&float32Num, "*float32"), float32(1.1))
+
+		var float64Num float64 = 1.1
+		t.Assert(gconv.Convert(float64Num, "*float64"), float64(1.1))
+		t.Assert(gconv.Convert(&float64Num, "*float64"), float64(1.1))
+
+		var boolValue bool = true
+		t.Assert(gconv.Convert(boolValue, "*bool"), true)
+		t.Assert(gconv.Convert(&boolValue, "*bool"), true)
+
+		var stringValue string = "1"
+		t.Assert(gconv.Convert(stringValue, "*string"), "1")
+		t.Assert(gconv.Convert(&stringValue, "*string"), "1")
+
+		var durationValue time.Duration = 1989
+		var expectDurationValue = time.Duration(int64(1989))
+		t.AssertEQ(gconv.Convert(&durationValue, "*time.Duration"), &expectDurationValue)
+		t.AssertEQ(gconv.Convert(durationValue, "*time.Duration"), &expectDurationValue)
+
+		var string_interface_map = map[string]interface{}{"k1": 1}
+		var string_int_map = map[string]int{"k1": 1}
+		var string_string_map = map[string]string{"k1": "1"}
+		t.AssertEQ(gconv.Convert(string_int_map, "map[string]string"), string_string_map)
+		t.AssertEQ(gconv.Convert(string_int_map, "map[string]interface{}"), string_interface_map)
 	})
 }

--- a/util/gconv/gconv_z_unit_map_test.go
+++ b/util/gconv/gconv_z_unit_map_test.go
@ -38,6 +38,16 @@ func Test_Map_Basic(t *testing.T) {
 		t.Assert(gconv.Map(m3), g.Map{
 			"1.22": "3.1",
 		})
+		t.Assert(gconv.Map(`{"name":"goframe"}`), g.Map{
+			"name": "goframe",
+		})
+		t.Assert(gconv.Map(`{"name":"goframe"`), nil)
+		t.Assert(gconv.Map(`{goframe}`), nil)
+		t.Assert(gconv.Map([]byte(`{"name":"goframe"}`)), g.Map{
+			"name": "goframe",
+		})
+		t.Assert(gconv.Map([]byte(`{"name":"goframe"`)), nil)
+		t.Assert(gconv.Map([]byte(`{goframe}`)), nil)
 	})
 }

@ -69,6 +79,44 @@ func Test_Maps_Basic(t *testing.T) {
 		t.Assert(list[0]["id"], 100)
 		t.Assert(list[1]["id"], 200)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		list := gconv.SliceMap(params)
+		t.Assert(len(list), 2)
+		t.Assert(list[0]["id"], 100)
+		t.Assert(list[1]["id"], 200)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		list := gconv.SliceMapDeep(params)
+		t.Assert(len(list), 2)
+		t.Assert(list[0]["id"], 100)
+		t.Assert(list[1]["id"], 200)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		type Base struct {
+			Age int
+		}
+		type User struct {
+			Id   int
+			Name string
+			Base
+		}
+
+		users := make([]User, 0)
+		params := []g.Map{
+			{"id": 1, "name": "john", "age": 18},
+			{"id": 2, "name": "smith", "age": 20},
+		}
+		err := gconv.SliceStruct(params, &users)
+		t.AssertNil(err)
+		t.Assert(len(users), 2)
+		t.Assert(users[0].Id, params[0]["id"])
+		t.Assert(users[0].Name, params[0]["name"])
+		t.Assert(users[0].Age, 18)
+
+		t.Assert(users[1].Id, params[1]["id"])
+		t.Assert(users[1].Name, params[1]["name"])
+		t.Assert(users[1].Age, 20)
+	})
 }

 func Test_Maps_JsonStr(t *testing.T) {
@ -78,6 +126,18 @@ func Test_Maps_JsonStr(t *testing.T) {
 		t.Assert(len(list), 2)
 		t.Assert(list[0]["id"], 100)
 		t.Assert(list[1]["id"], 200)
+
+		list = gconv.Maps([]byte(jsonStr))
+		t.Assert(len(list), 2)
+		t.Assert(list[0]["id"], 100)
+		t.Assert(list[1]["id"], 200)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(gconv.Maps(`[id]`), nil)
+		t.Assert(gconv.Maps(`test`), nil)
+		t.Assert(gconv.Maps([]byte(`[id]`)), nil)
+		t.Assert(gconv.Maps([]byte(`test`)), nil)
 	})
 }

@ -477,3 +537,72 @@ field3:
 		t.Assert(string(jsonData), `{"field3":{"123":"integer_key"},"outer_struct":{"field1":{"inner1":123,"inner2":345},"field2":{"inner1":123,"inner2":345,"inner3":456,"inner4":789}}}`)
 	})
 }
+
+func TestMapStrStr(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(gconv.MapStrStr(map[string]string{"k": "v"}), map[string]string{"k": "v"})
+		t.Assert(gconv.MapStrStr(`{}`), nil)
+	})
+}
+
+func TestMapStrStrDeep(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(gconv.MapStrStrDeep(map[string]string{"k": "v"}), map[string]string{"k": "v"})
+		t.Assert(gconv.MapStrStrDeep(`{"k":"v"}`), map[string]string{"k": "v"})
+		t.Assert(gconv.MapStrStrDeep(`{}`), nil)
+	})
+}
+
+func TestMapsDeep(t *testing.T) {
+	jsonStr := `[{"id":100, "name":"john"},{"id":200, "name":"smith"}]`
+	params := g.Slice{
+		g.Map{"id": 100, "name": "john"},
+		g.Map{"id": 200, "name": "smith"},
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(gconv.MapsDeep(nil), nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		list := gconv.MapsDeep(params)
+		t.Assert(len(list), 2)
+		t.Assert(list[0]["id"], 100)
+		t.Assert(list[1]["id"], 200)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		list := gconv.MapsDeep(jsonStr)
+		t.Assert(len(list), 2)
+		t.Assert(list[0]["id"], 100)
+		t.Assert(list[1]["id"], 200)
+
+		list = gconv.MapsDeep([]byte(jsonStr))
+		t.Assert(len(list), 2)
+		t.Assert(list[0]["id"], 100)
+		t.Assert(list[1]["id"], 200)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(gconv.MapsDeep(`[id]`), nil)
+		t.Assert(gconv.MapsDeep(`test`), nil)
+		t.Assert(gconv.MapsDeep([]byte(`[id]`)), nil)
+		t.Assert(gconv.MapsDeep([]byte(`test`)), nil)
+		t.Assert(gconv.MapsDeep([]string{}), nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		string_interface_map_list := []map[string]interface{}{}
+		string_interface_map_list = append(string_interface_map_list, map[string]interface{}{"id": 100})
+		string_interface_map_list = append(string_interface_map_list, map[string]interface{}{"id": 200})
+		list := gconv.MapsDeep(string_interface_map_list)
+		t.Assert(len(list), 2)
+		t.Assert(list[0]["id"], 100)
+		t.Assert(list[1]["id"], 200)
+
+		list = gconv.MapsDeep([]byte(jsonStr))
+		t.Assert(len(list), 2)
+		t.Assert(list[0]["id"], 100)
+		t.Assert(list[1]["id"], 200)
+	})
+}
--- a/util/gconv/gconv_z_unit_maptomap_test.go
+++ b/util/gconv/gconv_z_unit_maptomap_test.go
@ -67,6 +67,18 @@ func Test_MapToMap1(t *testing.T) {
 		t.Assert(m2["k1"], m1["k1"])
 		t.Assert(m2["k2"], m1["k2"])
 	})
+	// string -> map[string]interface{}
+	gtest.C(t, func(t *gtest.T) {
+		jsonStr := `{"id":100, "name":"john"}`
+
+		m1 := g.MapStrAny{}
+		t.Assert(gconv.MapToMap(jsonStr, &m1), nil)
+		t.Assert(m1["id"], 100)
+
+		m2 := g.MapStrAny{}
+		t.Assert(gconv.MapToMap([]byte(jsonStr), &m2), nil)
+		t.Assert(m2["id"], 100)
+	})
 }

 func Test_MapToMap2(t *testing.T) {
@ -162,6 +174,18 @@ func Test_MapToMaps(t *testing.T) {
 		t.Assert(len(s), 2)
 		t.Assert(s, params)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		jsonStr := `[{"id":100, "name":"john"},{"id":200, "name":"smith"}]`
+
+		var m1 []g.Map
+		t.Assert(gconv.MapToMaps(jsonStr, &m1), nil)
+		t.Assert(m1[0]["id"], 100)
+		t.Assert(m1[1]["id"], 200)
+
+		t.Assert(gconv.MapToMaps([]byte(jsonStr), &m1), nil)
+		t.Assert(m1[0]["id"], 100)
+		t.Assert(m1[1]["id"], 200)
+	})
 }

 func Test_MapToMaps_StructParams(t *testing.T) {
--- a/util/gconv/gconv_z_unit_string_test.go
+++ b/util/gconv/gconv_z_unit_string_test.go
@ -7,10 +7,11 @@
 package gconv_test

 import (
-	"testing"
-
+	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
+	"testing"
+	"time"
 )

 type stringStruct1 struct {
@ -61,5 +62,10 @@ func Test_String(t *testing.T) {

 		t.AssertEQ(gconv.String(stringStruct2{"john"}), `{"Name":"john"}`)
 		t.AssertEQ(gconv.String(&stringStruct2{"john"}), `{"Name":"john"}`)
+
+		var nilTime *time.Time = nil
+		t.AssertEQ(gconv.String(nilTime), "")
+		var nilGTime *gtime.Time = nil
+		t.AssertEQ(gconv.String(nilGTime), "")
 	})
 }