jsonzh/json_test.go at main · yylego/jsonzh · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package jsonzh_test

import (
	"testing"

	"github.com/stretchr/testify/require"
	"github.com/yylego/jsonzh"
)

type Person struct {
	N姓名 string `json:"name"`
	A年龄 int    `json:"age"`
	E邮箱 string `json:"mailbox,omitempty"`
}

func TestM编码(t *testing.T) {
	// 测试用例1：正常结构体序列化
	t.Run("NormalStruct", func(t *testing.T) {
		input := Person{N姓名: "Alice", A年龄: 30, E邮箱: "alice@example.com"}
		expected := []byte(`{"name":"Alice","age":30,"mailbox":"alice@example.com"}`)

		data, err := jsonzh.M编码(input)
		require.NoError(t, err, "M编码 should not return error")
		require.JSONEq(t, string(expected), string(data), "M编码 output should match expected JSON")
	})

	// 测试用例2：空结构体序列化
	t.Run("EmptyStruct", func(t *testing.T) {
		input := Person{}
		expected := []byte(`{"name":"","age":0}`)

		data, err := jsonzh.M编码(input)
		require.NoError(t, err, "M编码 should not return error for empty struct")
		require.JSONEq(t, string(expected), string(data), "M编码 output should match expected JSON")
	})

	// 测试用例3：不可序列化的输入（如 channel）
	t.Run("InvalidInput", func(t *testing.T) {
		input := make(chan int)
		_, err := jsonzh.M编码(input)
		require.Error(t, err, "M编码 should return error for invalid input")
	})
}

func TestU解码(t *testing.T) {
	// 测试用例1：正常 JSON 解析
	t.Run("NormalJSON", func(t *testing.T) {
		input := []byte(`{"name":"Bob","age":25,"mailbox":"bob@example.com"}`)
		expected := Person{N姓名: "Bob", A年龄: 25, E邮箱: "bob@example.com"}

		result, err := jsonzh.U解码[Person](input)
		require.NoError(t, err, "U解码 should not return error")
		require.Equal(t, &expected, result, "U解码 output should match expected struct")
	})

	// 测试用例2：空 JSON 解析
	t.Run("EmptyJSON", func(t *testing.T) {
		input := []byte(`{}`)
		expected := Person{}

		result, err := jsonzh.U解码[Person](input)
		require.NoError(t, err, "U解码 should not return error for empty JSON")
		require.Equal(t, &expected, result, "U解码 output should match expected struct")
	})

	// 测试用例3：无效 JSON
	t.Run("InvalidJSON", func(t *testing.T) {
		input := []byte(`{invalid json}`)
		_, err := jsonzh.U解码[Person](input)
		require.Error(t, err, "U解码 should return error for invalid JSON")
	})
}

func TestM编码s(t *testing.T) {
	// 测试用例1：正常结构体序列化为字符串
	t.Run("NormalStruct", func(t *testing.T) {
		input := Person{N姓名: "Charlie", A年龄: 40}
		expected := `{"name":"Charlie","age":40}`

		data, err := jsonzh.M编码s(input)
		require.NoError(t, err, "M编码s should not return error")
		require.JSONEq(t, expected, data, "M编码s output should match expected JSON string")
	})

	// 测试用例2：空结构体序列化
	t.Run("EmptyStruct", func(t *testing.T) {
		input := Person{}
		expected := `{"name":"","age":0}`

		data, err := jsonzh.M编码s(input)
		require.NoError(t, err, "M编码s should not return error for empty struct")
		require.JSONEq(t, expected, data, "M编码s output should match expected JSON string")
	})

	// 测试用例3：不可序列化的输入
	t.Run("InvalidInput", func(t *testing.T) {
		input := make(chan int)
		_, err := jsonzh.M编码s(input)
		require.Error(t, err, "M编码s should return error for invalid input")
	})
}

func TestU解码s(t *testing.T) {
	// 测试用例1：正常 JSON 字符串解析
	t.Run("NormalJSON", func(t *testing.T) {
		input := `{"name":"Dave","age":35,"mailbox":"dave@example.com"}`
		expected := Person{N姓名: "Dave", A年龄: 35, E邮箱: "dave@example.com"}

		result, err := jsonzh.U解码s[Person](input)
		require.NoError(t, err, "U解码s should not return error")
		require.Equal(t, &expected, result, "U解码s output should match expected struct")
	})

	// 测试用例2：空 JSON 字符串解析
	t.Run("EmptyJSON", func(t *testing.T) {
		input := `{}`
		expected := Person{}

		result, err := jsonzh.U解码s[Person](input)
		require.NoError(t, err, "U解码s should not return error for empty JSON")
		require.Equal(t, &expected, result, "U解码s output should match expected struct")
	})

	// 测试用例3：无效 JSON 字符串
	t.Run("InvalidJSON", func(t *testing.T) {
		input := `{invalid json}`
		_, err := jsonzh.U解码s[Person](input)
		require.Error(t, err, "U解码s should return error for invalid JSON")
	})

	// 测试用例4：空字符串
	t.Run("EmptyString", func(t *testing.T) {
		input := ""
		_, err := jsonzh.U解码s[Person](input)
		require.Error(t, err, "U解码s should return error for empty string")
	})
}