git.oblomov.eu Git - git/blob - t/helper/test-json-writer.c

   1 #include "test-tool.h"
   2 #include "cache.h"
   3 #include "json-writer.h"
   4
   5 static const char *expect_obj1 = "{\"a\":\"abc\",\"b\":42,\"c\":true}";
   6 static const char *expect_obj2 = "{\"a\":-1,\"b\":2147483647,\"c\":0}";
   7 static const char *expect_obj3 = "{\"a\":0,\"b\":4294967295,\"c\":9223372036854775807}";
   8 static const char *expect_obj4 = "{\"t\":true,\"f\":false,\"n\":null}";
   9 static const char *expect_obj5 = "{\"abc\\tdef\":\"abc\\\\def\"}";
  10 static const char *expect_obj6 = "{\"a\":3.14}";
  11
  12 static const char *pretty_obj1 = ("{\n"
  13                                   "  \"a\": \"abc\",\n"
  14                                   "  \"b\": 42,\n"
  15                                   "  \"c\": true\n"
  16                                   "}");
  17 static const char *pretty_obj2 = ("{\n"
  18                                   "  \"a\": -1,\n"
  19                                   "  \"b\": 2147483647,\n"
  20                                   "  \"c\": 0\n"
  21                                   "}");
  22 static const char *pretty_obj3 = ("{\n"
  23                                   "  \"a\": 0,\n"
  24                                   "  \"b\": 4294967295,\n"
  25                                   "  \"c\": 9223372036854775807\n"
  26                                   "}");
  27 static const char *pretty_obj4 = ("{\n"
  28                                   "  \"t\": true,\n"
  29                                   "  \"f\": false,\n"
  30                                   "  \"n\": null\n"
  31                                   "}");
  32
  33 static struct json_writer obj1 = JSON_WRITER_INIT;
  34 static struct json_writer obj2 = JSON_WRITER_INIT;
  35 static struct json_writer obj3 = JSON_WRITER_INIT;
  36 static struct json_writer obj4 = JSON_WRITER_INIT;
  37 static struct json_writer obj5 = JSON_WRITER_INIT;
  38 static struct json_writer obj6 = JSON_WRITER_INIT;
  39
  40 static void make_obj1(int pretty)
  41 {
  42         jw_object_begin(&obj1, pretty);
  43         {
  44                 jw_object_string(&obj1, "a", "abc");
  45                 jw_object_intmax(&obj1, "b", 42);
  46                 jw_object_true(&obj1, "c");
  47         }
  48         jw_end(&obj1);
  49 }
  50
  51 static void make_obj2(int pretty)
  52 {
  53         jw_object_begin(&obj2, pretty);
  54         {
  55                 jw_object_intmax(&obj2, "a", -1);
  56                 jw_object_intmax(&obj2, "b", 0x7fffffff);
  57                 jw_object_intmax(&obj2, "c", 0);
  58         }
  59         jw_end(&obj2);
  60 }
  61
  62 static void make_obj3(int pretty)
  63 {
  64         jw_object_begin(&obj3, pretty);
  65         {
  66                 jw_object_intmax(&obj3, "a", 0);
  67                 jw_object_intmax(&obj3, "b", 0xffffffff);
  68                 jw_object_intmax(&obj3, "c", 0x7fffffffffffffffULL);
  69         }
  70         jw_end(&obj3);
  71 }
  72
  73 static void make_obj4(int pretty)
  74 {
  75         jw_object_begin(&obj4, pretty);
  76         {
  77                 jw_object_true(&obj4, "t");
  78                 jw_object_false(&obj4, "f");
  79                 jw_object_null(&obj4, "n");
  80         }
  81         jw_end(&obj4);
  82 }
  83
  84 static void make_obj5(int pretty)
  85 {
  86         jw_object_begin(&obj5, pretty);
  87         {
  88                 jw_object_string(&obj5, "abc" "\x09" "def", "abc" "\\" "def");
  89         }
  90         jw_end(&obj5);
  91 }
  92
  93 static void make_obj6(int pretty)
  94 {
  95         jw_object_begin(&obj6, pretty);
  96         {
  97                 jw_object_double(&obj6, "a", 2, 3.14159);
  98         }
  99         jw_end(&obj6);
 100 }
 101
 102 static const char *expect_arr1 = "[\"abc\",42,true]";
 103 static const char *expect_arr2 = "[-1,2147483647,0]";
 104 static const char *expect_arr3 = "[0,4294967295,9223372036854775807]";
 105 static const char *expect_arr4 = "[true,false,null]";
 106
 107 static const char *pretty_arr1 = ("[\n"
 108                                   "  \"abc\",\n"
 109                                   "  42,\n"
 110                                   "  true\n"
 111                                   "]");
 112 static const char *pretty_arr2 = ("[\n"
 113                                   "  -1,\n"
 114                                   "  2147483647,\n"
 115                                   "  0\n"
 116                                   "]");
 117 static const char *pretty_arr3 = ("[\n"
 118                                   "  0,\n"
 119                                   "  4294967295,\n"
 120                                   "  9223372036854775807\n"
 121                                   "]");
 122 static const char *pretty_arr4 = ("[\n"
 123                                   "  true,\n"
 124                                   "  false,\n"
 125                                   "  null\n"
 126                                   "]");
 127
 128 static struct json_writer arr1 = JSON_WRITER_INIT;
 129 static struct json_writer arr2 = JSON_WRITER_INIT;
 130 static struct json_writer arr3 = JSON_WRITER_INIT;
 131 static struct json_writer arr4 = JSON_WRITER_INIT;
 132
 133 static void make_arr1(int pretty)
 134 {
 135         jw_array_begin(&arr1, pretty);
 136         {
 137                 jw_array_string(&arr1, "abc");
 138                 jw_array_intmax(&arr1, 42);
 139                 jw_array_true(&arr1);
 140         }
 141         jw_end(&arr1);
 142 }
 143
 144 static void make_arr2(int pretty)
 145 {
 146         jw_array_begin(&arr2, pretty);
 147         {
 148                 jw_array_intmax(&arr2, -1);
 149                 jw_array_intmax(&arr2, 0x7fffffff);
 150                 jw_array_intmax(&arr2, 0);
 151         }
 152         jw_end(&arr2);
 153 }
 154
 155 static void make_arr3(int pretty)
 156 {
 157         jw_array_begin(&arr3, pretty);
 158         {
 159                 jw_array_intmax(&arr3, 0);
 160                 jw_array_intmax(&arr3, 0xffffffff);
 161                 jw_array_intmax(&arr3, 0x7fffffffffffffffULL);
 162         }
 163         jw_end(&arr3);
 164 }
 165
 166 static void make_arr4(int pretty)
 167 {
 168         jw_array_begin(&arr4, pretty);
 169         {
 170                 jw_array_true(&arr4);
 171                 jw_array_false(&arr4);
 172                 jw_array_null(&arr4);
 173         }
 174         jw_end(&arr4);
 175 }
 176
 177 static char *expect_nest1 =
 178         "{\"obj1\":{\"a\":\"abc\",\"b\":42,\"c\":true},\"arr1\":[\"abc\",42,true]}";
 179
 180 static struct json_writer nest1 = JSON_WRITER_INIT;
 181
 182 static void make_nest1(int pretty)
 183 {
 184         jw_object_begin(&nest1, pretty);
 185         {
 186                 jw_object_sub_jw(&nest1, "obj1", &obj1);
 187                 jw_object_sub_jw(&nest1, "arr1", &arr1);
 188         }
 189         jw_end(&nest1);
 190 }
 191
 192 static char *expect_inline1 =
 193         "{\"obj1\":{\"a\":\"abc\",\"b\":42,\"c\":true},\"arr1\":[\"abc\",42,true]}";
 194
 195 static char *pretty_inline1 =
 196         ("{\n"
 197          "  \"obj1\": {\n"
 198          "    \"a\": \"abc\",\n"
 199          "    \"b\": 42,\n"
 200          "    \"c\": true\n"
 201          "  },\n"
 202          "  \"arr1\": [\n"
 203          "    \"abc\",\n"
 204          "    42,\n"
 205          "    true\n"
 206          "  ]\n"
 207          "}");
 208
 209 static struct json_writer inline1 = JSON_WRITER_INIT;
 210
 211 static void make_inline1(int pretty)
 212 {
 213         jw_object_begin(&inline1, pretty);
 214         {
 215                 jw_object_inline_begin_object(&inline1, "obj1");
 216                 {
 217                         jw_object_string(&inline1, "a", "abc");
 218                         jw_object_intmax(&inline1, "b", 42);
 219                         jw_object_true(&inline1, "c");
 220                 }
 221                 jw_end(&inline1);
 222                 jw_object_inline_begin_array(&inline1, "arr1");
 223                 {
 224                         jw_array_string(&inline1, "abc");
 225                         jw_array_intmax(&inline1, 42);
 226                         jw_array_true(&inline1);
 227                 }
 228                 jw_end(&inline1);
 229         }
 230         jw_end(&inline1);
 231 }
 232
 233 static char *expect_inline2 =
 234         "[[1,2],[3,4],{\"a\":\"abc\"}]";
 235
 236 static char *pretty_inline2 =
 237         ("[\n"
 238          "  [\n"
 239          "    1,\n"
 240          "    2\n"
 241          "  ],\n"
 242          "  [\n"
 243          "    3,\n"
 244          "    4\n"
 245          "  ],\n"
 246          "  {\n"
 247          "    \"a\": \"abc\"\n"
 248          "  }\n"
 249          "]");
 250
 251 static struct json_writer inline2 = JSON_WRITER_INIT;
 252
 253 static void make_inline2(int pretty)
 254 {
 255         jw_array_begin(&inline2, pretty);
 256         {
 257                 jw_array_inline_begin_array(&inline2);
 258                 {
 259                         jw_array_intmax(&inline2, 1);
 260                         jw_array_intmax(&inline2, 2);
 261                 }
 262                 jw_end(&inline2);
 263                 jw_array_inline_begin_array(&inline2);
 264                 {
 265                         jw_array_intmax(&inline2, 3);
 266                         jw_array_intmax(&inline2, 4);
 267                 }
 268                 jw_end(&inline2);
 269                 jw_array_inline_begin_object(&inline2);
 270                 {
 271                         jw_object_string(&inline2, "a", "abc");
 272                 }
 273                 jw_end(&inline2);
 274         }
 275         jw_end(&inline2);
 276 }
 277
 278 /*
 279  * When super is compact, we expect subs to be compacted (even if originally
 280  * pretty).
 281  */
 282 static const char *expect_mixed1 =
 283         ("{\"obj1\":{\"a\":\"abc\",\"b\":42,\"c\":true},"
 284          "\"arr1\":[\"abc\",42,true]}");
 285
 286 /*
 287  * When super is pretty, a compact sub (obj1) is kept compact and a pretty
 288  * sub (arr1) is re-indented.
 289  */
 290 static const char *pretty_mixed1 =
 291         ("{\n"
 292          "  \"obj1\": {\"a\":\"abc\",\"b\":42,\"c\":true},\n"
 293          "  \"arr1\": [\n"
 294          "    \"abc\",\n"
 295          "    42,\n"
 296          "    true\n"
 297          "  ]\n"
 298          "}");
 299
 300 static struct json_writer mixed1 = JSON_WRITER_INIT;
 301
 302 static void make_mixed1(int pretty)
 303 {
 304         jw_init(&obj1);
 305         jw_init(&arr1);
 306
 307         make_obj1(0); /* obj1 is compact */
 308         make_arr1(1); /* arr1 is pretty */
 309
 310         jw_object_begin(&mixed1, pretty);
 311         {
 312                 jw_object_sub_jw(&mixed1, "obj1", &obj1);
 313                 jw_object_sub_jw(&mixed1, "arr1", &arr1);
 314         }
 315         jw_end(&mixed1);
 316 }
 317
 318 static void cmp(const char *test, const struct json_writer *jw, const char *exp)
 319 {
 320         if (!strcmp(jw->json.buf, exp))
 321                 return;
 322
 323         printf("error[%s]: observed '%s' expected '%s'\n",
 324                test, jw->json.buf, exp);
 325         exit(1);
 326 }
 327
 328 #define t(v) do { make_##v(0); cmp(#v, &v, expect_##v); } while (0)
 329 #define p(v) do { make_##v(1); cmp(#v, &v, pretty_##v); } while (0)
 330
 331 /*
 332  * Run some basic regression tests with some known patterns.
 333  * These tests also demonstrate how to use the jw_ API.
 334  */
 335 static int unit_tests(void)
 336 {
 337         /* comptact (canonical) forms */
 338         t(obj1);
 339         t(obj2);
 340         t(obj3);
 341         t(obj4);
 342         t(obj5);
 343         t(obj6);
 344
 345         t(arr1);
 346         t(arr2);
 347         t(arr3);
 348         t(arr4);
 349
 350         t(nest1);
 351
 352         t(inline1);
 353         t(inline2);
 354
 355         jw_init(&obj1);
 356         jw_init(&obj2);
 357         jw_init(&obj3);
 358         jw_init(&obj4);
 359
 360         jw_init(&arr1);
 361         jw_init(&arr2);
 362         jw_init(&arr3);
 363         jw_init(&arr4);
 364
 365         jw_init(&inline1);
 366         jw_init(&inline2);
 367
 368         /* pretty forms */
 369         p(obj1);
 370         p(obj2);
 371         p(obj3);
 372         p(obj4);
 373
 374         p(arr1);
 375         p(arr2);
 376         p(arr3);
 377         p(arr4);
 378
 379         p(inline1);
 380         p(inline2);
 381
 382         /* mixed forms */
 383         t(mixed1);
 384         jw_init(&mixed1);
 385         p(mixed1);
 386
 387         return 0;
 388 }
 389
 390 static void get_s(int line_nr, char **s_in)
 391 {
 392         *s_in = strtok(NULL, " ");
 393         if (!*s_in)
 394                 die("line[%d]: expected: <s>", line_nr);
 395 }
 396
 397 static void get_i(int line_nr, intmax_t *s_in)
 398 {
 399         char *s;
 400         char *endptr;
 401
 402         get_s(line_nr, &s);
 403
 404         *s_in = strtol(s, &endptr, 10);
 405         if (*endptr || errno == ERANGE)
 406                 die("line[%d]: invalid integer value", line_nr);
 407 }
 408
 409 static void get_d(int line_nr, double *s_in)
 410 {
 411         char *s;
 412         char *endptr;
 413
 414         get_s(line_nr, &s);
 415
 416         *s_in = strtod(s, &endptr);
 417         if (*endptr || errno == ERANGE)
 418                 die("line[%d]: invalid float value", line_nr);
 419 }
 420
 421 static int pretty;
 422
 423 #define MAX_LINE_LENGTH (64 * 1024)
 424
 425 static char *get_trimmed_line(char *buf, int buf_size)
 426 {
 427         int len;
 428
 429         if (!fgets(buf, buf_size, stdin))
 430                 return NULL;
 431
 432         len = strlen(buf);
 433         while (len > 0) {
 434                 char c = buf[len - 1];
 435                 if (c == '\n' || c == '\r' || c == ' ' || c == '\t')
 436                         buf[--len] = 0;
 437                 else
 438                         break;
 439         }
 440
 441         while (*buf == ' ' || *buf == '\t')
 442                 buf++;
 443
 444         return buf;
 445 }
 446
 447 static int scripted(void)
 448 {
 449         struct json_writer jw = JSON_WRITER_INIT;
 450         char buf[MAX_LINE_LENGTH];
 451         char *line;
 452         int line_nr = 0;
 453
 454         line = get_trimmed_line(buf, MAX_LINE_LENGTH);
 455         if (!line)
 456                 return 0;
 457
 458         if (!strcmp(line, "object"))
 459                 jw_object_begin(&jw, pretty);
 460         else if (!strcmp(line, "array"))
 461                 jw_array_begin(&jw, pretty);
 462         else
 463                 die("expected first line to be 'object' or 'array'");
 464
 465         while ((line = get_trimmed_line(buf, MAX_LINE_LENGTH)) != NULL) {
 466                 char *verb;
 467                 char *key;
 468                 char *s_value;
 469                 intmax_t i_value;
 470                 double d_value;
 471
 472                 line_nr++;
 473
 474                 verb = strtok(line, " ");
 475
 476                 if (!strcmp(verb, "end")) {
 477                         jw_end(&jw);
 478                 }
 479                 else if (!strcmp(verb, "object-string")) {
 480                         get_s(line_nr, &key);
 481                         get_s(line_nr, &s_value);
 482                         jw_object_string(&jw, key, s_value);
 483                 }
 484                 else if (!strcmp(verb, "object-int")) {
 485                         get_s(line_nr, &key);
 486                         get_i(line_nr, &i_value);
 487                         jw_object_intmax(&jw, key, i_value);
 488                 }
 489                 else if (!strcmp(verb, "object-double")) {
 490                         get_s(line_nr, &key);
 491                         get_i(line_nr, &i_value);
 492                         get_d(line_nr, &d_value);
 493                         jw_object_double(&jw, key, i_value, d_value);
 494                 }
 495                 else if (!strcmp(verb, "object-true")) {
 496                         get_s(line_nr, &key);
 497                         jw_object_true(&jw, key);
 498                 }
 499                 else if (!strcmp(verb, "object-false")) {
 500                         get_s(line_nr, &key);
 501                         jw_object_false(&jw, key);
 502                 }
 503                 else if (!strcmp(verb, "object-null")) {
 504                         get_s(line_nr, &key);
 505                         jw_object_null(&jw, key);
 506                 }
 507                 else if (!strcmp(verb, "object-object")) {
 508                         get_s(line_nr, &key);
 509                         jw_object_inline_begin_object(&jw, key);
 510                 }
 511                 else if (!strcmp(verb, "object-array")) {
 512                         get_s(line_nr, &key);
 513                         jw_object_inline_begin_array(&jw, key);
 514                 }
 515                 else if (!strcmp(verb, "array-string")) {
 516                         get_s(line_nr, &s_value);
 517                         jw_array_string(&jw, s_value);
 518                 }
 519                 else if (!strcmp(verb, "array-int")) {
 520                         get_i(line_nr, &i_value);
 521                         jw_array_intmax(&jw, i_value);
 522                 }
 523                 else if (!strcmp(verb, "array-double")) {
 524                         get_i(line_nr, &i_value);
 525                         get_d(line_nr, &d_value);
 526                         jw_array_double(&jw, i_value, d_value);
 527                 }
 528                 else if (!strcmp(verb, "array-true"))
 529                         jw_array_true(&jw);
 530                 else if (!strcmp(verb, "array-false"))
 531                         jw_array_false(&jw);
 532                 else if (!strcmp(verb, "array-null"))
 533                         jw_array_null(&jw);
 534                 else if (!strcmp(verb, "array-object"))
 535                         jw_array_inline_begin_object(&jw);
 536                 else if (!strcmp(verb, "array-array"))
 537                         jw_array_inline_begin_array(&jw);
 538                 else
 539                         die("unrecognized token: '%s'", verb);
 540         }
 541
 542         if (!jw_is_terminated(&jw))
 543                 die("json not terminated: '%s'", jw.json.buf);
 544
 545         printf("%s\n", jw.json.buf);
 546
 547         strbuf_release(&jw.json);
 548         return 0;
 549 }
 550
 551 int cmd__json_writer(int argc, const char **argv)
 552 {
 553         argc--; /* skip over "json-writer" arg */
 554         argv++;
 555
 556         if (argc > 0 && argv[0][0] == '-') {
 557                 if (!strcmp(argv[0], "-u") || !strcmp(argv[0], "--unit"))
 558                         return unit_tests();
 559
 560                 if (!strcmp(argv[0], "-p") || !strcmp(argv[0], "--pretty"))
 561                         pretty = 1;
 562         }
 563
 564         return scripted();
 565 }