jdk-build-libs
/
json-c
Not watched
1
0
Fork 0
Code
Releases 11 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 787a8b3f1c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '787a8b3f1c'
${ noResults }
json-c/tests/test_parse.c

506 lines
20 kB
Raw Blame History 

  1. #include <stdio.h>

  2. #include <stdlib.h>

  3. #include <stddef.h>

  4. #include <string.h>

  5. #include <assert.h>

  6. 

  7. #include "json.h"

  8. #include "json_tokener.h"

  9. #include "json_visit.h"

  10. 

  11. static void test_basic_parse(void);

  12. static void test_utf8_parse(void);

  13. static void test_verbose_parse(void);

  14. static void test_incremental_parse(void);

  15. 

  16. int main(void)

  17. {

  18. 	MC_SET_DEBUG(1);

  19. 

  20. 	static const char separator[] = "==================================";

  21. 	test_basic_parse();

  22. 	puts(separator);

  23. 	test_utf8_parse();

  24. 	puts(separator);

  25. 	test_verbose_parse();

  26. 	puts(separator);

  27. 	test_incremental_parse();

  28. 	puts(separator);

  29. 

  30. 	return 0;

  31. }

  32. 

  33. static json_c_visit_userfunc clear_serializer;

  34. static void do_clear_serializer(json_object *jso);

  35. 

  36. static void single_basic_parse(const char *test_string, int clear_serializer)

  37. {

  38. 	json_object *new_obj;

  39. 

  40. 	new_obj = json_tokener_parse(test_string);

  41. 	if (clear_serializer)

  42. 		do_clear_serializer(new_obj);

  43. 	printf("new_obj.to_string(%s)=%s\n", test_string, json_object_to_json_string(new_obj));

  44. 	json_object_put(new_obj);

  45. }

  46. static void test_basic_parse()

  47. {

  48. 	single_basic_parse("\"\003\"", 0);

  49. 	single_basic_parse("/* hello */\"foo\"", 0);

  50. 	single_basic_parse("// hello\n\"foo\"", 0);

  51. 	single_basic_parse("\"foo\"blue", 0);

  52. 	single_basic_parse("\'foo\'", 0);

  53. 	single_basic_parse("\"\\u0041\\u0042\\u0043\"", 0);

  54. 	single_basic_parse("\"\\u4e16\\u754c\\u00df\"", 0);

  55. 	single_basic_parse("\"\\u4E16\"", 0);

  56. 	single_basic_parse("\"\\u4e1\"", 0);

  57. 	single_basic_parse("\"\\u4e1@\"", 0);

  58. 	single_basic_parse("\"\\ud840\\u4e16\"", 0);

  59. 	single_basic_parse("\"\\ud840\"", 0);

  60. 	single_basic_parse("\"\\udd27\"", 0);

  61. 	// Test with a "short" high surrogate

  62. 	single_basic_parse("[9,'\\uDAD", 0);

  63. 	single_basic_parse("null", 0);

  64. 	single_basic_parse("NaN", 0);

  65. 	single_basic_parse("-NaN", 0); /* non-sensical, returns null */

  66. 

  67. 	single_basic_parse("Inf", 0); /* must use full string, returns null */

  68. 	single_basic_parse("inf", 0); /* must use full string, returns null */

  69. 	single_basic_parse("Infinity", 0);

  70. 	single_basic_parse("infinity", 0);

  71. 	single_basic_parse("-Infinity", 0);

  72. 	single_basic_parse("-infinity", 0);

  73. 	single_basic_parse("{ \"min\": Infinity, \"max\": -Infinity}", 0);

  74. 

  75. 	single_basic_parse("Infinity!", 0);

  76. 	single_basic_parse("Infinitynull", 0);

  77. 	single_basic_parse("InfinityXXXX", 0);

  78. 	single_basic_parse("-Infinitynull", 0);

  79. 	single_basic_parse("-InfinityXXXX", 0);

  80. 	single_basic_parse("Infinoodle", 0);

  81. 	single_basic_parse("InfinAAA", 0);

  82. 	single_basic_parse("-Infinoodle", 0);

  83. 	single_basic_parse("-InfinAAA", 0);

  84. 

  85. 	single_basic_parse("True", 0);

  86. 	single_basic_parse("False", 0);

  87. 

  88. 	/* not case sensitive */

  89. 	single_basic_parse("tRue", 0);

  90. 	single_basic_parse("fAlse", 0);

  91. 	single_basic_parse("nAn", 0);

  92. 	single_basic_parse("iNfinity", 0);

  93. 

  94. 	single_basic_parse("12", 0);

  95. 	single_basic_parse("12.3", 0);

  96. 	single_basic_parse("12.3.4", 0); /* non-sensical, returns null */

  97. 	/* was returning (int)2015 before patch, should return null */

  98. 	single_basic_parse("2015-01-15", 0);

  99. 

  100. 	/* ...but this works.  It's rather inconsistent, and a future major release

  101. 	 * should change the behavior so it either always returns null when extra

  102. 	 * bytes are present (preferred), or always return object created from as much

  103. 	 * as was able to be parsed.

  104. 	 */

  105. 	single_basic_parse("12.3xxx", 0);

  106. 

  107. 	single_basic_parse("{\"FoO\"  :   -12.3E512}", 0);

  108. 	single_basic_parse("{\"FoO\"  :   -12.3e512}", 0);

  109. 	single_basic_parse("{\"FoO\"  :   -12.3E51.2}", 0); /* non-sensical, returns null */

  110. 	single_basic_parse("{\"FoO\"  :   -12.3E512E12}", 0); /* non-sensical, returns null */

  111. 	single_basic_parse("[\"\\n\"]", 0);

  112. 	single_basic_parse("[\"\\nabc\\n\"]", 0);

  113. 	single_basic_parse("[null]", 0);

  114. 	single_basic_parse("[]", 0);

  115. 	single_basic_parse("[false]", 0);

  116. 	single_basic_parse("[\"abc\",null,\"def\",12]", 0);

  117. 	single_basic_parse("{}", 0);

  118. 	single_basic_parse("{ \"foo\": \"bar\" }", 0);

  119. 	single_basic_parse("{ \'foo\': \'bar\' }", 0);

  120. 	single_basic_parse("{ \"foo\": \"bar\", \"baz\": null, \"bool0\": true }", 0);

  121. 	single_basic_parse("{ \"foo\": [null, \"foo\"] }", 0);

  122. 	single_basic_parse("{ \"abc\": 12, \"foo\": \"bar\", \"bool0\": false, \"bool1\": true, \"arr\": [ 1, 2, 3, null, 5 ] }", 0);

  123. 	single_basic_parse("{ \"abc\": \"blue\nred\\ngreen\" }", 0);

  124. 

  125. 	// Clear serializer for these tests so we see the actual parsed value.

  126. 	single_basic_parse("null", 1);

  127. 	single_basic_parse("false", 1);

  128. 	single_basic_parse("[0e]", 1);

  129. 	single_basic_parse("[0e+]", 1);

  130. 	single_basic_parse("[0e+-1]", 1);

  131. 	single_basic_parse("[18446744073709551616]", 1);

  132. 	single_basic_parse("\"hello world!\"", 1);

  133. }

  134. 

  135. static void test_utf8_parse()

  136. {

  137. 	// json_tokener_parse doesn't support checking for byte order marks.

  138. 	// It's the responsibility of the caller to detect and skip a BOM.

  139. 	// Both of these checks return null.

  140. 	char utf8_bom[] = { 0xEF, 0xBB, 0xBF, 0x00 };

  141. 	char utf8_bom_and_chars[] = { 0xEF, 0xBB, 0xBF, '{', '}', 0x00 };

  142. 	single_basic_parse(utf8_bom, 0);

  143. 	single_basic_parse(utf8_bom_and_chars, 0);

  144. }

  145. 

  146. // Clear the re-serialization information that the tokener

  147. // saves to ensure that the output reflects the actual

  148. // values we parsed, rather than just the original input.

  149. static void do_clear_serializer(json_object *jso)

  150. {

  151. 	json_c_visit(jso, 0, clear_serializer, NULL);

  152. }

  153. 

  154. static int clear_serializer(json_object *jso, int flags,

  155.                      json_object *parent_jso,

  156.                      const char *jso_key,

  157.                      size_t *jso_index, void *userarg)

  158. {

  159. 	if (jso)

  160. 		json_object_set_serializer(jso, NULL, NULL, NULL);

  161. 	return JSON_C_VISIT_RETURN_CONTINUE;

  162. }

  163. 

  164. static void test_verbose_parse()

  165. {

  166. 	json_object *new_obj;

  167. 	enum json_tokener_error error = json_tokener_success;

  168. 

  169. 	new_obj = json_tokener_parse_verbose("{ foo }", &error);

  170. 	assert (error == json_tokener_error_parse_object_key_name);

  171. 	assert (new_obj == NULL);

  172. 

  173. 	new_obj = json_tokener_parse("{ foo }");

  174. 	assert (new_obj == NULL);

  175. 

  176. 	new_obj = json_tokener_parse("foo");

  177. 	assert (new_obj == NULL);

  178. 	new_obj = json_tokener_parse_verbose("foo", &error);

  179. 	assert (new_obj == NULL);

  180. 

  181. 	/* b/c the string starts with 'f' parsing return a boolean error */

  182. 	assert (error == json_tokener_error_parse_boolean);

  183. 

  184. 	puts("json_tokener_parse_verbose() OK");

  185. }

  186. 

  187. struct incremental_step {

  188. 	const char *string_to_parse;

  189. 	int length;

  190. 	int char_offset;

  191. 	enum json_tokener_error expected_error;

  192. 	int reset_tokener;

  193. } incremental_steps[] = {

  194. 

  195. 	/* Check that full json messages can be parsed, both w/ and w/o a reset */

  196. 	{ "{ \"foo\": 123 }", -1, -1, json_tokener_success,  0 },

  197. 	{ "{ \"foo\": 456 }", -1, -1, json_tokener_success,  1 },

  198. 	{ "{ \"foo\": 789 }", -1, -1, json_tokener_success,  1 },

  199. 

  200. 	/* Check the comment parse*/

  201. 	{ "/* hello */{ \"foo\"", -1, -1, json_tokener_continue,  0 },

  202. 	{ "/* hello */:/* hello */", -1, -1, json_tokener_continue,  0 },

  203. 	{ "\"bar\"/* hello */", -1, -1, json_tokener_continue,  0 },

  204. 	{ "}/* hello */", -1, -1, json_tokener_success,  1 },

  205. 	{ "/ hello ", -1, 1, json_tokener_error_parse_comment,  1 },

  206. 	{ "/* hello\"foo\"", -1, -1, json_tokener_continue,  1 },

  207. 	{ "/* hello*\"foo\"", -1, -1, json_tokener_continue,  1 },

  208. 	{ "// hello\"foo\"", -1, -1, json_tokener_continue,  1 },

  209. 

  210. 	/*  Check a basic incremental parse */

  211. 	{ "{ \"foo",          -1, -1, json_tokener_continue, 0 },

  212. 	{ "\": {\"bar",       -1, -1, json_tokener_continue, 0 },

  213. 	{ "\":13}}",          -1, -1, json_tokener_success,  1 },

  214. 

  215. 	/* Check that json_tokener_reset actually resets */

  216. 	{ "{ \"foo",          -1, -1, json_tokener_continue, 1 },

  217. 	{ ": \"bar\"}",       -1, 0, json_tokener_error_parse_unexpected, 1 },

  218. 

  219. 	/* Check incremental parsing with trailing characters */

  220. 	{ "{ \"foo",          -1, -1, json_tokener_continue, 0 },

  221. 	{ "\": {\"bar",       -1, -1, json_tokener_continue, 0 },

  222. 	{ "\":13}}XXXX",      10, 6, json_tokener_success,  0 },

  223. 	{ "XXXX",              4, 0, json_tokener_error_parse_unexpected, 1 },

  224. 

  225. 	/* Check that trailing characters can change w/o a reset */

  226. 	{ "{\"x\": 123 }\"X\"", -1, 11, json_tokener_success, 0 },

  227. 	{ "\"Y\"",            -1, -1, json_tokener_success, 1 },

  228. 

  229. 	/* To stop parsing a number we need to reach a non-digit, e.g. a \0 */

  230. 	{ "1",                 1, 1, json_tokener_continue, 0 },

  231. 	/* This should parse as the number 12, since it continues the "1" */

  232. 	{ "2",                 2, 1, json_tokener_success, 0 },

  233. 	{ "12{",               3, 2, json_tokener_success, 1 },

  234. 	/* Parse number in strict model */

  235. 	{ "[02]",             -1, 3, json_tokener_error_parse_number, 3 },

  236. 

  237. 	/* Similar tests for other kinds of objects: */

  238. 	/* These could all return success immediately, since regardless of

  239. 	   what follows the false/true/null token we *will* return a json object,

  240.        but it currently doesn't work that way.  hmm... */

  241. 	{ "false",             5, 5, json_tokener_continue, 1 },

  242. 	{ "false",             6, 5, json_tokener_success, 1 },

  243. 	{ "true",              4, 4, json_tokener_continue, 1 },

  244. 	{ "true",              5, 4, json_tokener_success, 1 },

  245. 	{ "null",              4, 4, json_tokener_continue, 1 },

  246. 	{ "null",              5, 4, json_tokener_success, 1 },

  247. 

  248. 	{ "Infinity",          9, 8, json_tokener_success, 1 },

  249. 	{ "infinity",          9, 8, json_tokener_success, 1 },

  250. 	{ "-infinity",        10, 9, json_tokener_success, 1 },

  251. 	{ "infinity",          9, 0, json_tokener_error_parse_unexpected, 3 },

  252. 	{ "-infinity",        10, 1, json_tokener_error_parse_unexpected, 3 },

  253. 

  254. 	{ "inf",               3, 3, json_tokener_continue, 0 },

  255. 	{ "inity",             6, 5, json_tokener_success, 1 },

  256. 	{ "-inf",              4, 4, json_tokener_continue, 0 },

  257. 	{ "inity",             6, 5, json_tokener_success, 1 },

  258. 

  259. 	{ "i",                 1, 1, json_tokener_continue, 0 },

  260. 	{ "n",                 1, 1, json_tokener_continue, 0 },

  261. 	{ "f",                 1, 1, json_tokener_continue, 0 },

  262. 	{ "i",                 1, 1, json_tokener_continue, 0 },

  263. 	{ "n",                 1, 1, json_tokener_continue, 0 },

  264. 	{ "i",                 1, 1, json_tokener_continue, 0 },

  265. 	{ "t",                 1, 1, json_tokener_continue, 0 },

  266. 	{ "y",                 1, 1, json_tokener_continue, 0 },

  267. 	{ "",                  1, 0, json_tokener_success, 1 },

  268. 

  269. 	{ "-",                 1, 1, json_tokener_continue, 0 },

  270. 	{ "inf",               3, 3, json_tokener_continue, 0 },

  271. 	{ "ini",               3, 3, json_tokener_continue, 0 },

  272. 	{ "ty",                3, 2, json_tokener_success, 1 },

  273. 

  274. 	{ "-",                 1, 1, json_tokener_continue, 0 },

  275. 	{ "i",                 1, 1, json_tokener_continue, 0 },

  276. 	{ "nfini",             5, 5, json_tokener_continue, 0 },

  277. 	{ "ty",                3, 2, json_tokener_success, 1 },

  278. 

  279. 	{ "-i",                2, 2, json_tokener_continue, 0 },

  280. 	{ "nfinity",           8, 7, json_tokener_success, 1 },

  281. 

  282. 	{ "InfinityX",        10, 8, json_tokener_success, 0 },

  283. 	{ "X",                 1, 0, json_tokener_error_parse_unexpected, 1 },

  284. 

  285. 	{ "Infinity1234",     13, 8, json_tokener_success, 0 },

  286. 	{ "1234",              5, 4, json_tokener_success, 1 },

  287. 

  288. 	{ "Infinity9999",      8, 8, json_tokener_continue, 0 },

  289. 

  290. 	/* returns the Infinity loaded up by the previous call: */

  291. 	{ "1234",              5, 0, json_tokener_success, 0 },

  292. 	{ "1234",              5, 4, json_tokener_success, 1 },

  293. 

  294. 	/* offset=1 because "n" is the start of "null".  hmm... */

  295. 	{ "noodle",            7, 1, json_tokener_error_parse_null, 1 },

  296. 	/* offset=2 because "na" is the start of "nan".  hmm... */

  297. 	{ "naodle",            7, 2, json_tokener_error_parse_null, 1 },

  298. 	/* offset=2 because "tr" is the start of "true".  hmm... */

  299. 	{ "track",             6, 2, json_tokener_error_parse_boolean, 1 },

  300. 	{ "fail",              5, 2, json_tokener_error_parse_boolean, 1 },

  301. 

  302. 	/* Although they may initially look like they should fail,

  303. 	   the next few tests check that parsing multiple sequential

  304.        json objects in the input works as expected */

  305. 	{ "null123",           9, 4, json_tokener_success, 0 },

  306. 	{ "null123" + 4,       4, 3, json_tokener_success, 1 },

  307. 	{ "nullx",             5, 4, json_tokener_success, 0 },

  308. 	{ "nullx" + 4,         2, 0, json_tokener_error_parse_unexpected, 1 },

  309. 	{ "{\"a\":1}{\"b\":2}",15, 7, json_tokener_success, 0 },

  310. 	{ "{\"a\":1}{\"b\":2}" + 7,

  311. 	                       8, 7, json_tokener_success, 1 },

  312. 

  313. 	/* Some bad formatting. Check we get the correct error status */

  314. 	{ "2015-01-15",       10, 4, json_tokener_error_parse_number, 1 },

  315. 

  316. 	/* Strings have a well defined end point, so we can stop at the quote */

  317. 	{ "\"blue\"",         -1, -1, json_tokener_success, 0 },

  318. 

  319. 	/* Check each of the escape sequences defined by the spec */

  320. 	{ "\"\\\"\"",         -1, -1, json_tokener_success, 0 },

  321. 	{ "\"\\\\\"",         -1, -1, json_tokener_success, 0 },

  322. 	{ "\"\\b\"",         -1, -1, json_tokener_success, 0 },

  323. 	{ "\"\\f\"",         -1, -1, json_tokener_success, 0 },

  324. 	{ "\"\\n\"",         -1, -1, json_tokener_success, 0 },

  325. 	{ "\"\\r\"",         -1, -1, json_tokener_success, 0 },

  326. 	{ "\"\\t\"",         -1, -1, json_tokener_success, 0 },

  327. 	{ "\"\\/\"",         -1, -1, json_tokener_success, 0 },

  328. 	// Escaping a forward slash is optional

  329. 	{ "\"/\"",           -1, -1, json_tokener_success, 0 },

  330. 	/* Check wrong escape sequences */

  331. 	{ "\"\\a\"",         -1, 2, json_tokener_error_parse_string, 1 },

  332. 

  333. 	/* Check '\'' in strict model */

  334. 	{ "\'foo\'",         -1, 0, json_tokener_error_parse_unexpected, 3 },

  335. 

  336. 	/* Parse array/object */

  337. 	{ "[1,2,3]",          -1, -1, json_tokener_success, 0 },

  338. 	{ "[1,2,3}",         -1, 6, json_tokener_error_parse_array, 1 },

  339. 	{ "{\"a\"}",         -1, 4, json_tokener_error_parse_object_key_sep, 1 },

  340. 	{ "{\"a\":1]",       -1, 6, json_tokener_error_parse_object_value_sep, 1 },

  341. 	{ "{\"a\"::1}",      -1, 5, json_tokener_error_parse_unexpected, 1 },

  342. 	{ "{\"a\":}",        -1, 5, json_tokener_error_parse_unexpected, 1 },

  343. 	{ "{\"a\":1,\"a\":2}",-1, -1, json_tokener_success, 1 },

  344. 	{ "\"a\":1}",        -1, 3, json_tokener_success, 1 },

  345. 	{ "{\"a\":1",        -1, -1, json_tokener_continue, 1 },

  346. 	{ "[,]",             -1, 1, json_tokener_error_parse_unexpected, 1 },

  347. 	{ "[,1]",             -1, 1, json_tokener_error_parse_unexpected, 1 },

  348. 

  349. 	/* This behaviour doesn't entirely follow the json spec, but until we have

  350. 	   a way to specify how strict to be we follow Postel's Law and be liberal

  351. 	   in what we accept (up to a point). */

  352. 	{ "[1,2,3,]",         -1, -1, json_tokener_success, 0 },

  353. 	{ "[1,2,,3,]",        -1, 5, json_tokener_error_parse_unexpected, 0 },

  354. 

  355. 	{ "[1,2,3,]",         -1, 7, json_tokener_error_parse_unexpected, 3 },

  356. 	{ "{\"a\":1,}",         -1, 7, json_tokener_error_parse_unexpected, 3 },

  357. 

  358.   // utf-8 test

  359.   // acsll encoding

  360. 	{ "\x22\x31\x32\x33\x61\x73\x63\x24\x25\x26\x22",-1, -1, json_tokener_success, 5 },

  361. 	{ "\x22\x31\x32\x33\x61\x73\x63\x24\x25\x26\x22",-1, -1, json_tokener_success, 1 },

  362.   // utf-8 encoding

  363. 	{ "\x22\xe4\xb8\x96\xe7\x95\x8c\x22",-1, -1, json_tokener_success, 5 },

  364. 	{ "\x22\xe4\xb8",-1, 3, json_tokener_error_parse_utf8_string, 4 },

  365. 	{ "\x96\xe7\x95\x8c\x22",-1, 0, json_tokener_error_parse_utf8_string, 5 },

  366. 	{ "\x22\xe4\xb8\x96\xe7\x95\x8c\x22",-1, -1, json_tokener_success, 1 },

  367. 	{ "\x22\xcf\x80\xcf\x86\x22",-1, -1, json_tokener_success, 5 },

  368. 	{ "\x22\xf0\xa5\x91\x95\x22",-1, -1, json_tokener_success, 5 },

  369.   // wrong utf-8 encoding

  370. 	{ "\x22\xe6\x9d\x4e\x22",-1, 3, json_tokener_error_parse_utf8_string, 5 },

  371. 	{ "\x22\xe6\x9d\x4e\x22",-1, 5, json_tokener_success, 1 },

  372.   // GBK encoding

  373. 	{ "\x22\xc0\xee\xc5\xf4\x22",-1, 2, json_tokener_error_parse_utf8_string, 5 },

  374. 	{ "\x22\xc0\xee\xc5\xf4\x22",-1, 6, json_tokener_success, 1 },

  375.   // char after space

  376. 	{ "\x20\x20\x22\xe4\xb8\x96\x22",-1, -1, json_tokener_success, 5 },

  377. 	{ "\x20\x20\x81\x22\xe4\xb8\x96\x22",-1, 2, json_tokener_error_parse_utf8_string, 5 },

  378. 	{ "\x5b\x20\x81\x31\x5d",-1, 2, json_tokener_error_parse_utf8_string, 5 },

  379.   // char in state inf

  380. 	{ "\x49\x6e\x66\x69\x6e\x69\x74\x79",9, 8, json_tokener_success, 1 },

  381. 	{ "\x49\x6e\x66\x81\x6e\x69\x74\x79",-1, 3, json_tokener_error_parse_utf8_string, 5 },

  382.   // char in escape unicode

  383. 	{ "\x22\x5c\x75\x64\x38\x35\x35\x5c\x75\x64\x63\x35\x35\x22",15, 14, json_tokener_success, 5 },

  384. 	{ "\x22\x5c\x75\x64\x38\x35\x35\xc0\x75\x64\x63\x35\x35\x22",-1, 8, json_tokener_error_parse_utf8_string, 5 },

  385. 	{ "\x22\x5c\x75\x64\x30\x30\x33\x31\xc0\x22",-1, 9, json_tokener_error_parse_utf8_string, 5 },

  386.   // char in number

  387. 	{ "\x31\x31\x81\x31\x31",-1, 2, json_tokener_error_parse_utf8_string, 5 },

  388.   // char in object

  389. 	{ "\x7b\x22\x31\x81\x22\x3a\x31\x7d",-1, 3, json_tokener_error_parse_utf8_string, 5 },

  390. 

  391. 	{ NULL, -1, -1, json_tokener_success, 0 },

  392. };

  393. 

  394. static void test_incremental_parse()

  395. {

  396. 	json_object *new_obj;

  397. 	enum json_tokener_error jerr;

  398. 	struct json_tokener *tok;

  399. 	const char *string_to_parse;

  400. 	int ii;

  401. 	int num_ok, num_error;

  402. 

  403. 	num_ok = 0;

  404. 	num_error = 0;

  405. 

  406. 	printf("Starting incremental tests.\n");

  407. 	printf("Note: quotes and backslashes seen in the output here are literal values passed\n");

  408. 	printf("     to the parse functions.  e.g. this is 4 characters: \"\\f\"\n");

  409. 

  410. 	string_to_parse = "{ \"foo"; /* } */

  411. 	printf("json_tokener_parse(%s) ... ", string_to_parse);

  412. 	new_obj = json_tokener_parse(string_to_parse);

  413. 	if (new_obj == NULL) puts("got error as expected");

  414. 

  415. 	/* test incremental parsing in various forms */

  416. 	tok = json_tokener_new();

  417. 	for (ii = 0; incremental_steps[ii].string_to_parse != NULL; ii++)

  418. 	{

  419. 		int this_step_ok = 0;

  420. 		struct incremental_step *step = &incremental_steps[ii];

  421. 		int length = step->length;

  422. 		size_t expected_char_offset;

  423. 

  424. 		if (step->reset_tokener & 2)

  425. 			{

  426. 				if (step->reset_tokener & 4)

  427. 					json_tokener_set_flags(tok, 3);

  428. 				else

  429. 					json_tokener_set_flags(tok, JSON_TOKENER_STRICT);

  430. 			}

  431. 		else

  432. 			{

  433. 				if (step->reset_tokener & 4)

  434. 					json_tokener_set_flags(tok, JSON_TOKENER_VALIDATE_UTF8);

  435. 				else

  436. 					json_tokener_set_flags(tok, 0);

  437. 			}

  438. 

  439. 		if (length == -1)

  440. 			length = strlen(step->string_to_parse);

  441. 		if (step->char_offset == -1)

  442. 			expected_char_offset = length;

  443. 		else

  444. 			expected_char_offset = step->char_offset;

  445. 

  446. 		printf("json_tokener_parse_ex(tok, %-12s, %3d) ... ",

  447. 			step->string_to_parse, length);

  448. 		new_obj = json_tokener_parse_ex(tok, step->string_to_parse, length);

  449. 

  450. 		jerr = json_tokener_get_error(tok);

  451. 		if (step->expected_error != json_tokener_success)

  452. 		{

  453. 			if (new_obj != NULL)

  454. 				printf("ERROR: invalid object returned: %s\n",

  455. 				       json_object_to_json_string(new_obj));

  456. 			else if (jerr != step->expected_error)

  457. 				printf("ERROR: got wrong error: %s\n",

  458. 				       json_tokener_error_desc(jerr));

  459. 			else if (json_tokener_get_parse_end(tok) != expected_char_offset)

  460. 				printf("ERROR: wrong char_offset %zu != expected %zu\n",

  461. 				       json_tokener_get_parse_end(tok),

  462. 				       expected_char_offset);

  463. 			else

  464. 			{

  465. 				printf("OK: got correct error: %s\n",

  466. 				       json_tokener_error_desc(jerr));

  467. 				this_step_ok = 1;

  468. 			}

  469. 		}

  470. 		else

  471. 		{

  472. 			if (new_obj == NULL &&

  473. 			    !(step->length >= 4 &&

  474. 			      strncmp(step->string_to_parse, "null", 4) == 0))

  475. 				printf("ERROR: expected valid object, instead: %s\n",

  476. 				       json_tokener_error_desc(jerr));

  477. 			else if (json_tokener_get_parse_end(tok) != expected_char_offset)

  478. 				printf("ERROR: wrong char_offset %zu != expected %zu\n",

  479. 				       json_tokener_get_parse_end(tok),

  480. 				       expected_char_offset);

  481. 			else

  482. 			{

  483. 				printf("OK: got object of type [%s]: %s\n",

  484. 					json_type_to_name(json_object_get_type(new_obj)),

  485. 					json_object_to_json_string(new_obj));

  486. 				this_step_ok = 1;

  487. 			}

  488. 		}

  489. 

  490. 		if (new_obj)

  491. 			json_object_put(new_obj);

  492. 

  493. 		if (step->reset_tokener & 1)

  494. 			json_tokener_reset(tok);

  495. 

  496. 		if (this_step_ok)

  497. 			num_ok++;

  498. 		else

  499. 			num_error++;

  500. 	}

  501. 

  502. 	json_tokener_free(tok);

  503. 

  504. 	printf("End Incremental Tests OK=%d ERROR=%d\n", num_ok, num_error);

  505. }