github.com/zly-app/zapp@v1.3.3/pkg/serializer/base_test.go (about)

     1  package serializer
     2  
     3  import (
     4  	"bytes"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  type Temp struct {
    12  	A string `json:"AA"`
    13  }
    14  
    15  func TestBaseMarshal(t *testing.T) {
    16  	serializer := GetSerializer(BaseSerializerName)
    17  
    18  	marshalArgs := []struct {
    19  		A      interface{}
    20  		Expect string
    21  	}{
    22  		{"hello", "hello"},
    23  		{1, "1"},
    24  		{true, "true"},
    25  		{float64(1.2), "1.2"},
    26  		{[]byte("hello"), "hello"},
    27  		{Temp{"xx"}, `{"AA":"xx"}`},
    28  	}
    29  	for i := range marshalArgs {
    30  		var buf bytes.Buffer
    31  		err := serializer.Marshal(marshalArgs[i].A, &buf)
    32  		assert.Nil(t, err)
    33  		assert.Equal(t, marshalArgs[i].Expect, buf.String())
    34  	}
    35  	for i := range marshalArgs {
    36  		bs, err := serializer.MarshalBytes(marshalArgs[i].A)
    37  		assert.Nil(t, err)
    38  		assert.Equal(t, marshalArgs[i].Expect, string(bs))
    39  	}
    40  }
    41  
    42  func TestBaseUnmarshal(t *testing.T) {
    43  	serializer := GetSerializer(BaseSerializerName)
    44  
    45  	type Args struct {
    46  		Data   string
    47  		A      interface{}
    48  		Expect interface{}
    49  	}
    50  	unmarshalArgs := []func() Args{
    51  		func() Args {
    52  			var a string
    53  			expect := "hello"
    54  			return Args{"hello", &a, &expect}
    55  		},
    56  		func() Args {
    57  			var a int
    58  			expect := 1
    59  			return Args{"1", &a, &expect}
    60  		},
    61  		func() Args {
    62  			var a bool
    63  			expect := true
    64  			return Args{"1", &a, &expect}
    65  		},
    66  		func() Args {
    67  			var a float64
    68  			expect := float64(1.2)
    69  			return Args{"1.2", &a, &expect}
    70  		},
    71  		func() Args {
    72  			var a []byte
    73  			expect := []byte("hello")
    74  			return Args{"hello", &a, &expect}
    75  		},
    76  		func() Args {
    77  			var a Temp
    78  			expect := Temp{"xx"}
    79  			return Args{`{"AA":"xx"}`, &a, &expect}
    80  		},
    81  	}
    82  	for i := range unmarshalArgs {
    83  		args := unmarshalArgs[i]()
    84  		err := serializer.Unmarshal(strings.NewReader(args.Data), args.A)
    85  		assert.Nil(t, err)
    86  		assert.Equal(t, args.Expect, args.A)
    87  	}
    88  }