github.com/wangyougui/gf/v2@v2.6.5/util/gconv/gconv_z_unit_all_test.go

// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/wangyougui/gf.

package gconv_test

import (
	"math"
	"testing"
	"time"

	"github.com/wangyougui/gf/v2/container/gvar"

	"github.com/wangyougui/gf/v2/frame/g"
	"github.com/wangyougui/gf/v2/os/gtime"
	"github.com/wangyougui/gf/v2/test/gtest"
	"github.com/wangyougui/gf/v2/util/gconv"
)

type iString interface {
	String() string
}

type S struct {
}

func (s S) String() string {
	return "22222"
}

type iError interface {
	Error() string
}

type S1 struct {
}

func (s1 S1) Error() string {
	return "22222"
}

func Test_Bool_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.AssertEQ(gconv.Bool(any), false)
		t.AssertEQ(gconv.Bool(false), false)
		t.AssertEQ(gconv.Bool(nil), false)
		t.AssertEQ(gconv.Bool(0), false)
		t.AssertEQ(gconv.Bool("0"), false)
		t.AssertEQ(gconv.Bool(""), false)
		t.AssertEQ(gconv.Bool("false"), false)
		t.AssertEQ(gconv.Bool("off"), false)
		t.AssertEQ(gconv.Bool([]byte{}), false)
		t.AssertEQ(gconv.Bool([]string{}), false)
		t.AssertEQ(gconv.Bool([2]int{1, 2}), true)
		t.AssertEQ(gconv.Bool([]interface{}{}), false)
		t.AssertEQ(gconv.Bool([]map[int]int{}), false)

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Bool(countryCapitalMap), true)

		t.AssertEQ(gconv.Bool("1"), true)
		t.AssertEQ(gconv.Bool("on"), true)
		t.AssertEQ(gconv.Bool(1), true)
		t.AssertEQ(gconv.Bool(123.456), true)
		t.AssertEQ(gconv.Bool(boolStruct{}), true)
		t.AssertEQ(gconv.Bool(&boolStruct{}), true)
	})
}

func Test_Int_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.AssertEQ(gconv.Int(any), 0)
		t.AssertEQ(gconv.Int(false), 0)
		t.AssertEQ(gconv.Int(nil), 0)
		t.Assert(gconv.Int(nil), 0)
		t.AssertEQ(gconv.Int(0), 0)
		t.AssertEQ(gconv.Int("0"), 0)
		t.AssertEQ(gconv.Int(""), 0)
		t.AssertEQ(gconv.Int("false"), 0)
		t.AssertEQ(gconv.Int("off"), 0)
		t.AssertEQ(gconv.Int([]byte{}), 0)
		t.AssertEQ(gconv.Int([]string{}), 0)
		t.AssertEQ(gconv.Int([2]int{1, 2}), 0)
		t.AssertEQ(gconv.Int([]interface{}{}), 0)
		t.AssertEQ(gconv.Int([]map[int]int{}), 0)

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Int(countryCapitalMap), 0)

		t.AssertEQ(gconv.Int("1"), 1)
		t.AssertEQ(gconv.Int("on"), 0)
		t.AssertEQ(gconv.Int(1), 1)
		t.AssertEQ(gconv.Int(123.456), 123)
		t.AssertEQ(gconv.Int(boolStruct{}), 0)
		t.AssertEQ(gconv.Int(&boolStruct{}), 0)
		t.AssertEQ(gconv.Int("NaN"), 0)
	})
}

func Test_Int8_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.Assert(gconv.Int8(any), int8(0))
		t.AssertEQ(gconv.Int8(false), int8(0))
		t.AssertEQ(gconv.Int8(nil), int8(0))
		t.AssertEQ(gconv.Int8(0), int8(0))
		t.AssertEQ(gconv.Int8("0"), int8(0))
		t.AssertEQ(gconv.Int8(""), int8(0))
		t.AssertEQ(gconv.Int8("false"), int8(0))
		t.AssertEQ(gconv.Int8("off"), int8(0))
		t.AssertEQ(gconv.Int8([]byte{}), int8(0))
		t.AssertEQ(gconv.Int8([]string{}), int8(0))
		t.AssertEQ(gconv.Int8([2]int{1, 2}), int8(0))
		t.AssertEQ(gconv.Int8([]interface{}{}), int8(0))
		t.AssertEQ(gconv.Int8([]map[int]int{}), int8(0))

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Int8(countryCapitalMap), int8(0))

		t.AssertEQ(gconv.Int8("1"), int8(1))
		t.AssertEQ(gconv.Int8("on"), int8(0))
		t.AssertEQ(gconv.Int8(int8(1)), int8(1))
		t.AssertEQ(gconv.Int8(123.456), int8(123))
		t.AssertEQ(gconv.Int8(boolStruct{}), int8(0))
		t.AssertEQ(gconv.Int8(&boolStruct{}), int8(0))
		t.AssertEQ(gconv.Int8("NaN"), int8(0))

	})
}

func Test_Int16_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.Assert(gconv.Int16(any), int16(0))
		t.AssertEQ(gconv.Int16(false), int16(0))
		t.AssertEQ(gconv.Int16(nil), int16(0))
		t.AssertEQ(gconv.Int16(0), int16(0))
		t.AssertEQ(gconv.Int16("0"), int16(0))
		t.AssertEQ(gconv.Int16(""), int16(0))
		t.AssertEQ(gconv.Int16("false"), int16(0))
		t.AssertEQ(gconv.Int16("off"), int16(0))
		t.AssertEQ(gconv.Int16([]byte{}), int16(0))
		t.AssertEQ(gconv.Int16([]string{}), int16(0))
		t.AssertEQ(gconv.Int16([2]int{1, 2}), int16(0))
		t.AssertEQ(gconv.Int16([]interface{}{}), int16(0))
		t.AssertEQ(gconv.Int16([]map[int]int{}), int16(0))

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Int16(countryCapitalMap), int16(0))

		t.AssertEQ(gconv.Int16("1"), int16(1))
		t.AssertEQ(gconv.Int16("on"), int16(0))
		t.AssertEQ(gconv.Int16(int16(1)), int16(1))
		t.AssertEQ(gconv.Int16(123.456), int16(123))
		t.AssertEQ(gconv.Int16(boolStruct{}), int16(0))
		t.AssertEQ(gconv.Int16(&boolStruct{}), int16(0))
		t.AssertEQ(gconv.Int16("NaN"), int16(0))
	})
}

func Test_Int32_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.Assert(gconv.Int32(any), int32(0))
		t.AssertEQ(gconv.Int32(false), int32(0))
		t.AssertEQ(gconv.Int32(nil), int32(0))
		t.AssertEQ(gconv.Int32(0), int32(0))
		t.AssertEQ(gconv.Int32("0"), int32(0))
		t.AssertEQ(gconv.Int32(""), int32(0))
		t.AssertEQ(gconv.Int32("false"), int32(0))
		t.AssertEQ(gconv.Int32("off"), int32(0))
		t.AssertEQ(gconv.Int32([]byte{}), int32(0))
		t.AssertEQ(gconv.Int32([]string{}), int32(0))
		t.AssertEQ(gconv.Int32([2]int{1, 2}), int32(0))
		t.AssertEQ(gconv.Int32([]interface{}{}), int32(0))
		t.AssertEQ(gconv.Int32([]map[int]int{}), int32(0))

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Int32(countryCapitalMap), int32(0))

		t.AssertEQ(gconv.Int32("1"), int32(1))
		t.AssertEQ(gconv.Int32("on"), int32(0))
		t.AssertEQ(gconv.Int32(int32(1)), int32(1))
		t.AssertEQ(gconv.Int32(123.456), int32(123))
		t.AssertEQ(gconv.Int32(boolStruct{}), int32(0))
		t.AssertEQ(gconv.Int32(&boolStruct{}), int32(0))
		t.AssertEQ(gconv.Int32("NaN"), int32(0))
	})
}

func Test_Int64_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.AssertEQ(gconv.Int64("0x00e"), int64(14))
		t.Assert(gconv.Int64("022"), int64(22))

		t.Assert(gconv.Int64(any), int64(0))
		t.Assert(gconv.Int64(true), 1)
		t.Assert(gconv.Int64("1"), int64(1))
		t.Assert(gconv.Int64("0"), int64(0))
		t.Assert(gconv.Int64("X"), int64(0))
		t.Assert(gconv.Int64("x"), int64(0))
		t.Assert(gconv.Int64(int64(1)), int64(1))
		t.Assert(gconv.Int64(int(0)), int64(0))
		t.Assert(gconv.Int64(int8(0)), int64(0))
		t.Assert(gconv.Int64(int16(0)), int64(0))
		t.Assert(gconv.Int64(int32(0)), int64(0))
		t.Assert(gconv.Int64(uint64(0)), int64(0))
		t.Assert(gconv.Int64(uint32(0)), int64(0))
		t.Assert(gconv.Int64(uint16(0)), int64(0))
		t.Assert(gconv.Int64(uint8(0)), int64(0))
		t.Assert(gconv.Int64(uint(0)), int64(0))
		t.Assert(gconv.Int64(float32(0)), int64(0))

		t.AssertEQ(gconv.Int64(false), int64(0))
		t.AssertEQ(gconv.Int64(nil), int64(0))
		t.AssertEQ(gconv.Int64(0), int64(0))
		t.AssertEQ(gconv.Int64("0"), int64(0))
		t.AssertEQ(gconv.Int64(""), int64(0))
		t.AssertEQ(gconv.Int64("false"), int64(0))
		t.AssertEQ(gconv.Int64("off"), int64(0))
		t.AssertEQ(gconv.Int64([]byte{}), int64(0))
		t.AssertEQ(gconv.Int64([]string{}), int64(0))
		t.AssertEQ(gconv.Int64([2]int{1, 2}), int64(0))
		t.AssertEQ(gconv.Int64([]interface{}{}), int64(0))
		t.AssertEQ(gconv.Int64([]map[int]int{}), int64(0))

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Int64(countryCapitalMap), int64(0))

		t.AssertEQ(gconv.Int64("1"), int64(1))
		t.AssertEQ(gconv.Int64("on"), int64(0))
		t.AssertEQ(gconv.Int64(int64(1)), int64(1))
		t.AssertEQ(gconv.Int64(123.456), int64(123))
		t.AssertEQ(gconv.Int64(boolStruct{}), int64(0))
		t.AssertEQ(gconv.Int64(&boolStruct{}), int64(0))
		t.AssertEQ(gconv.Int64("NaN"), int64(0))
	})
}

func Test_Uint_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.AssertEQ(gconv.Uint(any), uint(0))
		t.AssertEQ(gconv.Uint(false), uint(0))
		t.AssertEQ(gconv.Uint(nil), uint(0))
		t.Assert(gconv.Uint(nil), uint(0))
		t.AssertEQ(gconv.Uint(uint(0)), uint(0))
		t.AssertEQ(gconv.Uint("0"), uint(0))
		t.AssertEQ(gconv.Uint(""), uint(0))
		t.AssertEQ(gconv.Uint("false"), uint(0))
		t.AssertEQ(gconv.Uint("off"), uint(0))
		t.AssertEQ(gconv.Uint([]byte{}), uint(0))
		t.AssertEQ(gconv.Uint([]string{}), uint(0))
		t.AssertEQ(gconv.Uint([2]int{1, 2}), uint(0))
		t.AssertEQ(gconv.Uint([]interface{}{}), uint(0))
		t.AssertEQ(gconv.Uint([]map[int]int{}), uint(0))

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Uint(countryCapitalMap), uint(0))

		t.AssertEQ(gconv.Uint("1"), uint(1))
		t.AssertEQ(gconv.Uint("on"), uint(0))
		t.AssertEQ(gconv.Uint(1), uint(1))
		t.AssertEQ(gconv.Uint(123.456), uint(123))
		t.AssertEQ(gconv.Uint(boolStruct{}), uint(0))
		t.AssertEQ(gconv.Uint(&boolStruct{}), uint(0))
		t.AssertEQ(gconv.Uint("NaN"), uint(0))
	})
}

func Test_Uint8_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.Assert(gconv.Uint8(any), uint8(0))
		t.AssertEQ(gconv.Uint8(uint8(1)), uint8(1))
		t.AssertEQ(gconv.Uint8(false), uint8(0))
		t.AssertEQ(gconv.Uint8(nil), uint8(0))
		t.AssertEQ(gconv.Uint8(0), uint8(0))
		t.AssertEQ(gconv.Uint8("0"), uint8(0))
		t.AssertEQ(gconv.Uint8(""), uint8(0))
		t.AssertEQ(gconv.Uint8("false"), uint8(0))
		t.AssertEQ(gconv.Uint8("off"), uint8(0))
		t.AssertEQ(gconv.Uint8([]byte{}), uint8(0))
		t.AssertEQ(gconv.Uint8([]string{}), uint8(0))
		t.AssertEQ(gconv.Uint8([2]int{1, 2}), uint8(0))
		t.AssertEQ(gconv.Uint8([]interface{}{}), uint8(0))
		t.AssertEQ(gconv.Uint8([]map[int]int{}), uint8(0))

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Uint8(countryCapitalMap), uint8(0))

		t.AssertEQ(gconv.Uint8("1"), uint8(1))
		t.AssertEQ(gconv.Uint8("on"), uint8(0))
		t.AssertEQ(gconv.Uint8(int8(1)), uint8(1))
		t.AssertEQ(gconv.Uint8(123.456), uint8(123))
		t.AssertEQ(gconv.Uint8(boolStruct{}), uint8(0))
		t.AssertEQ(gconv.Uint8(&boolStruct{}), uint8(0))
		t.AssertEQ(gconv.Uint8("NaN"), uint8(0))
	})
}

func Test_Uint16_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.Assert(gconv.Uint16(any), uint16(0))
		t.AssertEQ(gconv.Uint16(uint16(1)), uint16(1))
		t.AssertEQ(gconv.Uint16(false), uint16(0))
		t.AssertEQ(gconv.Uint16(nil), uint16(0))
		t.AssertEQ(gconv.Uint16(0), uint16(0))
		t.AssertEQ(gconv.Uint16("0"), uint16(0))
		t.AssertEQ(gconv.Uint16(""), uint16(0))
		t.AssertEQ(gconv.Uint16("false"), uint16(0))
		t.AssertEQ(gconv.Uint16("off"), uint16(0))
		t.AssertEQ(gconv.Uint16([]byte{}), uint16(0))
		t.AssertEQ(gconv.Uint16([]string{}), uint16(0))
		t.AssertEQ(gconv.Uint16([2]int{1, 2}), uint16(0))
		t.AssertEQ(gconv.Uint16([]interface{}{}), uint16(0))
		t.AssertEQ(gconv.Uint16([]map[int]int{}), uint16(0))

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Uint16(countryCapitalMap), uint16(0))

		t.AssertEQ(gconv.Uint16("1"), uint16(1))
		t.AssertEQ(gconv.Uint16("on"), uint16(0))
		t.AssertEQ(gconv.Uint16(int16(1)), uint16(1))
		t.AssertEQ(gconv.Uint16(123.456), uint16(123))
		t.AssertEQ(gconv.Uint16(boolStruct{}), uint16(0))
		t.AssertEQ(gconv.Uint16(&boolStruct{}), uint16(0))
		t.AssertEQ(gconv.Uint16("NaN"), uint16(0))
	})
}

func Test_Uint32_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.Assert(gconv.Uint32(any), uint32(0))
		t.AssertEQ(gconv.Uint32(uint32(1)), uint32(1))
		t.AssertEQ(gconv.Uint32(false), uint32(0))
		t.AssertEQ(gconv.Uint32(nil), uint32(0))
		t.AssertEQ(gconv.Uint32(0), uint32(0))
		t.AssertEQ(gconv.Uint32("0"), uint32(0))
		t.AssertEQ(gconv.Uint32(""), uint32(0))
		t.AssertEQ(gconv.Uint32("false"), uint32(0))
		t.AssertEQ(gconv.Uint32("off"), uint32(0))
		t.AssertEQ(gconv.Uint32([]byte{}), uint32(0))
		t.AssertEQ(gconv.Uint32([]string{}), uint32(0))
		t.AssertEQ(gconv.Uint32([2]int{1, 2}), uint32(0))
		t.AssertEQ(gconv.Uint32([]interface{}{}), uint32(0))
		t.AssertEQ(gconv.Uint32([]map[int]int{}), uint32(0))

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Uint32(countryCapitalMap), uint32(0))

		t.AssertEQ(gconv.Uint32("1"), uint32(1))
		t.AssertEQ(gconv.Uint32("on"), uint32(0))
		t.AssertEQ(gconv.Uint32(int32(1)), uint32(1))
		t.AssertEQ(gconv.Uint32(123.456), uint32(123))
		t.AssertEQ(gconv.Uint32(boolStruct{}), uint32(0))
		t.AssertEQ(gconv.Uint32(&boolStruct{}), uint32(0))
		t.AssertEQ(gconv.Uint32("NaN"), uint32(0))
	})
}

func Test_Uint64_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.AssertEQ(gconv.Uint64("0x00e"), uint64(14))
		t.Assert(gconv.Uint64("022"), uint64(22))

		t.AssertEQ(gconv.Uint64(any), uint64(0))
		t.AssertEQ(gconv.Uint64(true), uint64(1))
		t.Assert(gconv.Uint64("1"), int64(1))
		t.Assert(gconv.Uint64("0"), uint64(0))
		t.Assert(gconv.Uint64("X"), uint64(0))
		t.Assert(gconv.Uint64("x"), uint64(0))
		t.Assert(gconv.Uint64(int64(1)), uint64(1))
		t.Assert(gconv.Uint64(int(0)), uint64(0))
		t.Assert(gconv.Uint64(int8(0)), uint64(0))
		t.Assert(gconv.Uint64(int16(0)), uint64(0))
		t.Assert(gconv.Uint64(int32(0)), uint64(0))
		t.Assert(gconv.Uint64(uint64(0)), uint64(0))
		t.Assert(gconv.Uint64(uint32(0)), uint64(0))
		t.Assert(gconv.Uint64(uint16(0)), uint64(0))
		t.Assert(gconv.Uint64(uint8(0)), uint64(0))
		t.Assert(gconv.Uint64(uint(0)), uint64(0))
		t.Assert(gconv.Uint64(float32(0)), uint64(0))

		t.AssertEQ(gconv.Uint64(false), uint64(0))
		t.AssertEQ(gconv.Uint64(nil), uint64(0))
		t.AssertEQ(gconv.Uint64(0), uint64(0))
		t.AssertEQ(gconv.Uint64("0"), uint64(0))
		t.AssertEQ(gconv.Uint64(""), uint64(0))
		t.AssertEQ(gconv.Uint64("false"), uint64(0))
		t.AssertEQ(gconv.Uint64("off"), uint64(0))
		t.AssertEQ(gconv.Uint64([]byte{}), uint64(0))
		t.AssertEQ(gconv.Uint64([]string{}), uint64(0))
		t.AssertEQ(gconv.Uint64([2]int{1, 2}), uint64(0))
		t.AssertEQ(gconv.Uint64([]interface{}{}), uint64(0))
		t.AssertEQ(gconv.Uint64([]map[int]int{}), uint64(0))

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Uint64(countryCapitalMap), uint64(0))

		t.AssertEQ(gconv.Uint64("1"), uint64(1))
		t.AssertEQ(gconv.Uint64("on"), uint64(0))
		t.AssertEQ(gconv.Uint64(int64(1)), uint64(1))
		t.AssertEQ(gconv.Uint64(123.456), uint64(123))
		t.AssertEQ(gconv.Uint64(boolStruct{}), uint64(0))
		t.AssertEQ(gconv.Uint64(&boolStruct{}), uint64(0))
		t.AssertEQ(gconv.Uint64("NaN"), uint64(0))
	})
}

func Test_Float32_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.Assert(gconv.Float32(any), float32(0))
		t.AssertEQ(gconv.Float32(false), float32(0))
		t.AssertEQ(gconv.Float32(nil), float32(0))
		t.AssertEQ(gconv.Float32(0), float32(0))
		t.AssertEQ(gconv.Float32("0"), float32(0))
		t.AssertEQ(gconv.Float32(""), float32(0))
		t.AssertEQ(gconv.Float32("false"), float32(0))
		t.AssertEQ(gconv.Float32("off"), float32(0))
		t.AssertEQ(gconv.Float32([]byte{}), float32(0))
		t.AssertEQ(gconv.Float32([]string{}), float32(0))
		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对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Float32(countryCapitalMap), float32(0))

		t.AssertEQ(gconv.Float32("1"), float32(1))
		t.AssertEQ(gconv.Float32("on"), float32(0))
		t.AssertEQ(gconv.Float32(float32(1)), float32(1))
		t.AssertEQ(gconv.Float32(123.456), float32(123.456))
		t.AssertEQ(gconv.Float32(boolStruct{}), float32(0))
		t.AssertEQ(gconv.Float32(&boolStruct{}), float32(0))
		t.AssertEQ(gconv.Float32("NaN"), float32(math.NaN()))
	})
}

func Test_Float64_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.Assert(gconv.Float64(any), float64(0))
		t.AssertEQ(gconv.Float64(false), float64(0))
		t.AssertEQ(gconv.Float64(nil), float64(0))
		t.AssertEQ(gconv.Float64(0), float64(0))
		t.AssertEQ(gconv.Float64("0"), float64(0))
		t.AssertEQ(gconv.Float64(""), float64(0))
		t.AssertEQ(gconv.Float64("false"), float64(0))
		t.AssertEQ(gconv.Float64("off"), float64(0))
		t.AssertEQ(gconv.Float64([]byte{}), float64(0))
		t.AssertEQ(gconv.Float64([]string{}), float64(0))
		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对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.Float64(countryCapitalMap), float64(0))

		t.AssertEQ(gconv.Float64("1"), float64(1))
		t.AssertEQ(gconv.Float64("on"), float64(0))
		t.AssertEQ(gconv.Float64(float64(1)), float64(1))
		t.AssertEQ(gconv.Float64(123.456), float64(123.456))
		t.AssertEQ(gconv.Float64(boolStruct{}), float64(0))
		t.AssertEQ(gconv.Float64(&boolStruct{}), float64(0))
		t.AssertEQ(gconv.Float64("NaN"), float64(math.NaN()))
	})
}

func Test_String_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var s []rune
		t.AssertEQ(gconv.String(s), "")
		var any interface{} = nil
		t.AssertEQ(gconv.String(any), "")
		t.AssertEQ(gconv.String("1"), "1")
		t.AssertEQ(gconv.String("0"), string("0"))
		t.Assert(gconv.String("X"), string("X"))
		t.Assert(gconv.String("x"), string("x"))
		t.Assert(gconv.String(int64(1)), uint64(1))
		t.Assert(gconv.String(int(0)), string("0"))
		t.Assert(gconv.String(int8(0)), string("0"))
		t.Assert(gconv.String(int16(0)), string("0"))
		t.Assert(gconv.String(int32(0)), string("0"))
		t.Assert(gconv.String(uint64(0)), string("0"))
		t.Assert(gconv.String(uint32(0)), string("0"))
		t.Assert(gconv.String(uint16(0)), string("0"))
		t.Assert(gconv.String(uint8(0)), string("0"))
		t.Assert(gconv.String(uint(0)), string("0"))
		t.Assert(gconv.String(float32(0)), string("0"))
		t.AssertEQ(gconv.String(true), "true")
		t.AssertEQ(gconv.String(false), "false")
		t.AssertEQ(gconv.String(nil), "")
		t.AssertEQ(gconv.String(0), string("0"))
		t.AssertEQ(gconv.String("0"), string("0"))
		t.AssertEQ(gconv.String(""), "")
		t.AssertEQ(gconv.String("false"), "false")
		t.AssertEQ(gconv.String("off"), string("off"))
		t.AssertEQ(gconv.String([]byte{}), "")
		t.AssertEQ(gconv.String([]string{}), "[]")
		t.AssertEQ(gconv.String([2]int{1, 2}), "[1,2]")
		t.AssertEQ(gconv.String([]interface{}{}), "[]")
		t.AssertEQ(gconv.String(map[int]int{}), "{}")

		var countryCapitalMap = make(map[string]string)
		/* map插入key - value对,各个国家对应的首都 */
		countryCapitalMap["France"] = "巴黎"
		countryCapitalMap["Italy"] = "罗马"
		countryCapitalMap["Japan"] = "东京"
		countryCapitalMap["India "] = "新德里"
		t.AssertEQ(gconv.String(countryCapitalMap), `{"France":"巴黎","India ":"新德里","Italy":"罗马","Japan":"东京"}`)
		t.AssertEQ(gconv.String(int64(1)), "1")
		t.AssertEQ(gconv.String(123.456), "123.456")
		t.AssertEQ(gconv.String(boolStruct{}), "{}")
		t.AssertEQ(gconv.String(&boolStruct{}), "{}")

		var info = new(S)
		t.AssertEQ(gconv.String(info), "22222")
		var errInfo = new(S1)
		t.AssertEQ(gconv.String(errInfo), "22222")
	})
}

func Test_Runes_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		t.AssertEQ(gconv.Runes("www"), []int32{119, 119, 119})
		var s []rune
		t.AssertEQ(gconv.Runes(s), nil)
	})
}

func Test_Rune_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		t.AssertEQ(gconv.Rune("www"), int32(0))
		t.AssertEQ(gconv.Rune(int32(0)), int32(0))
		var s []rune
		t.AssertEQ(gconv.Rune(s), int32(0))
	})
}

func Test_Bytes_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		t.AssertEQ(gconv.Bytes(nil), nil)
		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})
	})
}

func Test_Byte_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		t.AssertEQ(gconv.Byte(uint8(0)), uint8(0))
		t.AssertEQ(gconv.Byte("s"), uint8(0))
		t.AssertEQ(gconv.Byte([]byte("s")), uint8(115))
	})
}

func Test_Convert_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		var any interface{} = nil
		t.AssertEQ(gconv.Convert(any, "string"), "")
		t.AssertEQ(gconv.Convert("1", "string"), "1")
		t.Assert(gconv.Convert(int64(1), "int64"), int64(1))
		t.Assert(gconv.Convert(int(0), "int"), int(0))
		t.Assert(gconv.Convert(int8(0), "int8"), int8(0))
		t.Assert(gconv.Convert(int16(0), "int16"), int16(0))
		t.Assert(gconv.Convert(int32(0), "int32"), int32(0))
		t.Assert(gconv.Convert(uint64(0), "uint64"), uint64(0))
		t.Assert(gconv.Convert(uint32(0), "uint32"), uint32(0))
		t.Assert(gconv.Convert(uint16(0), "uint16"), uint16(0))
		t.Assert(gconv.Convert(uint8(0), "uint8"), uint8(0))
		t.Assert(gconv.Convert(uint(0), "uint"), uint(0))
		t.Assert(gconv.Convert(float32(0), "float32"), float32(0))
		t.Assert(gconv.Convert(float64(0), "float64"), float64(0))
		t.AssertEQ(gconv.Convert(true, "bool"), true)
		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())
		t.AssertEQ(gconv.Convert(1989, "gtime.Time"), *gconv.GTime("1970-01-01 08:33:09 +0800 CST"))
		t.AssertEQ(gconv.Convert(gtime.Now(), "*gtime.Time", 1), gtime.New())
		t.AssertEQ(gconv.Convert(gtime.Now(), "GTime", 1), *gtime.New())
		t.AssertEQ(gconv.Convert(1989, "*gtime.Time"), gconv.GTime(1989))
		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)
	})
}

func Test_Slice_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		value := 123.456
		t.AssertEQ(gconv.Ints(value), []int{123})
		t.AssertEQ(gconv.Ints(nil), nil)
		t.AssertEQ(gconv.Ints([]string{"1", "2"}), []int{1, 2})
		t.AssertEQ(gconv.Ints([]int{}), []int{})
		t.AssertEQ(gconv.Ints([]int8{1, 2}), []int{1, 2})
		t.AssertEQ(gconv.Ints([]int16{1, 2}), []int{1, 2})
		t.AssertEQ(gconv.Ints([]int32{1, 2}), []int{1, 2})
		t.AssertEQ(gconv.Ints([]int64{1, 2}), []int{1, 2})
		t.AssertEQ(gconv.Ints([]uint{1}), []int{1})
		t.AssertEQ(gconv.Ints([]uint8{1, 2}), []int{1, 2})
		t.AssertEQ(gconv.Ints([]uint16{1, 2}), []int{1, 2})
		t.AssertEQ(gconv.Ints([]uint32{1, 2}), []int{1, 2})
		t.AssertEQ(gconv.Ints([]uint64{1, 2}), []int{1, 2})
		t.AssertEQ(gconv.Ints([]bool{true}), []int{1})
		t.AssertEQ(gconv.Ints([]float32{1, 2}), []int{1, 2})
		t.AssertEQ(gconv.Ints([]float64{1, 2}), []int{1, 2})
		var inter []interface{} = make([]interface{}, 2)
		t.AssertEQ(gconv.Ints(inter), []int{0, 0})

		t.AssertEQ(gconv.Strings(value), []string{"123.456"})
		t.AssertEQ(gconv.Strings(nil), nil)
		t.AssertEQ(gconv.Strings([]string{"1", "2"}), []string{"1", "2"})
		t.AssertEQ(gconv.Strings([]int{1}), []string{"1"})
		t.AssertEQ(gconv.Strings([]int8{1, 2}), []string{"1", "2"})
		t.AssertEQ(gconv.Strings([]int16{1, 2}), []string{"1", "2"})
		t.AssertEQ(gconv.Strings([]int32{1, 2}), []string{"1", "2"})
		t.AssertEQ(gconv.Strings([]int64{1, 2}), []string{"1", "2"})
		t.AssertEQ(gconv.Strings([]uint{1}), []string{"1"})
		t.AssertEQ(gconv.Strings([]uint8{1, 2}), []string{"1", "2"})
		t.AssertEQ(gconv.Strings([]uint16{1, 2}), []string{"1", "2"})
		t.AssertEQ(gconv.Strings([]uint32{1, 2}), []string{"1", "2"})
		t.AssertEQ(gconv.Strings([]uint64{1, 2}), []string{"1", "2"})
		t.AssertEQ(gconv.Strings([]bool{true}), []string{"true"})
		t.AssertEQ(gconv.Strings([]float32{1, 2}), []string{"1", "2"})
		t.AssertEQ(gconv.Strings([]float64{1, 2}), []string{"1", "2"})
		var strer = make([]interface{}, 2)
		t.AssertEQ(gconv.Strings(strer), []string{"", ""})

		t.AssertEQ(gconv.Floats(value), []float64{123.456})
		t.AssertEQ(gconv.Floats(nil), nil)
		t.AssertEQ(gconv.Floats([]string{"1", "2"}), []float64{1, 2})
		t.AssertEQ(gconv.Floats([]int{1}), []float64{1})
		t.AssertEQ(gconv.Floats([]int8{1, 2}), []float64{1, 2})
		t.AssertEQ(gconv.Floats([]int16{1, 2}), []float64{1, 2})
		t.AssertEQ(gconv.Floats([]int32{1, 2}), []float64{1, 2})
		t.AssertEQ(gconv.Floats([]int64{1, 2}), []float64{1, 2})
		t.AssertEQ(gconv.Floats([]uint{1}), []float64{1})
		t.AssertEQ(gconv.Floats([]uint8{1, 2}), []float64{1, 2})
		t.AssertEQ(gconv.Floats([]uint16{1, 2}), []float64{1, 2})
		t.AssertEQ(gconv.Floats([]uint32{1, 2}), []float64{1, 2})
		t.AssertEQ(gconv.Floats([]uint64{1, 2}), []float64{1, 2})
		t.AssertEQ(gconv.Floats([]bool{true}), []float64{0})
		t.AssertEQ(gconv.Floats([]float32{1, 2}), []float64{1, 2})
		t.AssertEQ(gconv.Floats([]float64{1, 2}), []float64{1, 2})
		var floer = make([]interface{}, 2)
		t.AssertEQ(gconv.Floats(floer), []float64{0, 0})

		t.AssertEQ(gconv.Interfaces(value), []interface{}{123.456})
		t.AssertEQ(gconv.Interfaces(nil), nil)
		t.AssertEQ(gconv.Interfaces([]interface{}{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]string{"1"}), []interface{}{"1"})
		t.AssertEQ(gconv.Interfaces([]int{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]int8{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]int16{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]int32{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]int64{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]uint{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]uint8{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]uint16{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]uint32{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]uint64{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]bool{true}), []interface{}{true})
		t.AssertEQ(gconv.Interfaces([]float32{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([]float64{1}), []interface{}{1})
		t.AssertEQ(gconv.Interfaces([1]int{1}), []interface{}{1})

		type interSlice []int
		slices := interSlice{1}
		t.AssertEQ(gconv.Interfaces(slices), []interface{}{1})

		t.AssertEQ(gconv.Maps(nil), nil)
		t.AssertEQ(gconv.Maps([]map[string]interface{}{{"a": "1"}}), []map[string]interface{}{{"a": "1"}})
		t.AssertEQ(gconv.Maps(1223), []map[string]interface{}{nil})
		t.AssertEQ(gconv.Maps([]int{}), nil)
	})
}

// 私有属性不会进行转换
func Test_Slice_PrivateAttribute_All(t *testing.T) {
	type User struct {
		Id   int           `json:"id"`
		name string        `json:"name"`
		Ad   []interface{} `json:"ad"`
	}
	gtest.C(t, func(t *gtest.T) {
		user := &User{1, "john", []interface{}{2}}
		array := gconv.Interfaces(user)
		t.Assert(len(array), 1)
		t.Assert(array[0].(*User).Id, 1)
		t.Assert(array[0].(*User).name, "john")
		t.Assert(array[0].(*User).Ad, []interface{}{2})
	})
}

func Test_Map_Basic_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		m1 := map[string]string{
			"k": "v",
		}
		m2 := map[int]string{
			3: "v",
		}
		m3 := map[float64]float32{
			1.22: 3.1,
		}
		t.Assert(gconv.Map(m1), g.Map{
			"k": "v",
		})
		t.Assert(gconv.Map(m2), g.Map{
			"3": "v",
		})
		t.Assert(gconv.Map(m3), g.Map{
			"1.22": "3.1",
		})
		t.AssertEQ(gconv.Map(nil), nil)
		t.AssertEQ(gconv.Map(map[string]interface{}{"a": 1}), map[string]interface{}{"a": 1})
		t.AssertEQ(gconv.Map(map[int]interface{}{1: 1}), map[string]interface{}{"1": 1})
		t.AssertEQ(gconv.Map(map[uint]interface{}{1: 1}), map[string]interface{}{"1": 1})
		t.AssertEQ(gconv.Map(map[uint]string{1: "1"}), map[string]interface{}{"1": "1"})

		t.AssertEQ(gconv.Map(map[interface{}]interface{}{"a": 1}), map[interface{}]interface{}{"a": 1})
		t.AssertEQ(gconv.Map(map[interface{}]string{"a": "1"}), map[interface{}]string{"a": "1"})
		t.AssertEQ(gconv.Map(map[interface{}]int{"a": 1}), map[interface{}]int{"a": 1})
		t.AssertEQ(gconv.Map(map[interface{}]uint{"a": 1}), map[interface{}]uint{"a": 1})
		t.AssertEQ(gconv.Map(map[interface{}]float32{"a": 1}), map[interface{}]float32{"a": 1})
		t.AssertEQ(gconv.Map(map[interface{}]float64{"a": 1}), map[interface{}]float64{"a": 1})

		t.AssertEQ(gconv.Map(map[string]bool{"a": true}), map[string]interface{}{"a": true})
		t.AssertEQ(gconv.Map(map[string]int{"a": 1}), map[string]interface{}{"a": 1})
		t.AssertEQ(gconv.Map(map[string]uint{"a": 1}), map[string]interface{}{"a": 1})
		t.AssertEQ(gconv.Map(map[string]float32{"a": 1}), map[string]interface{}{"a": 1})
		t.AssertEQ(gconv.Map(map[string]float64{"a": 1}), map[string]interface{}{"a": 1})

	})
}

func Test_Map_StructWithGconvTag_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type User struct {
			Uid      int
			Name     string
			SiteUrl  string   `gconv:"-"`
			NickName string   `gconv:"nickname,omitempty"`
			Pass1    string   `gconv:"password1"`
			Pass2    string   `gconv:"password2"`
			Ss       []string `gconv:"ss"`
		}
		user1 := User{
			Uid:     100,
			Name:    "john",
			SiteUrl: "https://goframe.org",
			Pass1:   "123",
			Pass2:   "456",
			Ss:      []string{"sss", "2222"},
		}
		user2 := &user1
		map1 := gconv.Map(user1)
		map2 := gconv.Map(user2)
		t.Assert(map1["Uid"], 100)
		t.Assert(map1["Name"], "john")
		t.Assert(map1["SiteUrl"], nil)
		t.Assert(map1["NickName"], nil)
		t.Assert(map1["nickname"], nil)
		t.Assert(map1["password1"], "123")
		t.Assert(map1["password2"], "456")
		t.Assert(map2["Uid"], 100)
		t.Assert(map2["Name"], "john")
		t.Assert(map2["SiteUrl"], nil)
		t.Assert(map2["NickName"], nil)
		t.Assert(map2["nickname"], nil)
		t.Assert(map2["password1"], "123")
		t.Assert(map2["password2"], "456")
	})
}

func Test_Map_StructWithJsonTag_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type User struct {
			Uid      int
			Name     string
			SiteUrl  string   `json:"-"`
			NickName string   `json:"nickname, omitempty"`
			Pass1    string   `json:"password1,newpassword"`
			Pass2    string   `json:"password2"`
			Ss       []string `json:"omitempty"`
			ssb, ssa string
		}
		user1 := User{
			Uid:     100,
			Name:    "john",
			SiteUrl: "https://goframe.org",
			Pass1:   "123",
			Pass2:   "456",
			Ss:      []string{"sss", "2222"},
			ssb:     "11",
			ssa:     "222",
		}
		user3 := User{
			Uid:      100,
			Name:     "john",
			NickName: "SSS",
			SiteUrl:  "https://goframe.org",
			Pass1:    "123",
			Pass2:    "456",
			Ss:       []string{"sss", "2222"},
			ssb:      "11",
			ssa:      "222",
		}
		user2 := &user1
		_ = gconv.Map(user1, gconv.MapOption{Tags: []string{"Ss"}})
		map1 := gconv.Map(user1, gconv.MapOption{Tags: []string{"json", "json2"}})
		map2 := gconv.Map(user2)
		map3 := gconv.Map(user3)
		t.Assert(map1["Uid"], 100)
		t.Assert(map1["Name"], "john")
		t.Assert(map1["SiteUrl"], nil)
		t.Assert(map1["NickName"], nil)
		t.Assert(map1["nickname"], nil)
		t.Assert(map1["password1"], "123")
		t.Assert(map1["password2"], "456")
		t.Assert(map2["Uid"], 100)
		t.Assert(map2["Name"], "john")
		t.Assert(map2["SiteUrl"], nil)
		t.Assert(map2["NickName"], nil)
		t.Assert(map2["nickname"], nil)
		t.Assert(map2["password1"], "123")
		t.Assert(map2["password2"], "456")
		t.Assert(map3["NickName"], nil)
	})
}

func Test_Map_PrivateAttribute_All(t *testing.T) {
	type User struct {
		Id   int
		name string
	}
	gtest.C(t, func(t *gtest.T) {
		user := &User{1, "john"}
		t.Assert(gconv.Map(user), g.Map{"Id": 1})
	})
}

func Test_Map_StructInherit_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type Ids struct {
			Id  int `json:"id"`
			Uid int `json:"uid"`
		}
		type Base struct {
			Ids
			CreateTime string `json:"create_time"`
		}
		type User struct {
			Base
			Passport string  `json:"passport"`
			Password string  `json:"password"`
			Nickname string  `json:"nickname"`
			S        *string `json:"nickname2"`
		}

		user := new(User)
		user.Id = 100
		user.Nickname = "john"
		user.CreateTime = "2019"
		var s = "s"
		user.S = &s

		m := gconv.MapDeep(user)
		t.Assert(m["id"], user.Id)
		t.Assert(m["nickname"], user.Nickname)
		t.Assert(m["create_time"], user.CreateTime)
		t.Assert(m["nickname2"], user.S)
	})
}

func Test_Struct_Basic1_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type Score struct {
			Name   int
			Result string
		}

		type Score2 struct {
			Name   int
			Result string
		}

		type User struct {
			Uid      int
			Name     string
			Site_Url string
			NickName string
			Pass1    string `gconv:"password1"`
			Pass2    string `gconv:"password2"`
			As       *Score
			Ass      Score
			Assb     []interface{}
		}
		// 使用默认映射规则绑定属性值到对象
		user := new(User)
		params1 := g.Map{
			"uid":       1,
			"Name":      "john",
			"siteurl":   "https://goframe.org",
			"nick_name": "johng",
			"PASS1":     "123",
			"PASS2":     "456",
			"As":        g.Map{"Name": 1, "Result": "22222"},
			"Ass":       &Score{11, "11"},
			"Assb":      []string{"wwww"},
		}
		_ = gconv.Struct(nil, user)
		_ = gconv.Struct(params1, nil)
		_ = gconv.Struct([]interface{}{nil}, user)
		_ = gconv.Struct(user, []interface{}{nil})

		var a = []interface{}{nil}
		ab := &a
		_ = gconv.Struct(params1, *ab)
		var pi *int = nil
		_ = gconv.Struct(params1, pi)

		_ = gconv.Struct(params1, user)
		_ = gconv.Struct(params1, user, map[string]string{"uid": "Names"})
		_ = gconv.Struct(params1, user, map[string]string{"uid": "as"})

		// 使用struct tag映射绑定属性值到对象
		user = new(User)
		params2 := g.Map{
			"uid":       2,
			"name":      "smith",
			"site-url":  "https://goframe.org",
			"nick name": "johng",
			"password1": "111",
			"password2": "222",
		}
		if err := gconv.Struct(params2, user); err != nil {
			gtest.Error(err)
		}
		t.Assert(user, &User{
			Uid:      2,
			Name:     "smith",
			Site_Url: "https://goframe.org",
			NickName: "johng",
			Pass1:    "111",
			Pass2:    "222",
		})
	})
}

// 使用默认映射规则绑定属性值到对象
func Test_Struct_Basic2_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type User struct {
			Uid     int
			Name    string
			SiteUrl string
			Pass1   string
			Pass2   string
		}
		user := new(User)
		params := g.Map{
			"uid":      1,
			"Name":     "john",
			"site_url": "https://goframe.org",
			"PASS1":    "123",
			"PASS2":    "456",
		}
		if err := gconv.Struct(params, user); err != nil {
			gtest.Error(err)
		}
		t.Assert(user, &User{
			Uid:     1,
			Name:    "john",
			SiteUrl: "https://goframe.org",
			Pass1:   "123",
			Pass2:   "456",
		})
	})
}

// 带有指针的基础类型属性
func Test_Struct_Basic3_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type User struct {
			Uid  int
			Name *string
		}
		user := new(User)
		params := g.Map{
			"uid":  1,
			"Name": "john",
		}
		if err := gconv.Struct(params, user); err != nil {
			gtest.Error(err)
		}
		t.Assert(user.Uid, 1)
		t.Assert(*user.Name, "john")
	})
}

// slice类型属性的赋值
func Test_Struct_Attr_Slice_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type User struct {
			Scores []int
		}
		scores := []interface{}{99, 100, 60, 140}
		user := new(User)
		if err := gconv.Struct(g.Map{"Scores": scores}, user); err != nil {
			gtest.Error(err)
		} else {
			t.Assert(user, &User{
				Scores: []int{99, 100, 60, 140},
			})
		}
	})
}

// 属性为struct对象
func Test_Struct_Attr_Struct_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type Score struct {
			Name   string
			Result int
		}
		type User struct {
			Scores Score
		}

		user := new(User)
		scores := map[string]interface{}{
			"Scores": map[string]interface{}{
				"Name":   "john",
				"Result": 100,
			},
		}

		// 嵌套struct转换
		if err := gconv.Struct(scores, user); err != nil {
			gtest.Error(err)
		} else {
			t.Assert(user, &User{
				Scores: Score{
					Name:   "john",
					Result: 100,
				},
			})
		}
	})
}

// 属性为struct对象指针
func Test_Struct_Attr_Struct_Ptr_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type Score struct {
			Name   string
			Result int
		}
		type User struct {
			Scores *Score
		}

		user := new(User)
		scores := map[string]interface{}{
			"Scores": map[string]interface{}{
				"Name":   "john",
				"Result": 100,
			},
		}

		// 嵌套struct转换
		if err := gconv.Struct(scores, user); err != nil {
			gtest.Error(err)
		} else {
			t.Assert(user.Scores, &Score{
				Name:   "john",
				Result: 100,
			})
		}
	})
}

// 属性为struct对象slice
func Test_Struct_Attr_Struct_Slice1_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type Score struct {
			Name   string
			Result int
		}
		type User struct {
			Scores []Score
		}

		user := new(User)
		scores := map[string]interface{}{
			"Scores": map[string]interface{}{
				"Name":   "john",
				"Result": 100,
			},
		}

		// 嵌套struct转换，属性为slice类型，数值为map类型
		if err := gconv.Struct(scores, user); err != nil {
			gtest.Error(err)
		} else {
			t.Assert(user.Scores, []Score{
				{
					Name:   "john",
					Result: 100,
				},
			})
		}
	})
}

// 属性为struct对象slice
func Test_Struct_Attr_Struct_Slice2_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type Score struct {
			Name   string
			Result int
		}
		type User struct {
			Scores []Score
		}

		user := new(User)
		scores := map[string]interface{}{
			"Scores": []interface{}{
				map[string]interface{}{
					"Name":   "john",
					"Result": 100,
				},
				map[string]interface{}{
					"Name":   "smith",
					"Result": 60,
				},
			},
		}

		// 嵌套struct转换，属性为slice类型，数值为slice map类型
		if err := gconv.Struct(scores, user); err != nil {
			gtest.Error(err)
		} else {
			t.Assert(user.Scores, []Score{
				{
					Name:   "john",
					Result: 100,
				},
				{
					Name:   "smith",
					Result: 60,
				},
			})
		}
	})
}

// 属性为struct对象slice ptr
func Test_Struct_Attr_Struct_Slice_Ptr_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type Score struct {
			Name   string
			Result int
		}
		type User struct {
			Scores []*Score
		}

		user := new(User)
		scores := map[string]interface{}{
			"Scores": []interface{}{
				map[string]interface{}{
					"Name":   "john",
					"Result": 100,
				},
				map[string]interface{}{
					"Name":   "smith",
					"Result": 60,
				},
			},
		}

		// 嵌套struct转换，属性为slice类型，数值为slice map类型
		if err := gconv.Struct(scores, user); err != nil {
			gtest.Error(err)
		} else {
			t.Assert(len(user.Scores), 2)
			t.Assert(user.Scores[0], &Score{
				Name:   "john",
				Result: 100,
			})
			t.Assert(user.Scores[1], &Score{
				Name:   "smith",
				Result: 60,
			})
		}
	})
}

func Test_Struct_PrivateAttribute_All(t *testing.T) {
	type User struct {
		Id   int
		name string
	}
	gtest.C(t, func(t *gtest.T) {
		user := new(User)
		err := gconv.Struct(g.Map{"id": 1, "name": "john"}, user)
		t.AssertNil(err)
		t.Assert(user.Id, 1)
		t.Assert(user.name, "")
	})
}

func Test_Struct_Embedded_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type Ids struct {
			Id  int `json:"id"`
			Uid int `json:"uid"`
		}
		type Base struct {
			Ids
			CreateTime string `json:"create_time"`
		}
		type User struct {
			Base
			Passport string `json:"passport"`
			Password string `json:"password"`
			Nickname string `json:"nickname"`
		}
		data := g.Map{
			"id":          100,
			"uid":         101,
			"passport":    "t1",
			"password":    "123456",
			"nickname":    "T1",
			"create_time": "2019",
		}
		user := new(User)
		gconv.Struct(data, user)
		t.Assert(user.Id, 100)
		t.Assert(user.Uid, 101)
		t.Assert(user.Nickname, "T1")
		t.Assert(user.CreateTime, "2019")
	})
}

func Test_Struct_Time_All(t *testing.T) {
	gtest.C(t, func(t *gtest.T) {
		type User struct {
			CreateTime time.Time
		}
		now := time.Now()
		user := new(User)
		gconv.Struct(g.Map{
			"create_time": now,
		}, user)
		t.Assert(user.CreateTime.UTC().String(), now.UTC().String())
	})

	gtest.C(t, func(t *gtest.T) {
		type User struct {
			CreateTime *time.Time
		}
		now := time.Now()
		user := new(User)
		gconv.Struct(g.Map{
			"create_time": &now,
		}, user)
		t.Assert(user.CreateTime.UTC().String(), now.UTC().String())
	})

	gtest.C(t, func(t *gtest.T) {
		type User struct {
			CreateTime *gtime.Time
		}
		now := time.Now()
		user := new(User)
		gconv.Struct(g.Map{
			"create_time": &now,
		}, user)
		t.Assert(user.CreateTime.Time.UTC().String(), now.UTC().String())
	})

	gtest.C(t, func(t *gtest.T) {
		type User struct {
			CreateTime gtime.Time
		}
		now := time.Now()
		user := new(User)
		gconv.Struct(g.Map{
			"create_time": &now,
		}, user)
		t.Assert(user.CreateTime.Time.UTC().String(), now.UTC().String())
	})

	gtest.C(t, func(t *gtest.T) {
		type User struct {
			CreateTime gtime.Time
		}
		now := time.Now()
		user := new(User)
		gconv.Struct(g.Map{
			"create_time": now,
		}, user)
		t.Assert(user.CreateTime.Time.UTC().String(), now.UTC().String())
	})
}