gitee.com/zhongguo168a/gocodes@v0.0.0-20230609140523-e1828349603f/datax/jsonmap/jsonmap_test.go

package jsonmap

import (
	"fmt"
	"gitee.com/zhongguo168a/gocodes/datax"
	"gitee.com/zhongguo168a/gocodes/datax/mapx"
	"github.com/jinzhu/copier"
	"github.com/stretchr/testify/assert"
	"testing"
	"unsafe"
)

type Enum1 int

const (
	Enum1_A Enum1 = iota
	Enum1_B
	Enum1_C
)

type Enum2 string

const (
	Enum2_A Enum2 = "A"
	Enum2_B Enum2 = "B"
	Enum2_C Enum2 = "C"
)

type Class1 struct {
	*ClassParent

	Enum       Enum1
	EnumString Enum2
	Int8       int8
	Class2     *Class2
	Map        map[string]interface{}
	MapEnum    map[Enum1]interface{}
	ArrayAny   []interface{}
	ArrayBasic []string
	ArrayClass []*Class2
	Any        interface{}
}

type Class2 struct {
	String string
	Int    int
}

type ClassParent struct {
	ParentInt8 int8
}

func TestStructToMap2(t *testing.T) {
	m := map[string]interface{}{
		"b": 2,
	}
	copier.Copy(&m, map[string]interface{}{
		"a": 1,
	})

	fmt.Println("m", m)
}

func TestJustifyByStruct(t *testing.T) {
	m := datax.M{
		"Enum": 2,
		"Int8": 9,
		"Class2": datax.M{
			"String": "modify",
		},
		"Map": datax.M{
			"a": 2,
			"b": "b",
		},
		"MapEnum": datax.M{
			"1": 2,
			"2": 4,
		},
		"ArrayAny":   []interface{}{"2", "3", 4},
		"ArrayBasic": []interface{}{"5"},
		"ArrayClass": []interface{}{datax.M{
			"String": "ArrayClass2",
		}},
	}
	JustifyByStruct(m, &Class1{})
}

func TestStructToMap(t *testing.T) {
	c1 := &Class1{
		Enum:       Enum1_B,
		EnumString: Enum2_B,
		Int8:       8,
		Class2: &Class2{
			String: "Class2",
		},
		Map: map[string]interface{}{
			"a": 1,
		},
		MapEnum: map[Enum1]interface{}{
			Enum1_B: 1,
		},
		ArrayAny:   []interface{}{"1", "2", 3, datax.M{"1": 1}},
		ArrayBasic: []string{"1", "2"},
		ArrayClass: []*Class2{
			{String: "ArrayClass"},
		},
	}

	c1map := map[string]interface{}{}
	err := StructToMap(c1, c1map)
	assert.Equal(t, nil, err)
	assert.Equal(t, 1, mapx.Int(c1map, "Enum"))
	assert.Equal(t, 8, mapx.Int(c1map, "Int8"))
	assert.Equal(t, "Class2", mapx.Map(c1map, "Class2")["String"])
	assert.Equal(t, 1, mapx.Map(c1map, "Map")["a"])
	assert.Equal(t, 1, mapx.Map(c1map, "MapEnum")["1"])
	assert.Equal(t, []interface{}{"1", "2", 3, datax.M{"1": 1}}, mapx.Array(c1map, "ArrayAny"))
	assert.Equal(t, []interface{}{"1", "2"}, mapx.Array(c1map, "ArrayBasic"))
	assert.Equal(t, map[string]interface{}{"Int": float64(0), "String": "ArrayClass"}, mapx.Array(c1map, "ArrayClass")[0])
}

func TestMapToStruct(t *testing.T) {
	c1 := &Class1{
		Enum:       Enum1_B,
		EnumString: Enum2_B,
		Int8:       8,
		Class2: &Class2{
			String: "Class2",
		},
		Map: map[string]interface{}{
			"a": 1,
		},
		MapEnum: map[Enum1]interface{}{
			Enum1_B: 1,
		},
		ArrayAny:   []interface{}{"1", "2", 3},
		ArrayBasic: []string{"1", "2"},
		ArrayClass: []*Class2{
			{String: "ArrayClass"},
		},
	}

	err := MapToStruct(map[string]interface{}{
		"Enum": "2",
	}, c1)
	assert.Equal(t, true, err != nil)

	err = MapToStruct(datax.M{
		"Enum":       2,
		"EnumString": "C",
		"Int8":       9,
		"Class2": datax.M{
			"String": "modify",
		},
		"Map": datax.M{
			"a": 2,
			"b": "b",
		},
		"MapEnum": datax.M{
			"1": 2,
			"2": 4,
		},
		"ArrayAny":   []interface{}{"2", "3", 4},
		"ArrayBasic": []interface{}{"5"},
		"ArrayClass": []interface{}{datax.M{
			"String": "ArrayClass2",
		}},
		"Any": map[string]interface{}{"a": 1},
	}, c1)
	assert.Equal(t, Enum1_C, c1.Enum)
	assert.Equal(t, Enum2_C, c1.EnumString)
	assert.Equal(t, int8(9), c1.Int8)
	assert.Equal(t, "modify", c1.Class2.String)
	assert.Equal(t, 2, c1.Map["a"])
	assert.Equal(t, "b", c1.Map["b"])
	assert.Equal(t, 2, c1.MapEnum[Enum1_B])
	assert.Equal(t, 4, c1.MapEnum[Enum1_C])
	assert.Equal(t, []interface{}{"2", "3", 4}, c1.ArrayAny)
	assert.Equal(t, []string{"5"}, c1.ArrayBasic)
	assert.Equal(t, "ArrayClass2", c1.ArrayClass[0].String)
	assert.Equal(t, map[string]interface{}{"a": 1}, c1.Any)
}

type People struct {
	Age   int
	Name  string
	Test1 string
	Test2 string
}

type emptyInterface struct {
	typ  *struct{}
	word unsafe.Pointer
}

func TestStruct(t *testing.T) {
	var in interface{} = map[string]interface{}{
		"a": 1,
	}

	t2 := uintptr(((*emptyInterface)(unsafe.Pointer(&in))).word)
	*(*int)(unsafe.Pointer(t2)) = 111
	fmt.Println(in)
}

func TestAnyToAny(t *testing.T) {

}