v

1
module json2
2

3
fn test_str() {
4
	mut sc := Scanner{
5
		text: '"test"'.bytes()
6
	}
7
	tok := sc.scan()
8
	assert tok.kind == .str_
9
	assert tok.lit.len == 4
10
	assert tok.lit.bytestr() == 'test'
11
}
12

13
fn test_str_valid_unicode_escape() {
14
	mut sc := Scanner{
15
		text: r'"\u0048"'.bytes()
16
	}
17
	tok := sc.scan()
18
	assert tok.kind == .str_
19
	assert tok.lit.len == 1
20
	assert tok.lit.bytestr() == 'H'
21
}
22

23
fn test_str_valid_unicode_escape_2() {
24
	mut sc := Scanner{
25
		text: r'"\u2714"'.bytes()
26
	}
27
	tok := sc.scan()
28
	assert tok.kind == .str_
29
	assert tok.lit.len == 3
30
	assert tok.lit.bytestr() == '✔'
31
}
32

33
fn test_str_invalid_escape() {
34
	mut sc := Scanner{
35
		text: r'"\z"'.bytes()
36
	}
37
	tok := sc.scan()
38
	assert tok.kind == .error
39
	assert tok.lit.bytestr() == 'invalid backslash escape'
40
}
41

42
fn test_str_invalid_must_be_escape() {
43
	for ch in important_escapable_chars {
44
		mut sc := Scanner{
45
			text: [u8(`"`), `t`, ch, `"`]
46
		}
47
		tok := sc.scan()
48
		assert tok.kind == .error
49
		assert tok.lit.bytestr() == 'character must be escaped with a backslash'
50
	}
51
}
52

53
fn test_str_invalid_unicode_escape() {
54
	mut sc := Scanner{
55
		text: r'"\u010G"'.bytes()
56
	}
57
	tok := sc.scan()
58
	assert tok.kind == .error
59
	assert tok.lit.bytestr() == '`G` is not a hex digit'
60
}
61

62
fn test_str_invalid_unicode_escape_len() {
63
	mut sc := Scanner{
64
		text: r'"\u001"'.bytes()
65
	}
66
	tok := sc.scan()
67
	assert tok.kind == .error
68
	assert tok.lit.bytestr() == 'unicode escape must have 4 hex digits'
69
}
70

71
fn test_str_invalid_uppercase_u() {
72
	mut sc := Scanner{
73
		text: r'"\U0000"'.bytes()
74
	}
75
	tok := sc.scan()
76
	assert tok.kind == .error
77
	assert tok.lit.bytestr() == 'unicode endpoints must be in lowercase `u`'
78
}
79

80
fn test_str_missing_closing_bracket() {
81
	mut sc := Scanner{
82
		text: '"incomplete'.bytes()
83
	}
84
	tok := sc.scan()
85
	assert tok.kind == .error
86
	assert tok.lit.bytestr() == 'missing double quotes in string closing'
87
}
88

89
fn test_int() {
90
	mut sc := Scanner{
91
		text: '10'.bytes()
92
	}
93
	tok := sc.scan()
94
	assert tok.kind == .int_
95
	assert tok.lit.len == 2
96
	assert tok.lit.bytestr() == '10'
97
}
98

99
fn test_int_negative() {
100
	mut sc := Scanner{
101
		text: '-10'.bytes()
102
	}
103
	tok := sc.scan()
104
	assert tok.kind == .int_
105
	assert tok.lit.len == 3
106
	assert tok.lit.bytestr() == '-10'
107
}
108

109
fn test_float() {
110
	mut sc := Scanner{
111
		text: '123.400'.bytes()
112
	}
113
	tok := sc.scan()
114
	assert tok.kind == .float
115
	assert tok.lit.len == 7
116
	assert tok.lit.bytestr() == '123.400'
117
}
118

119
fn test_float_negative() {
120
	mut sc := Scanner{
121
		text: '-123.400'.bytes()
122
	}
123
	tok := sc.scan()
124
	assert tok.kind == .float
125
	assert tok.lit.len == 8
126
	assert tok.lit.bytestr() == '-123.400'
127
}
128

129
fn test_int_exp() {
130
	mut sc := Scanner{
131
		text: '1E22'.bytes()
132
	}
133
	tok := sc.scan()
134
	assert tok.kind == .int_
135
	assert tok.lit.len == 4
136
	assert tok.lit.bytestr() == '1E22'
137
}
138

139
fn test_int_exp_negative() {
140
	mut sc := Scanner{
141
		text: '1E-2'.bytes()
142
	}
143
	tok := sc.scan()
144
	assert tok.kind == .int_
145
	assert tok.lit.len == 4
146
	assert tok.lit.bytestr() == '1E-2'
147
}
148

149
fn test_int_exp_positive() {
150
	mut sc := Scanner{
151
		text: '1E+2'.bytes()
152
	}
153
	tok := sc.scan()
154
	assert tok.kind == .int_
155
	assert tok.lit.len == 4
156
	assert tok.lit.bytestr() == '1E+2'
157
}
158

159
fn test_float_exp() {
160
	mut sc := Scanner{
161
		text: '123.456e78'.bytes()
162
	}
163
	tok := sc.scan()
164
	assert tok.kind == .float
165
	assert tok.lit.len == 10
166
	assert tok.lit.bytestr() == '123.456e78'
167
}
168

169
fn test_float_exp_negative() {
170
	mut sc := Scanner{
171
		text: '20.56e-5'.bytes()
172
	}
173
	tok := sc.scan()
174
	assert tok.kind == .float
175
	assert tok.lit.len == 8
176
	assert tok.lit.bytestr() == '20.56e-5'
177
}
178

179
fn test_float_exp_positive() {
180
	mut sc := Scanner{
181
		text: '20.56e+5'.bytes()
182
	}
183
	tok := sc.scan()
184
	assert tok.kind == .float
185
	assert tok.lit.len == 8
186
	assert tok.lit.bytestr() == '20.56e+5'
187
}
188

189
fn test_number_with_space() {
190
	mut sc := Scanner{
191
		text: ' 4'.bytes()
192
	}
193
	tok := sc.scan()
194
	assert tok.kind == .int_
195
	assert tok.lit.len == 1
196
	assert tok.lit.bytestr() == '4'
197
}
198

199
fn test_number_invalid_leading_zero() {
200
	mut sc := Scanner{
201
		text: '0010'.bytes()
202
	}
203
	tok := sc.scan()
204
	assert tok.kind == .error
205
	assert tok.lit.bytestr() == 'leading zeroes in a number are not allowed'
206
}
207

208
fn test_number_invalid_leading_zero_negative() {
209
	mut sc := Scanner{
210
		text: '-0010'.bytes()
211
	}
212
	tok := sc.scan()
213
	assert tok.kind == .error
214
	assert tok.lit.bytestr() == 'leading zeroes in a number are not allowed'
215
}
216

217
fn test_number_invalid_start_char() {
218
	mut sc := Scanner{
219
		text: '+1'.bytes()
220
	}
221
	tok := sc.scan()
222
	assert tok.kind == .error
223
	assert tok.lit.bytestr() == 'invalid token `+`'
224
}
225

226
fn test_number_invalid_char() {
227
	mut sc := Scanner{
228
		text: '122x'.bytes()
229
	}
230
	sc.scan()
231
	tok := sc.scan()
232
	assert tok.kind == .error
233
	assert tok.lit.bytestr() == 'invalid token `x`'
234
}
235

236
fn test_number_invalid_char_float() {
237
	mut sc := Scanner{
238
		text: '122x.1'.bytes()
239
	}
240
	sc.scan()
241
	tok := sc.scan()
242
	assert tok.kind == .error
243
	assert tok.lit.bytestr() == 'invalid token `x`'
244
}
245

246
fn test_number_invalid_multiple_dot() {
247
	mut sc := Scanner{
248
		text: '122.108.10'.bytes()
249
	}
250
	sc.scan()
251
	tok := sc.scan()
252
	assert tok.kind == .error
253
	assert tok.lit.bytestr() == 'invalid token `.`'
254
}
255

256
fn test_number_invalid_exp() {
257
	mut sc := Scanner{
258
		text: '0.3e'.bytes()
259
	}
260
	tok := sc.scan()
261
	assert tok.kind == .error
262
	assert tok.lit.bytestr() == 'invalid exponent'
263
}
264

265
fn test_number_invalid_exp_with_sign() {
266
	mut sc := Scanner{
267
		text: '0.3e+'.bytes()
268
	}
269
	tok := sc.scan()
270
	assert tok.kind == .error
271
	assert tok.lit.bytestr() == 'invalid exponent'
272
}
273

274
fn test_number_invalid_zero_exp() {
275
	mut sc := Scanner{
276
		text: '0e'.bytes()
277
	}
278
	tok := sc.scan()
279
	assert tok.kind == .error
280
	assert tok.lit.bytestr() == 'invalid exponent'
281
}
282

283
fn test_number_invalid_dot_exp() {
284
	mut sc := Scanner{
285
		text: '0.e'.bytes()
286
	}
287
	tok := sc.scan()
288
	assert tok.kind == .error
289
	assert tok.lit.bytestr() == 'invalid float'
290
}
291

292
fn test_number_invalid_double_exp() {
293
	mut sc := Scanner{
294
		text: '2eE'.bytes()
295
	}
296
	sc.scan()
297
	tok := sc.scan()
298
	assert tok.kind == .error
299
	assert tok.lit.bytestr() == 'invalid token `E`'
300
}
301

302
fn test_null() {
303
	mut sc := Scanner{
304
		text: 'null'.bytes()
305
	}
306
	tok := sc.scan()
307
	assert tok.kind == .null
308
	assert tok.lit.len == 4
309
	assert tok.lit.bytestr() == 'null'
310
}
311

312
fn test_bool_true() {
313
	mut sc := Scanner{
314
		text: 'true'.bytes()
315
	}
316
	tok := sc.scan()
317
	assert tok.kind == .bool_
318
	assert tok.lit.len == 4
319
	assert tok.lit.bytestr() == 'true'
320
}
321

322
fn test_bool_false() {
323
	mut sc := Scanner{
324
		text: 'false'.bytes()
325
	}
326
	tok := sc.scan()
327
	assert tok.kind == .bool_
328
	assert tok.lit.len == 5
329
	assert tok.lit.bytestr() == 'false'
330
}
331

332
fn test_json_with_whitespace_start() {
333
	mut sc := Scanner{
334
		text: ' \n  \n\t {'.bytes()
335
	}
336
	tok := sc.scan()
337
	eprintln(tok)
338
	assert tok.kind == .lcbr
339
	assert tok.lit.len == 0
340
}
341

342
fn test_json_with_whitespace_end() {
343
	mut sc := Scanner{
344
		text: '}  \n\t'.bytes()
345
	}
346
	tok := sc.scan()
347
	assert tok.kind == .rcbr
348
	tok2 := sc.scan()
349
	eprintln(tok2)
350
	assert tok2.kind == .eof
351
}
352