1 #include"pch.h"
2
3 /*#ifdef WIN32
4 #define _CRTDBG_MAP_ALLOC
5 #include <stdlib.h>
6 #include <crtdbg.h>
7 #endif*/
8
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include "leptjson.h"
13 static int main_ret = 0;
14 static int test_count = 0;
15 static int test_pass = 0;
16
17 #define EXPECT_EQ_BASE(equality, expect, actual, format) \
18 do {\
19 test_count++;\
20 if (equality)\
21 test_pass++;\
22 else {\
23 fprintf(stderr, "%s:%d: expect: " format " actual: " format "\n", __FILE__, __LINE__, expect, actual);\
24 main_ret = 1;\
25 }\
26 } while(0)
27
28 //测试解析结果
29 #define EXPECT_EQ_INT(expect, actual) EXPECT_EQ_BASE((expect) == (actual), expect, actual, "%d")
30
31 //format为自动选择格式%e或者%f（选输出宽度小的）精度是保留17位以内
32 #define EXPECT_EQ_DOUBLE(expect, actual) EXPECT_EQ_BASE((expect) == (actual), expect, actual, "%.17g")
33 #define EXPECT_EQ_STRING(expect, actual, alength) \
34 EXPECT_EQ_BASE(sizeof(expect) - 1 == alength && memcmp(expect, actual, alength) == 0, expect, actual, "%s")
35 #define EXPECT_TRUE(actual) EXPECT_EQ_BASE((actual) != 0, "true", "false", "%s")
36 #define EXPECT_FALSE(actual) EXPECT_EQ_BASE((actual) == 0, "false", "true", "%s")
37 #define EXPECT_EQ_SIZE_T(expect, actual) EXPECT_EQ_BASE((expect) == (actual), (size_t)expect, (size_t)actual, "%zu")
38
39 //null测试
40 static void test_parse_null() {
41 lept_value v;
42 v.type = LEPT_FALSE;
43 EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "null"));
44 EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
45 }
46
47 //false测试
48 static void test_parse_false() {
49 lept_value v;
50 v.type = LEPT_TRUE;
51 EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "false"));
52 EXPECT_EQ_INT(LEPT_FALSE, lept_get_type(&v));
53 }
54
55 //true测试
56 static void test_parse_true() {
57 lept_value v;
58 v.type = LEPT_FALSE;
59 EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "true"));
60 EXPECT_EQ_INT(LEPT_TRUE, lept_get_type(&v));
61 }
62
63 static void test_parse_array() {
64 size_t i, j;
65 lept_value v;
66
67 lept_init(&v);
68 EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "[ ]"));
69 EXPECT_EQ_INT(LEPT_ARRAY, lept_get_type(&v));
70 EXPECT_EQ_SIZE_T(0, lept_get_array_size(&v));
71 lept_free(&v);
72
73 lept_init(&v);
74 EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "[ null , false , true , 123 , \"abc\" ]"));
75 EXPECT_EQ_INT(LEPT_ARRAY, lept_get_type(&v));
76 EXPECT_EQ_SIZE_T(5, lept_get_array_size(&v));
77 EXPECT_EQ_INT(LEPT_NULL, lept_get_type(lept_get_array_element(&v, 0)));
78 EXPECT_EQ_INT(LEPT_FALSE, lept_get_type(lept_get_array_element(&v, 1)));
79 EXPECT_EQ_INT(LEPT_TRUE, lept_get_type(lept_get_array_element(&v, 2)));
80 EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(lept_get_array_element(&v, 3)));
81 EXPECT_EQ_INT(LEPT_STRING, lept_get_type(lept_get_array_element(&v, 4)));
82 EXPECT_EQ_DOUBLE(123.0, lept_get_number(lept_get_array_element(&v, 3)));
83 EXPECT_EQ_STRING("abc", lept_get_string(lept_get_array_element(&v, 4)), lept_get_string_length(lept_get_array_element(&v, 4)));
84 lept_free(&v);
85
86 lept_init(&v);
87 EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, "[ [ ] , [ 0 ] , [ 0 , 1 ] , [ 0 , 1 , 2 ] ]"));
88 EXPECT_EQ_INT(LEPT_ARRAY, lept_get_type(&v));
89 EXPECT_EQ_SIZE_T(4, lept_get_array_size(&v));
90 for (i = 0; i < 4; i++) {
91 lept_value* a = lept_get_array_element(&v, i);
92 EXPECT_EQ_INT(LEPT_ARRAY, lept_get_type(a));
93 EXPECT_EQ_SIZE_T(i, lept_get_array_size(a));
94 for (j = 0; j < i; j++) {
95 lept_value* e = lept_get_array_element(a, j);
96 EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(e));
97 EXPECT_EQ_DOUBLE((double)j, lept_get_number(e));
98 }
99 }
100 lept_free(&v);
101 }
102
103 //尝试用宏来重构上述三个测试代码，因为他们具有重复性
104 #define TEST_ERROR(error, json)\
105 do {\
106 lept_value v;\
107 v.type = LEPT_FALSE;\
108 EXPECT_EQ_INT(error, lept_parse(&v, json));\
109 EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));\
110 } while(0)
111
112 //测试number
113 #define TEST_NUMBER(expect, json)\
114 do {\
115 lept_value v;\
116 EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, json));\
117 EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(&v));\
118 EXPECT_EQ_DOUBLE(expect, lept_get_number(&v));\
119 } while(0)
120
121 static void test_parse_number() {
122 TEST_NUMBER(0.0, "0");
123 TEST_NUMBER(0.0, "-0");
124 TEST_NUMBER(0.0, "-0.0");
125 //TEST_ERROR(0.5E10, "0.5E10");整数部分如果是0开始，只能是单个0
126 TEST_NUMBER(1.0, "1");
127 TEST_NUMBER(-1.0, "-1");
128 TEST_NUMBER(1.5, "1.5");
129 TEST_NUMBER(-1.5, "-1.5");
130 TEST_NUMBER(3.1416, "3.1416");
131 TEST_NUMBER(1E10, "1E10");
132 TEST_NUMBER(1e10, "1e10");
133 TEST_NUMBER(1E+10, "1E+10");
134 TEST_NUMBER(1E-10, "1E-10");
135 TEST_NUMBER(-1E10, "-1E10");
136 TEST_NUMBER(-1e10, "-1e10");
137 TEST_NUMBER(-1E+10, "-1E+10");
138 TEST_NUMBER(-1E-10, "-1E-10");
139 TEST_NUMBER(1.234E+10, "1.234E+10");
140 TEST_NUMBER(1.234E-10, "1.234E-10");
141 TEST_NUMBER(0.0, "1e-10000"); /* must underflow */
142
143 TEST_NUMBER(1.0000000000000002, "1.0000000000000002"); /* the smallest number > 1 */
144 TEST_NUMBER(4.9406564584124654e-324, "4.9406564584124654e-324"); /* minimum denormal */
145 TEST_NUMBER(-4.9406564584124654e-324, "-4.9406564584124654e-324");
146 TEST_NUMBER(2.2250738585072009e-308, "2.2250738585072009e-308"); /* Max subnormal double */
147 TEST_NUMBER(-2.2250738585072009e-308, "-2.2250738585072009e-308");
148 TEST_NUMBER(2.2250738585072014e-308, "2.2250738585072014e-308"); /* Min normal positive double */
149 TEST_NUMBER(-2.2250738585072014e-308, "-2.2250738585072014e-308");
150 TEST_NUMBER(1.7976931348623157e+308, "1.7976931348623157e+308"); /* Max double */
151 TEST_NUMBER(-1.7976931348623157e+308, "-1.7976931348623157e+308");
152 }
153
154 #define TEST_STRING(expect, json)\
155 do {\
156 lept_value v;\
157 lept_init(&v);\
158 EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, json));\
159 EXPECT_EQ_INT(LEPT_STRING, lept_get_type(&v));\
160 EXPECT_EQ_STRING(expect, lept_get_string(&v), lept_get_string_length(&v));\
161 lept_free(&v);\
162 } while(0)
163
164
165 static void test_parse_string() {
166 TEST_STRING("", "\"\"");
167 TEST_STRING("Hello", "\"Hello\"");
168 TEST_STRING("Hello\nWorld", "\"Hello\\nWorld\"");
169 TEST_STRING("\" \\ / \b \f \n \r \t", "\"\\\" \\\\ \\/ \\b \\f \\n \\r \\t\"");
170 TEST_STRING("Hello\0World", "\"Hello\\u0000World\"");
171 TEST_STRING("\x24", "\"\\u0024\""); /* Dollar sign U+0024 */
172 TEST_STRING("\xC2\xA2", "\"\\u00A2\""); /* Cents sign U+00A2 */
173 TEST_STRING("\xE2\x82\xAC", "\"\\u20AC\""); /* Euro sign U+20AC */
174 TEST_STRING("\xF0\x9D\x84\x9E", "\"\\uD834\\uDD1E\""); /* G clef sign U+1D11E */
175 TEST_STRING("\xF0\x9D\x84\x9E", "\"\\ud834\\udd1e\""); /* G clef sign U+1D11E */
176 }
177
178 static void test_parse_object() {
179 lept_value v;
180 size_t i;
181
182 lept_init(&v);
183 EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, " { } "));
184 EXPECT_EQ_INT(LEPT_OBJECT, lept_get_type(&v));
185 EXPECT_EQ_SIZE_T(0, lept_get_object_size(&v));
186 lept_free(&v);
187
188 lept_init(&v);
189 EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v,
190 " { "
191 "\"n\" : null , "
192 "\"f\" : false , "
193 "\"t\" : true , "
194 "\"i\" : 123 , "
195 "\"s\" : \"abc\", "
196 "\"a\" : [ 1, 2, 3 ],"
197 "\"o\" : { \"1\" : 1, \"2\" : 2, \"3\" : 3 }"
198 " } "
199 ));
200 EXPECT_EQ_INT(LEPT_OBJECT, lept_get_type(&v));
201 EXPECT_EQ_SIZE_T(7, lept_get_object_size(&v));
202 EXPECT_EQ_STRING("n", lept_get_object_key(&v, 0), lept_get_object_key_length(&v, 0));
203 EXPECT_EQ_INT(LEPT_NULL, lept_get_type(lept_get_object_value(&v, 0)));
204 EXPECT_EQ_STRING("f", lept_get_object_key(&v, 1), lept_get_object_key_length(&v, 1));
205 EXPECT_EQ_INT(LEPT_FALSE, lept_get_type(lept_get_object_value(&v, 1)));
206 EXPECT_EQ_STRING("t", lept_get_object_key(&v, 2), lept_get_object_key_length(&v, 2));
207 EXPECT_EQ_INT(LEPT_TRUE, lept_get_type(lept_get_object_value(&v, 2)));
208 EXPECT_EQ_STRING("i", lept_get_object_key(&v, 3), lept_get_object_key_length(&v, 3));
209 EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(lept_get_object_value(&v, 3)));
210 EXPECT_EQ_DOUBLE(123.0, lept_get_number(lept_get_object_value(&v, 3)));
211 EXPECT_EQ_STRING("s", lept_get_object_key(&v, 4), lept_get_object_key_length(&v, 4));
212 EXPECT_EQ_INT(LEPT_STRING, lept_get_type(lept_get_object_value(&v, 4)));
213 EXPECT_EQ_STRING("abc", lept_get_string(lept_get_object_value(&v, 4)), lept_get_string_length(lept_get_object_value(&v, 4)));
214 EXPECT_EQ_STRING("a", lept_get_object_key(&v, 5), lept_get_object_key_length(&v, 5));
215 EXPECT_EQ_INT(LEPT_ARRAY, lept_get_type(lept_get_object_value(&v, 5)));
216 EXPECT_EQ_SIZE_T(3, lept_get_array_size(lept_get_object_value(&v, 5)));
217 for (i = 0; i < 3; i++) {
218 lept_value* e = lept_get_array_element(lept_get_object_value(&v, 5), i);
219 EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(e));
220 EXPECT_EQ_DOUBLE(i + 1.0, lept_get_number(e));
221 }
222 EXPECT_EQ_STRING("o", lept_get_object_key(&v, 6), lept_get_object_key_length(&v, 6));
223 {
224 lept_value* o = lept_get_object_value(&v, 6);
225 EXPECT_EQ_INT(LEPT_OBJECT, lept_get_type(o));
226 for (i = 0; i < 3; i++) {
227 lept_value* ov = lept_get_object_value(o, i);
228 EXPECT_TRUE('1' + i == lept_get_object_key(o, i)[0]);
229 EXPECT_EQ_SIZE_T(1, lept_get_object_key_length(o, i));
230 EXPECT_EQ_INT(LEPT_NUMBER, lept_get_type(ov));
231 EXPECT_EQ_DOUBLE(i + 1.0, lept_get_number(ov));
232 }
233 }
234 lept_free(&v);
235 }
236
237 //以下用null作为示例，你修改其中参数即可作为别的类型测试
238 static void test_parse_expect_value() {
239 lept_value v;
240
241 v.type = LEPT_FALSE;
242 EXPECT_EQ_INT(LEPT_PARSE_EXPECT_VALUE, lept_parse(&v, ""));
243 EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
244
245 v.type = LEPT_FALSE;
246 EXPECT_EQ_INT(LEPT_PARSE_EXPECT_VALUE, lept_parse(&v, " "));
247 EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
248 }
249
250 //数据类型的错值判断
251 static void test_parse_invalid_value() {
252 TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "nul");
253 TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "?");
254
255 //invalid number
256 TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "+0");
257 TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "+1");
258 TEST_ERROR(LEPT_PARSE_INVALID_VALUE, ".123"); /* at least one digit before '.' */
259 TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "1."); /* at least one digit after '.' */
260 TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "INF");
261 TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "inf");
262 TEST_ERROR(LEPT_PARSE_INVALID_VALUE, "NAN");
263 }
264
265 static void test_parse_root_not_singular() {
266 TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "null x");
267
268 //暂时无法解决的问题
269 //invalid number
270 //TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "0123"); /* after zero should be '.' , 'E' , 'e' or nothing */
271 //TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "0x0");
272 //TEST_ERROR(LEPT_PARSE_ROOT_NOT_SINGULAR, "0x123");
273 }
274
275 static void test_parse_missing_quotation_mark() {
276 TEST_ERROR(LEPT_PARSE_MISS_QUOTATION_MARK, "\"");
277 TEST_ERROR(LEPT_PARSE_MISS_QUOTATION_MARK, "\"abc");
278 }
279
280 static void test_parse_invalid_string_escape() {
281 TEST_ERROR(LEPT_PARSE_INVALID_STRING_ESCAPE, "\"\\v\"");
282 TEST_ERROR(LEPT_PARSE_INVALID_STRING_ESCAPE, "\"\\'\"");
283 TEST_ERROR(LEPT_PARSE_INVALID_STRING_ESCAPE, "\"\\0\"");
284 TEST_ERROR(LEPT_PARSE_INVALID_STRING_ESCAPE, "\"\\x12\"");
285 }
286
287 static void test_parse_invalid_string_char() {
288 TEST_ERROR(LEPT_PARSE_INVALID_STRING_CHAR, "\"\x01\"");
289 TEST_ERROR(LEPT_PARSE_INVALID_STRING_CHAR, "\"\x1F\"");
290 }
291
292 static void test_parse_invalid_unicode_hex() {
293 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u\"");
294 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u0\"");
295 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u01\"");
296 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u012\"");
297 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u/000\"");
298 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\uG000\"");
299 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u0/00\"");
300 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u0G00\"");
301 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u00/0\"");
302 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u00G0\"");
303 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u000/\"");
304 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u000G\"");
305 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_HEX, "\"\\u 123\"");
306 }
307
308 static void test_parse_invalid_unicode_surrogate() {
309 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE, "\"\\uD800\"");
310 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE, "\"\\uDBFF\"");
311 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE, "\"\\uD800\\\\\"");
312 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE, "\"\\uD800\\uDBFF\"");
313 TEST_ERROR(LEPT_PARSE_INVALID_UNICODE_SURROGATE, "\"\\uD800\\uE000\"");
314 }
315
316 static void test_parse_miss_comma_or_square_bracket() {
317 TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_SQUARE_BRACKET, "[1");
318 TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_SQUARE_BRACKET, "[1}");
319 TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_SQUARE_BRACKET, "[1 2");
320 TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_SQUARE_BRACKET, "[[]");
321 }
322
323 static void test_parse_miss_key() {
324 TEST_ERROR(LEPT_PARSE_MISS_KEY, "{:1,");
325 TEST_ERROR(LEPT_PARSE_MISS_KEY, "{1:1,");
326 TEST_ERROR(LEPT_PARSE_MISS_KEY, "{true:1,");
327 TEST_ERROR(LEPT_PARSE_MISS_KEY, "{false:1,");
328 TEST_ERROR(LEPT_PARSE_MISS_KEY, "{null:1,");
329 TEST_ERROR(LEPT_PARSE_MISS_KEY, "{[]:1,");
330 TEST_ERROR(LEPT_PARSE_MISS_KEY, "{{}:1,");
331 TEST_ERROR(LEPT_PARSE_MISS_KEY, "{\"a\":1,");
332 }
333
334 static void test_parse_miss_colon() {
335 TEST_ERROR(LEPT_PARSE_MISS_COLON, "{\"a\"}");
336 TEST_ERROR(LEPT_PARSE_MISS_COLON, "{\"a\",\"b\"}");
337 }
338
339 static void test_parse_miss_comma_or_curly_bracket() {
340 TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_CURLY_BRACKET, "{\"a\":1");
341 TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_CURLY_BRACKET, "{\"a\":1]");
342 TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_CURLY_BRACKET, "{\"a\":1 \"b\"");
343 TEST_ERROR(LEPT_PARSE_MISS_COMMA_OR_CURLY_BRACKET, "{\"a\":{}");
344 }
345
346 static void test_access_null() {
347 lept_value v;
348 lept_init(&v);
349 lept_set_string(&v, "a", 1);
350 lept_set_null(&v);
351 EXPECT_EQ_INT(LEPT_NULL, lept_get_type(&v));
352 lept_free(&v);
353 }
354
355 static void test_access_boolean() {
356 lept_value v;
357 lept_init(&v);
358 lept_set_string(&v, "a", 1);
359 lept_set_boolean(&v, 1);
360 EXPECT_TRUE(lept_get_boolean(&v));
361 lept_set_boolean(&v, 0);
362 EXPECT_FALSE(lept_get_boolean(&v));
363 lept_free(&v);
364 }
365
366 static void test_access_number() {
367 lept_value v;
368 lept_init(&v);
369 lept_set_string(&v, "a", 1);
370 lept_set_number(&v, 1234.5);
371 EXPECT_EQ_DOUBLE(1234.5, lept_get_number(&v));
372 lept_free(&v);
373 }
374
375 static void test_access_string() {
376 lept_value v;
377 lept_init(&v);
378 lept_set_string(&v, "", 0);
379 EXPECT_EQ_STRING("", lept_get_string(&v), lept_get_string_length(&v));
380 lept_set_string(&v, "Hello", 5);
381 EXPECT_EQ_STRING("Hello", lept_get_string(&v), lept_get_string_length(&v));
382 lept_free(&v);
383 }
384
385 static void test_parse() {
386 test_parse_null();
387 test_parse_true();
388 test_parse_false();
389 test_parse_number();
390 test_parse_string();
391 test_parse_expect_value();
392 test_parse_invalid_value();
393 test_parse_root_not_singular();
394 //test_parse_number_too_big();
395 test_parse_missing_quotation_mark();
396 test_parse_invalid_string_escape();
397 test_parse_invalid_string_char();
398 test_parse_invalid_unicode_hex();
399 test_parse_invalid_unicode_surrogate();
400 test_parse_miss_comma_or_square_bracket();
401 test_parse_miss_key();
402 test_parse_miss_colon();
403 test_parse_miss_comma_or_curly_bracket();
404
405 test_access_null();
406 test_access_boolean();
407 test_access_number();
408 test_access_string();
409 test_parse_array();
410 test_parse_object();
411 }
412
413 int main() {
414 /*#ifdef WIN32
415 _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
416 //_CrtSetBreakAlloc(87); //在系统提示的第几次内存泄漏情况后，设置断点，可以更好的追踪泄漏源
417 #endif
418 */
419
420 test_parse();
421 printf("%d/%d (%3.2f%%) passed\n", test_pass, test_count, test_pass * 100.0 / test_count);
422 return main_ret;
423 }
