添加assign tag的测试

test/assign_tag_test.go

@@ -0,0 +1,500 @@
+package test
+
+import (
+	"git.sxidc.com/go-framework/baize/framework/core/tag/assign"
+	"git.sxidc.com/go-tools/utils/strutils"
+	"math/rand"
+	"strings"
+	"testing"
+	"time"
+)
+
+type AssignFrom struct {
+	StringField                  string              `assign:"toField:StringField"`
+	BoolField                    bool                `assign:"toField:BoolField"`
+	Int8Field                    int8                `assign:"toField:Int8Field"`
+	Int16Field                   int16               `assign:"toField:Int16Field"`
+	Int32Field                   int32               `assign:"toField:Int32Field"`
+	Int64Field                   int64               `assign:"toField:Int64Field"`
+	Uint8Field                   uint8               `assign:"toField:Uint8Field"`
+	Uint16Field                  uint16              `assign:"toField:Uint16Field"`
+	Uint32Field                  uint32              `assign:"toField:Uint32Field"`
+	Uint64Field                  uint64              `assign:"toField:Uint64Field"`
+	Float32Field                 float32             `assign:"toField:Float32Field"`
+	Float64Field                 float64             `assign:"toField:Float64Field"`
+	SliceField                   []string            `assign:"toField:SliceField"`
+	MapField                     map[string]string   `assign:"toField:MapField"`
+	ChanField                    chan any            `assign:"toField:ChanField"`
+	FuncField                    func() string       `assign:"toField:FuncField"`
+	StructField                  struct{ ID string } `assign:"toField:StructField"`
+	FromStringSliceToStringField []string            `assign:"toField:FromStringSliceToStringField"`
+	FromTimeToStringField        time.Time           `assign:"toField:FromTimeToStringField"`
+	FromTimeToTimeField          time.Time           `assign:"toField:FromTimeToTimeField"`
+	FromStringToTimeField        string              `assign:"toField:FromStringToTimeField"`
+}
+
+type AssignFromPointerField struct {
+	StringField                  *string              `assign:"toField:StringField"`
+	BoolField                    *bool                `assign:"toField:BoolField"`
+	Int8Field                    *int8                `assign:"toField:Int8Field"`
+	Int16Field                   *int16               `assign:"toField:Int16Field"`
+	Int32Field                   *int32               `assign:"toField:Int32Field"`
+	Int64Field                   *int64               `assign:"toField:Int64Field"`
+	Uint8Field                   *uint8               `assign:"toField:Uint8Field"`
+	Uint16Field                  *uint16              `assign:"toField:Uint16Field"`
+	Uint32Field                  *uint32              `assign:"toField:Uint32Field"`
+	Uint64Field                  *uint64              `assign:"toField:Uint64Field"`
+	Float32Field                 *float32             `assign:"toField:Float32Field"`
+	Float64Field                 *float64             `assign:"toField:Float64Field"`
+	SliceField                   *[]string            `assign:"toField:SliceField"`
+	MapField                     *map[string]string   `assign:"toField:MapField"`
+	ChanField                    *chan any            `assign:"toField:ChanField"`
+	FuncField                    *func() string       `assign:"toField:FuncField"`
+	StructField                  *struct{ ID string } `assign:"toField:StructField"`
+	FromStringSliceToStringField *[]string            `assign:"toField:FromStringSliceToStringField"`
+	FromTimeToStringField        *time.Time           `assign:"toField:FromTimeToStringField"`
+	FromTimeToTimeField          *time.Time           `assign:"toField:FromTimeToTimeField"`
+	FromStringToTimeField        *string              `assign:"toField:FromStringToTimeField"`
+}
+
+type AssignTo struct {
+	StringField                  string
+	BoolField                    bool
+	Int8Field                    int8
+	Int16Field                   int16
+	Int32Field                   int32
+	Int64Field                   int64
+	Uint8Field                   uint8
+	Uint16Field                  uint16
+	Uint32Field                  uint32
+	Uint64Field                  uint64
+	Float32Field                 float32
+	Float64Field                 float64
+	SliceField                   []string
+	MapField                     map[string]string
+	ChanField                    chan any
+	FuncField                    func() string
+	StructField                  struct{ ID string }
+	FromStringSliceToStringField string
+	FromTimeToStringField        string
+	FromTimeToTimeField          time.Time
+	FromStringToTimeField        time.Time
+}
+
+func (to AssignTo) checkFields(t *testing.T, from AssignFrom) {
+	if from.StringField != to.StringField {
+		t.Fatalf("StringField not equal: from %v, to %v",
+			from.StringField, to.StringField)
+	}
+
+	if from.BoolField != to.BoolField {
+		t.Fatalf("BoolField not equal: from %v, to %v",
+			from.BoolField, to.BoolField)
+	}
+
+	if from.Int8Field != to.Int8Field {
+		t.Fatalf("Int8Field not equal: from %v, to %v",
+			from.Int8Field, to.Int8Field)
+	}
+
+	if from.Int16Field != to.Int16Field {
+		t.Fatalf("Int16Field not equal: from %v, to %v",
+			from.Int16Field, to.Int16Field)
+	}
+
+	if from.Int32Field != to.Int32Field {
+		t.Fatalf("Int32Field not equal: from %v, to %v",
+			from.Int32Field, to.Int32Field)
+	}
+
+	if from.Int64Field != to.Int64Field {
+		t.Fatalf("Int64Field not equal: from %v, to %v",
+			from.Int64Field, to.Int64Field)
+	}
+
+	if from.Uint8Field != to.Uint8Field {
+		t.Fatalf("Uint8Field not equal: from %v, to %v",
+			from.Uint8Field, to.Uint8Field)
+	}
+
+	if from.Uint16Field != to.Uint16Field {
+		t.Fatalf("Uint16Field not equal: from %v, to %v",
+			from.Uint16Field, to.Uint16Field)
+	}
+
+	if from.Uint32Field != to.Uint32Field {
+		t.Fatalf("Uint32Field not equal: from %v, to %v",
+			from.Uint32Field, to.Uint32Field)
+	}
+
+	if from.Uint64Field != to.Uint64Field {
+		t.Fatalf("Uint64Field not equal: from %v, to %v",
+			from.Uint64Field, to.Uint64Field)
+	}
+
+	if from.Float32Field != to.Float32Field {
+		t.Fatalf("Float32Field not equal: from %v, to %v",
+			from.Float32Field, to.Float32Field)
+	}
+
+	if from.Float64Field != to.Float64Field {
+		t.Fatalf("Float64Field not equal: from %v, to %v",
+			from.Float64Field, to.Float64Field)
+	}
+
+	for i, value := range from.SliceField {
+		if value != to.SliceField[i] {
+			t.Fatalf("SliceField not equal: from %v, to %v",
+				value, to.SliceField[i])
+		}
+	}
+
+	for key, value := range from.MapField {
+		if value != to.MapField[key] {
+			t.Fatalf("MapField not equal: from %v, to %v",
+				value, to.MapField[key])
+		}
+	}
+
+	if from.ChanField != to.ChanField {
+		t.Fatalf("ChanField not equal: from %v, to %v",
+			from.ChanField, to.ChanField)
+	}
+
+	if from.FuncField() != to.FuncField() {
+		t.Fatalf("FuncField not equal: from %v, to %v",
+			from.FuncField(), to.FuncField())
+	}
+
+	if from.StructField.ID != to.StructField.ID {
+		t.Fatalf("StructField not equal: from %v, to %v",
+			from.StructField.ID, to.StructField.ID)
+	}
+
+	if strings.Join(from.FromStringSliceToStringField, "::") != to.FromStringSliceToStringField {
+		t.Fatalf("FromStringSliceToStringField not equal: from %v, to %v",
+			strings.Join(from.FromStringSliceToStringField, "::"), to.FromStringSliceToStringField)
+	}
+
+	if from.FromTimeToStringField.Format(time.DateTime) != to.FromTimeToStringField {
+		t.Fatalf("FromTimeToStringField not equal: from %v, to %v",
+			from.FromTimeToStringField.Format(time.DateTime), to.FromTimeToStringField)
+	}
+
+	if from.FromTimeToTimeField.Format(time.DateTime) != to.FromTimeToTimeField.Format(time.DateTime) {
+		t.Fatalf("FromTimeToTimeField not equal: from %v, to %v",
+			from.FromTimeToTimeField.Format(time.DateTime), to.FromTimeToTimeField.Format(time.DateTime))
+	}
+
+	if from.FromStringToTimeField != to.FromStringToTimeField.Format(time.DateTime) {
+		t.Fatalf("FromStringToTimeField not equal: from %v, to %v",
+			from.FromStringToTimeField, to.FromStringToTimeField.Format(time.DateTime))
+	}
+}
+
+type AssignToPointerField struct {
+	StringField                  *string
+	BoolField                    *bool
+	Int8Field                    *int8
+	Int16Field                   *int16
+	Int32Field                   *int32
+	Int64Field                   *int64
+	Uint8Field                   *uint8
+	Uint16Field                  *uint16
+	Uint32Field                  *uint32
+	Uint64Field                  *uint64
+	Float32Field                 *float32
+	Float64Field                 *float64
+	SliceField                   *[]string
+	MapField                     *map[string]string
+	ChanField                    *chan any
+	FuncField                    *func() string
+	StructField                  *struct{ ID string }
+	FromStringSliceToStringField *string
+	FromTimeToStringField        *string
+	FromTimeToTimeField          *time.Time
+	FromStringToTimeField        *time.Time
+}
+
+func (to AssignToPointerField) checkFields(t *testing.T, from AssignFrom) {
+	if from.StringField != *to.StringField {
+		t.Fatalf("StringField not equal: from %v, to %v",
+			from.StringField, *to.StringField)
+	}
+
+	if from.BoolField != *to.BoolField {
+		t.Fatalf("BoolField not equal: from %v, to %v",
+			from.BoolField, *to.BoolField)
+	}
+
+	if from.Int8Field != *to.Int8Field {
+		t.Fatalf("Int8Field not equal: from %v, to %v",
+			from.Int8Field, *to.Int8Field)
+	}
+
+	if from.Int16Field != *to.Int16Field {
+		t.Fatalf("Int16Field not equal: from %v, to %v",
+			from.Int16Field, *to.Int16Field)
+	}
+
+	if from.Int32Field != *to.Int32Field {
+		t.Fatalf("Int32Field not equal: from %v, to %v",
+			from.Int32Field, *to.Int32Field)
+	}
+
+	if from.Int64Field != *to.Int64Field {
+		t.Fatalf("Int64Field not equal: from %v, to %v",
+			from.Int64Field, *to.Int64Field)
+	}
+
+	if from.Uint8Field != *to.Uint8Field {
+		t.Fatalf("Uint8Field not equal: from %v, to %v",
+			from.Uint8Field, *to.Uint8Field)
+	}
+
+	if from.Uint16Field != *to.Uint16Field {
+		t.Fatalf("Uint16Field not equal: from %v, to %v",
+			from.Uint16Field, *to.Uint16Field)
+	}
+
+	if from.Uint32Field != *to.Uint32Field {
+		t.Fatalf("Uint32Field not equal: from %v, to %v",
+			from.Uint32Field, *to.Uint32Field)
+	}
+
+	if from.Uint64Field != *to.Uint64Field {
+		t.Fatalf("Uint64Field not equal: from %v, to %v",
+			from.Uint64Field, *to.Uint64Field)
+	}
+
+	if from.Float32Field != *to.Float32Field {
+		t.Fatalf("Float32Field not equal: from %v, to %v",
+			from.Float32Field, *to.Float32Field)
+	}
+
+	if from.Float64Field != *to.Float64Field {
+		t.Fatalf("Float64Field not equal: from %v, to %v",
+			from.Float64Field, *to.Float64Field)
+	}
+
+	for i, value := range from.SliceField {
+		if value != (*to.SliceField)[i] {
+			t.Fatalf("SliceField not equal: from %v, to %v",
+				value, (*to.SliceField)[i])
+		}
+	}
+
+	for key, value := range from.MapField {
+		if value != (*to.MapField)[key] {
+			t.Fatalf("MapField not equal: from %v, to %v",
+				value, (*to.MapField)[key])
+		}
+	}
+
+	if from.ChanField != *to.ChanField {
+		t.Fatalf("ChanField not equal: from %v, to %v",
+			from.ChanField, *to.ChanField)
+	}
+
+	if from.FuncField() != (*to.FuncField)() {
+		t.Fatalf("FuncField not equal: from %v, to %v",
+			from.FuncField(), (*to.FuncField)())
+	}
+
+	if from.StructField.ID != (*to.StructField).ID {
+		t.Fatalf("StructField not equal: from %v, to %v",
+			from.StructField.ID, (*to.StructField).ID)
+	}
+
+	if strings.Join(from.FromStringSliceToStringField, "::") != *to.FromStringSliceToStringField {
+		t.Fatalf("FromStringSliceToStringField not equal: from %v, to %v",
+			strings.Join(from.FromStringSliceToStringField, "::"), to.FromStringSliceToStringField)
+	}
+
+	if from.FromTimeToStringField.Format(time.DateTime) != *to.FromTimeToStringField {
+		t.Fatalf("FromTimeToStringField not equal: from %v, to %v",
+			from.FromTimeToStringField.Format(time.DateTime), to.FromTimeToStringField)
+	}
+
+	if from.FromTimeToTimeField.Format(time.DateTime) != (*to.FromTimeToTimeField).Format(time.DateTime) {
+		t.Fatalf("FromTimeToTimeField not equal: from %v, to %v",
+			from.FromTimeToTimeField.Format(time.DateTime), (*to.FromTimeToTimeField).Format(time.DateTime))
+	}
+
+	if from.FromStringToTimeField != (*to.FromStringToTimeField).Format(time.DateTime) {
+		t.Fatalf("FromStringToTimeField not equal: from %v, to %v",
+			from.FromStringToTimeField, (*to.FromStringToTimeField).Format(time.DateTime))
+	}
+}
+
+func TestDefaultUsage(t *testing.T) {
+	stringField := strutils.SimpleUUID()
+	boolField := rand.Intn(2) == 0
+	int8Field := int8(rand.Int())
+	int16Field := int16(rand.Int())
+	int32Field := int32(rand.Int())
+	int64Field := int64(rand.Int())
+	uint8Field := uint8(rand.Int())
+	uint16Field := uint16(rand.Int())
+	uint32Field := uint32(rand.Int())
+	uint64Field := uint64(rand.Int())
+	float32Field := rand.Float32()
+	float64Field := rand.Float64()
+	sliceField := []string{strutils.SimpleUUID(), strutils.SimpleUUID()}
+	mapField := map[string]string{strutils.SimpleUUID(): strutils.SimpleUUID()}
+	chanField := make(chan any)
+	returnValue := strutils.SimpleUUID()
+	funcField := func() string { return returnValue }
+	structField := struct{ ID string }{ID: strutils.SimpleUUID()}
+	fromStringSliceToStringField := []string{strutils.SimpleUUID(), strutils.SimpleUUID()}
+	fromTimeToStringField := time.Now().Local()
+	fromTimeToTimeField := time.Now().Local()
+	fromStringToTimeField := time.Now().Local().Format(time.DateTime)
+
+	from := AssignFrom{
+		StringField:                  stringField,
+		BoolField:                    boolField,
+		Int8Field:                    int8Field,
+		Int16Field:                   int16Field,
+		Int32Field:                   int32Field,
+		Int64Field:                   int64Field,
+		Uint8Field:                   uint8Field,
+		Uint16Field:                  uint16Field,
+		Uint32Field:                  uint32Field,
+		Uint64Field:                  uint64Field,
+		Float32Field:                 float32Field,
+		Float64Field:                 float64Field,
+		SliceField:                   sliceField,
+		MapField:                     mapField,
+		ChanField:                    chanField,
+		FuncField:                    funcField,
+		StructField:                  structField,
+		FromStringSliceToStringField: fromStringSliceToStringField,
+		FromTimeToStringField:        fromTimeToStringField,
+		FromTimeToTimeField:          fromTimeToTimeField,
+		FromStringToTimeField:        fromStringToTimeField,
+	}
+
+	fromPointer := AssignFromPointerField{
+		StringField:                  &stringField,
+		BoolField:                    &boolField,
+		Int8Field:                    &int8Field,
+		Int16Field:                   &int16Field,
+		Int32Field:                   &int32Field,
+		Int64Field:                   &int64Field,
+		Uint8Field:                   &uint8Field,
+		Uint16Field:                  &uint16Field,
+		Uint32Field:                  &uint32Field,
+		Uint64Field:                  &uint64Field,
+		Float32Field:                 &float32Field,
+		Float64Field:                 &float64Field,
+		SliceField:                   &sliceField,
+		MapField:                     &mapField,
+		ChanField:                    &chanField,
+		FuncField:                    &funcField,
+		StructField:                  &structField,
+		FromStringSliceToStringField: &fromStringSliceToStringField,
+		FromTimeToStringField:        &fromTimeToStringField,
+		FromTimeToTimeField:          &fromTimeToTimeField,
+		FromStringToTimeField:        &fromStringToTimeField,
+	}
+
+	to := AssignTo{}
+	toPointer := AssignToPointerField{}
+
+	err := assign.DefaultUsage(from, to)
+	if err == nil || err.Error() != "返回类型不是结构指针" {
+		t.Fatal("to参数必须是指针类型")
+	}
+
+	err = assign.DefaultUsage(from, toPointer)
+	if err == nil || err.Error() != "返回类型不是结构指针" {
+		t.Fatal("to参数必须是指针类型")
+	}
+
+	err = assign.DefaultUsage(fromPointer, to)
+	if err == nil || err.Error() != "返回类型不是结构指针" {
+		t.Fatal("to参数必须是指针类型")
+	}
+
+	err = assign.DefaultUsage(fromPointer, toPointer)
+	if err == nil || err.Error() != "返回类型不是结构指针" {
+		t.Fatal("to参数必须是指针类型")
+	}
+
+	err = assign.DefaultUsage(from, &to)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	to.checkFields(t, from)
+
+	err = assign.DefaultUsage(from, &toPointer)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	toPointer.checkFields(t, from)
+
+	err = assign.DefaultUsage(fromPointer, &to)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	to.checkFields(t, from)
+
+	err = assign.DefaultUsage(fromPointer, &toPointer)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	toPointer.checkFields(t, from)
+
+	err = assign.DefaultUsage(&from, to)
+	if err == nil || err.Error() != "返回类型不是结构指针" {
+		t.Fatal("to参数必须是指针类型")
+	}
+
+	err = assign.DefaultUsage(&from, toPointer)
+	if err == nil || err.Error() != "返回类型不是结构指针" {
+		t.Fatal("to参数必须是指针类型")
+	}
+
+	err = assign.DefaultUsage(&fromPointer, to)
+	if err == nil || err.Error() != "返回类型不是结构指针" {
+		t.Fatal("to参数必须是指针类型")
+	}
+
+	err = assign.DefaultUsage(&fromPointer, toPointer)
+	if err == nil || err.Error() != "返回类型不是结构指针" {
+		t.Fatal("to参数必须是指针类型")
+	}
+
+	err = assign.DefaultUsage(&from, &to)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	to.checkFields(t, from)
+
+	err = assign.DefaultUsage(&from, &toPointer)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	toPointer.checkFields(t, from)
+
+	err = assign.DefaultUsage(&fromPointer, &to)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	to.checkFields(t, from)
+
+	err = assign.DefaultUsage(&fromPointer, &toPointer)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	toPointer.checkFields(t, from)
+}