source: trunk/libtransmission/json-test.c

Last change on this file was 14721, checked in by jordan, 5 years ago

fix a handful of minor compiler warnings, mostly in the unit tests, eg field width shortening or implicit signed/unsigned conversions

  • Property svn:keywords set to Date Rev Author Id
File size: 7.6 KB
Line 
1/*
2 * This file Copyright (C) 2013-2014 Mnemosyne LLC
3 *
4 * It may be used under the GNU GPL versions 2 or 3
5 * or any future license endorsed by Mnemosyne LLC.
6 *
7 * $Id: json-test.c 14721 2016-03-29 03:04:54Z mikedld $
8 */
9
10#include <string.h> /* strlen () */
11
12#include <locale.h> /* setlocale() */
13
14#define __LIBTRANSMISSION_VARIANT_MODULE__
15#include "transmission.h"
16#include "utils.h" /* tr_free */
17#include "variant.h"
18#include "variant-common.h"
19#include "libtransmission-test.h"
20
21static int
22test_elements (void)
23{
24    const char * in;
25    tr_variant top;
26    const char * str;
27    bool f;
28    double d;
29    int64_t i;
30    int err = 0;
31    tr_quark key;
32
33    in = "{ \"string\": \"hello world\","
34         \"escaped\": \"bell \\b formfeed \\f linefeed \\n carriage return \\r tab \\t\","
35         \"int\": 5, "
36         \"float\": 6.5, "
37         \"true\": true, "
38         \"false\": false, "
39         \"null\": null }";
40
41    err = tr_variantFromJson (&top, in, strlen(in));
42    check_int_eq (0, err);
43    check (tr_variantIsDict (&top));
44    str = NULL;
45    key = tr_quark_new ("string", 6);
46    check (tr_variantDictFindStr (&top, key, &str, NULL));
47    check_streq ("hello world", str);
48    check (tr_variantDictFindStr (&top, tr_quark_new("escaped",7), &str, NULL));
49    check_streq ("bell \b formfeed \f linefeed \n carriage return \r tab \t", str);
50    i = 0;
51    check (tr_variantDictFindInt (&top, tr_quark_new("int",3), &i));
52    check_int_eq (5, i);
53    d = 0;
54    check (tr_variantDictFindReal (&top, tr_quark_new("float",5), &d));
55    check_int_eq (65, ((int)(d*10)));
56    f = false;
57    check (tr_variantDictFindBool (&top, tr_quark_new("true",4), &f));
58    check_int_eq (true, f);
59    check (tr_variantDictFindBool (&top, tr_quark_new("false",5), &f));
60    check_int_eq (false, f);
61    check (tr_variantDictFindStr (&top, tr_quark_new("null",4), &str, NULL));
62    check_streq ("", str);
63
64    if (!err)
65        tr_variantFree (&top);
66
67    return 0;
68}
69static int
70test_utf8 (void)
71{
72    const char      * in = "{ \"key\": \"Letöltések\" }";
73    tr_variant           top;
74    const char      * str;
75    char            * json;
76    int               err;
77    const tr_quark key = tr_quark_new ("key", 3);
78
79    err = tr_variantFromJson (&top, in, strlen(in));
80    check (!err);
81    check (tr_variantIsDict (&top));
82    check (tr_variantDictFindStr (&top, key, &str, NULL));
83    check_streq ("Letöltések", str);
84    if (!err)
85        tr_variantFree (&top);
86
87    in = "{ \"key\": \"\\u005C\" }";
88    err = tr_variantFromJson (&top, in, strlen(in));
89    check (!err);
90    check (tr_variantIsDict (&top));
91    check (tr_variantDictFindStr (&top, key, &str, NULL));
92    check_streq ("\\", str);
93    if (!err)
94        tr_variantFree (&top);
95
96    /**
97     * 1. Feed it JSON-escaped nonascii to the JSON decoder.
98     * 2. Confirm that the result is UTF-8.
99     * 3. Feed the same UTF-8 back into the JSON encoder.
100     * 4. Confirm that the result is JSON-escaped.
101     * 5. Dogfood that result back into the parser.
102     * 6. Confirm that the result is UTF-8.
103     */
104    in = "{ \"key\": \"Let\\u00f6lt\\u00e9sek\" }";
105    err = tr_variantFromJson (&top, in, strlen(in));
106    check (!err);
107    check (tr_variantIsDict (&top));
108    check (tr_variantDictFindStr (&top, key, &str, NULL));
109    check_streq ("Letöltések", str);
110    json = tr_variantToStr (&top, TR_VARIANT_FMT_JSON, NULL);
111    if (!err)
112        tr_variantFree (&top);
113    check (json);
114    check (strstr (json, "\\u00f6") != NULL);
115    check (strstr (json, "\\u00e9") != NULL);
116    err = tr_variantFromJson (&top, json, strlen(json));
117    check (!err);
118    check (tr_variantIsDict (&top));
119    check (tr_variantDictFindStr (&top, key, &str, NULL));
120    check_streq ("Letöltések", str);
121    if (!err)
122        tr_variantFree (&top);
123    tr_free (json);
124
125    return 0;
126}
127
128static int
129test1 (void)
130{
131    const char * in =
132        "{\n"
133        "    \"headers\": {\n"
134        "        \"type\": \"request\",\n"
135        "        \"tag\": 666\n"
136        "    },\n"
137        "    \"body\": {\n"
138        "        \"name\": \"torrent-info\",\n"
139        "        \"arguments\": {\n"
140        "            \"ids\": [ 7, 10 ]\n"
141        "        }\n"
142        "    }\n"
143        "}\n";
144    tr_variant      top, *headers, *body, *args, *ids;
145    const char * str;
146    int64_t      i;
147    const int    err = tr_variantFromJson (&top, in, strlen(in));
148
149    check (!err);
150    check (tr_variantIsDict (&top));
151    check ((headers = tr_variantDictFind (&top, tr_quark_new("headers",7))));
152    check (tr_variantIsDict (headers));
153    check (tr_variantDictFindStr (headers, tr_quark_new("type",4), &str, NULL));
154    check_streq ("request", str);
155    check (tr_variantDictFindInt (headers, TR_KEY_tag, &i));
156    check_int_eq (666, i);
157    check ((body = tr_variantDictFind (&top, tr_quark_new("body",4))));
158    check (tr_variantDictFindStr (body, TR_KEY_name, &str, NULL));
159    check_streq ("torrent-info", str);
160    check ((args = tr_variantDictFind (body, tr_quark_new("arguments",9))));
161    check (tr_variantIsDict (args));
162    check ((ids = tr_variantDictFind (args, TR_KEY_ids)));
163    check (tr_variantIsList (ids));
164    check_uint_eq (2, tr_variantListSize (ids));
165    check (tr_variantGetInt (tr_variantListChild (ids, 0), &i));
166    check_int_eq (7, i);
167    check (tr_variantGetInt (tr_variantListChild (ids, 1), &i));
168    check_int_eq (10, i);
169
170    tr_variantFree (&top);
171    return 0;
172}
173
174static int
175test2 (void)
176{
177    tr_variant top;
178    const char * in = " ";
179    int err;
180
181    top.type = 0;
182    err = tr_variantFromJson (&top, in, strlen(in));
183
184    check (err);
185    check (!tr_variantIsDict (&top));
186
187    return 0;
188}
189
190static int
191test3 (void)
192{
193    const char * in = "{ \"error\": 2,"
194                      \"errorString\": \"torrent not registered with this tracker 6UHsVW'*C\","
195                      \"eta\": 262792,"
196                      \"id\": 25,"
197                      \"leftUntilDone\": 2275655680 }";
198    tr_variant top;
199    const char * str;
200
201    const int err = tr_variantFromJson (&top, in, strlen(in));
202    check (!err);
203    check (tr_variantDictFindStr (&top, TR_KEY_errorString, &str, NULL));
204    check_streq ("torrent not registered with this tracker 6UHsVW'*C", str);
205
206    tr_variantFree (&top);
207    return 0;
208}
209
210static int
211test_unescape (void)
212{
213    const char * in = "{ \"string-1\": \"\\/usr\\/lib\" }";
214    tr_variant top;
215    const char * str;
216
217    const int err = tr_variantFromJson (&top, in, strlen(in));
218    check_int_eq (0, err);
219    check (tr_variantDictFindStr (&top, tr_quark_new("string-1",8), &str, NULL));
220    check_streq ("/usr/lib", str);
221
222    tr_variantFree (&top);
223    return 0;
224}
225
226int
227main (void)
228{
229  int i;
230  int n;
231  int rv;
232
233  const char * comma_locales[] = { "da_DK.UTF-8",
234                                   "fr_FR.UTF-8",
235                                   "ru_RU.UTF-8"};
236
237  const testFunc tests[] = { test_elements,
238                             test_utf8,
239                             test1,
240                             test2,
241                             test3,
242                             test_unescape };
243
244  /* run the tests in a locale with a decimal point of '.' */
245  setlocale (LC_NUMERIC, "C");
246  if ((rv = runTests (tests, NUM_TESTS (tests))))
247    return rv;
248
249  /* run the tests in a locale with a decimal point of ',' */
250  n = sizeof(comma_locales) / sizeof(comma_locales[0]);
251  for (i=0; i<n; ++i)
252    if (setlocale (LC_NUMERIC, comma_locales[i]) != NULL)
253      break;
254  if (i==n)
255    fprintf (stderr, "WARNING: unable to run locale-specific json tests. add a locale like %s or %s\n",
256             comma_locales[0],
257             comma_locales[1]);
258  else if ((rv = runTests (tests, NUM_TESTS(tests))))
259    return rv;
260
261  /* success */
262  return 0;
263}
Note: See TracBrowser for help on using the repository browser.