v

1
import x.json2 as json
2
import strings
3
import time
4

5
struct StructType[T] {
6
mut:
7
	val T
8
}
9

10
fn test_json_string_characters() {
11
	assert json.encode([u8(`/`)].bytestr()).bytes() == r'"\/"'.bytes()
12
	assert json.encode([u8(`\\`)].bytestr()).bytes() == r'"\\"'.bytes()
13
	assert json.encode([u8(`"`)].bytestr()).bytes() == r'"\""'.bytes()
14
	assert json.encode([u8(`\n`)].bytestr()).bytes() == r'"\n"'.bytes()
15
	assert json.encode(r'\n\r') == r'"\\n\\r"'
16
	assert json.encode('\\n') == r'"\\n"'
17
	assert json.encode(r'\n\r\b') == r'"\\n\\r\\b"'
18
	assert json.encode(r'\"/').bytes() == r'"\\\"\/"'.bytes()
19

20
	assert json.encode(r'\n\r\b\f\t\\\"\/') == r'"\\n\\r\\b\\f\\t\\\\\\\"\\\/"'
21

22
	text := json.raw_decode(r'"\n\r\b\f\t\\\"\/"') or { '' }
23
	assert text.json_str() == '"\\n\\r\\b\\f\\t\\\\\\"\\/"'
24

25
	assert json.encode("fn main(){nprintln('Hello World! Helo \$a')\n}") == '"fn main(){nprintln(\'Hello World! Helo \$a\')\\n}"'
26
	assert json.encode(' And when "\'s are in the string, along with # "') == '" And when \\"\'s are in the string, along with # \\""'
27
	assert json.encode('a \\\nb') == r'"a \\\nb"'
28
	assert json.encode('Name\tJosé\nLocation\tSF.') == '"Name\\tJosé\\nLocation\\tSF."'
29
}
30

31
fn test_json_escape_low_chars() {
32
	esc := '\u001b'
33
	assert esc.len == 1
34
	text := json.Any(esc)
35
	assert text.json_str() == r'"\u001b"'
36

37
	assert json.encode('\u000f') == r'"\u000f"'
38
	assert json.encode('\u0020') == r'" "'
39
	assert json.encode('\u0000') == r'"\u0000"'
40
}
41

42
fn test_json_string() {
43
	text := json.Any('te✔st')
44

45
	assert text.json_str() == r'"te\u2714st"'
46
	assert json.encode('te✔st') == r'"te\u2714st"'
47

48
	boolean := json.Any(true)
49
	assert boolean.json_str() == 'true'
50
	integer := json.Any(int(-5))
51
	assert integer.json_str() == '-5'
52
	u64integer := json.Any(u64(5000))
53
	assert u64integer.json_str() == '5000'
54
	i64integer := json.Any(i64(-17))
55
	assert i64integer.json_str() == '-17'
56
}
57

58
fn test_json_string_emoji() {
59
	text := json.Any('🐈')
60
	assert text.json_str() == r'"🐈"'
61
	assert json.Any('💀').json_str() == r'"💀"'
62

63
	assert json.encode('🐈') == r'"🐈"'
64
	assert json.encode('💀') == r'"💀"'
65
	// assert json.encode('🐈💀') == r'"🐈💀"'
66
}
67

68
fn test_json_string_non_ascii() {
69
	text := json.Any('ひらがな')
70
	assert text.json_str() == r'"\u3072\u3089\u304c\u306a"'
71

72
	assert json.encode('ひらがな') == r'"\u3072\u3089\u304c\u306a"'
73
}
74

75
fn test_utf8_strings_are_not_modified() {
76
	original := '{"s":"Schilddrüsenerkrankungen"}'
77
	deresult := json.raw_decode(original)!
78
	assert deresult.str() == original
79

80
	assert json.encode('ü') == '"ü"'
81
	assert json.encode('Schilddrüsenerkrankungen') == '"Schilddrüsenerkrankungen"'
82
}
83

84
fn test_encoder_unescaped_utf32() ! {
85
	jap_text := json.Any('ひらがな')
86
	enc := json.Encoder{
87
		escape_unicode: false
88
	}
89

90
	mut sb := strings.new_builder(20)
91
	defer {
92
		unsafe { sb.free() }
93
	}
94

95
	enc.encode_value(jap_text, mut sb)!
96

97
	assert sb.str() == '"${jap_text}"'
98
	sb.go_back_to(0)
99

100
	emoji_text := json.Any('🐈')
101
	enc.encode_value(emoji_text, mut sb)!
102
	assert sb.str() == '"${emoji_text}"'
103

104
	mut buf := []u8{cap: 14}
105

106
	enc.encode_value('ひらがな', mut buf)!
107

108
	assert buf.len == 14
109
	assert buf.bytestr() == '"ひらがな"'
110
}
111

112
fn test_encoder_prettify() {
113
	obj := {
114
		'hello': json.Any('world')
115
		'arr':   [json.Any('im a string'), [json.Any('3rd level')]]
116
		'obj':   {
117
			'map': json.Any('map inside a map')
118
		}
119
	}
120
	enc := json.Encoder{
121
		newline:              `\n`
122
		newline_spaces_count: 2
123
	}
124
	mut sb := strings.new_builder(20)
125
	defer {
126
		unsafe { sb.free() }
127
	}
128
	enc.encode_value(obj, mut sb)!
129
	assert sb.str() == '{
130
  "hello": "world",
131
  "arr": [
132
    "im a string",
133
    [
134
      "3rd level"
135
    ]
136
  ],
137
  "obj": {
138
    "map": "map inside a map"
139
  }
140
}'
141
}
142

143
pub struct Test {
144
	val string
145
}
146

147
fn test_encode_struct() {
148
	enc := json.encode(Test{'hello!'})
149
	assert enc == '{"val":"hello!"}'
150
}
151

152
pub struct Uri {
153
	protocol string
154
	path     string
155
}
156

157
pub fn (u Uri) json_str() string {
158
	return '"${u.protocol}://${u.path}"'
159
}
160

161
fn test_encode_encodable() {
162
	assert json.encode(Uri{'file', 'path/to/file'}) == '"file://path/to/file"'
163
}
164

165
fn test_encode_array() {
166
	array_of_struct := [StructType[[]bool]{
167
		val: [false, true]
168
	}, StructType[[]bool]{
169
		val: [true, false]
170
	}]
171

172
	assert json.encode([1, 2, 3]) == '[1,2,3]'
173

174
	assert json.encode(array_of_struct) == '[{"val":[false,true]},{"val":[true,false]}]'
175
}
176

177
fn test_encode_simple() {
178
	assert json.encode('hello!') == '"hello!"'
179
	assert json.encode(1) == '1'
180
}
181

182
fn test_encode_value() {
183
	json_enc := json.Encoder{
184
		newline:              `\n`
185
		newline_spaces_count: 2
186
		escape_unicode:       false
187
	}
188

189
	mut manifest := map[string]json.Any{}
190

191
	manifest['server_path'] = json.Any('new_path')
192
	manifest['last_updated'] = json.Any('timestamp.format_ss()')
193
	manifest['from_source'] = json.Any('from_source')
194

195
	mut sb := strings.new_builder(64)
196
	mut buffer := []u8{}
197
	json_enc.encode_value(manifest, mut buffer)!
198

199
	assert buffer.len > 0
200
	assert buffer == [u8(123), 10, 32, 32, 34, 115, 101, 114, 118, 101, 114, 95, 112, 97, 116,
201
		104, 34, 58, 32, 34, 110, 101, 119, 95, 112, 97, 116, 104, 34, 44, 10, 32, 32, 34, 108,
202
		97, 115, 116, 95, 117, 112, 100, 97, 116, 101, 100, 34, 58, 32, 34, 116, 105, 109, 101,
203
		115, 116, 97, 109, 112, 46, 102, 111, 114, 109, 97, 116, 95, 115, 115, 40, 41, 34, 44,
204
		10, 32, 32, 34, 102, 114, 111, 109, 95, 115, 111, 117, 114, 99, 101, 34, 58, 32, 34, 102,
205
		114, 111, 109, 95, 115, 111, 117, 114, 99, 101, 34, 10, 125]
206

207
	sb.write(buffer)!
208

209
	unsafe { buffer.free() }
210

211
	assert sb.str() == r'{
212
  "server_path": "new_path",
213
  "last_updated": "timestamp.format_ss()",
214
  "from_source": "from_source"
215
}'
216
}
217

218
fn test_encode_time() {
219
	assert json.encode({
220
		'bro': json.Any(time.Time{})
221
	}) == '{"bro":"0000-00-00T00:00:00.000Z"}'
222

223
	assert json.encode({
224
		'bro': time.Time{}
225
	}) == '{"bro":"0000-00-00T00:00:00.000Z"}'
226

227
	assert json.encode(time.Time{}) == '"0000-00-00T00:00:00.000Z"'
228
}
229