|
1 /* This file is part of QJson |
|
2 * |
|
3 * Copyright (C) 2008 Flavio Castelli <flavio.castelli@gmail.com> |
|
4 * |
|
5 * This library is free software; you can redistribute it and/or |
|
6 * modify it under the terms of the GNU Library General Public |
|
7 * License as published by the Free Software Foundation; either |
|
8 * version 2 of the License, or (at your option) any later version. |
|
9 * |
|
10 * This library is distributed in the hope that it will be useful, |
|
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
13 * Library General Public License for more details. |
|
14 * |
|
15 * You should have received a copy of the GNU Library General Public License |
|
16 * along with this library; see the file COPYING.LIB. If not, write to |
|
17 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
|
18 * Boston, MA 02110-1301, USA. |
|
19 */ |
|
20 |
|
21 #include <QtTest/QtTest> |
|
22 |
|
23 #include "parser.h" |
|
24 |
|
25 #include <QtCore/QVariant> |
|
26 |
|
27 class TestParser: public QObject |
|
28 { |
|
29 Q_OBJECT |
|
30 private slots: |
|
31 void parseNonAsciiString(); |
|
32 void parseSimpleObject(); |
|
33 void parseEmptyObject(); |
|
34 void parseEmptyValue(); |
|
35 void parseUrl(); |
|
36 void parseMultipleObject(); |
|
37 |
|
38 void parseSimpleArray(); |
|
39 void parseInvalidObject(); |
|
40 void parseMultipleArray(); |
|
41 |
|
42 void testTrueFalseNullValues(); |
|
43 void testEscapeChars(); |
|
44 void testNumbers(); |
|
45 void testNumbers_data(); |
|
46 }; |
|
47 |
|
48 Q_DECLARE_METATYPE(QVariant) |
|
49 Q_DECLARE_METATYPE(QVariant::Type) |
|
50 |
|
51 using namespace QJson; |
|
52 |
|
53 void TestParser::parseSimpleObject() { |
|
54 QByteArray json = "{\"foo\":\"bar\"}"; |
|
55 QVariantMap map; |
|
56 map.insert (QLatin1String("foo"), QLatin1String("bar")); |
|
57 QVariant expected(map); |
|
58 |
|
59 Parser parser; |
|
60 bool ok; |
|
61 QVariant result = parser.parse (json, &ok); |
|
62 QVERIFY (ok); |
|
63 QCOMPARE(result, expected); |
|
64 } |
|
65 |
|
66 void TestParser::parseEmptyObject() { |
|
67 QByteArray json = "{}"; |
|
68 QVariantMap map; |
|
69 QVariant expected (map); |
|
70 |
|
71 Parser parser; |
|
72 bool ok; |
|
73 QVariant result = parser.parse (json, &ok); |
|
74 QVERIFY (ok); |
|
75 QCOMPARE(result, expected); |
|
76 } |
|
77 |
|
78 void TestParser::parseEmptyValue() { |
|
79 QByteArray json = "{\"value\": \"\"}"; |
|
80 |
|
81 QVariantMap map; |
|
82 map.insert (QLatin1String("value"), QString(QLatin1String(""))); |
|
83 QVariant expected (map); |
|
84 |
|
85 Parser parser; |
|
86 bool ok; |
|
87 QVariant result = parser.parse (json, &ok); |
|
88 QVERIFY (ok); |
|
89 QCOMPARE(result, expected); |
|
90 QVERIFY (result.toMap().value(QLatin1String("value")).type() == QVariant::String); |
|
91 |
|
92 QString value = result.toMap().value(QLatin1String("value")).toString(); |
|
93 QVERIFY (value.isEmpty()); |
|
94 } |
|
95 |
|
96 void TestParser::parseInvalidObject() { |
|
97 QByteArray json = "{\"foo\":\"bar\""; |
|
98 |
|
99 Parser parser; |
|
100 bool ok; |
|
101 QVariant result = parser.parse (json, &ok); |
|
102 QVERIFY (!ok); |
|
103 } |
|
104 |
|
105 void TestParser::parseNonAsciiString() { |
|
106 QByteArray json = "{\"artist\":\"Queensr\\u00ffche\"}"; |
|
107 QVariantMap map; |
|
108 |
|
109 QChar unicode_char (0x00ff); |
|
110 QString unicode_string; |
|
111 unicode_string.setUnicode(&unicode_char, 1); |
|
112 unicode_string = QLatin1String("Queensr") + unicode_string + QLatin1String("che"); |
|
113 |
|
114 map.insert (QLatin1String("artist"), unicode_string); |
|
115 QVariant expected (map); |
|
116 |
|
117 Parser parser; |
|
118 bool ok; |
|
119 QVariant result = parser.parse (json, &ok); |
|
120 QVERIFY (ok); |
|
121 QCOMPARE(result, expected); |
|
122 } |
|
123 |
|
124 void TestParser::parseMultipleObject() { |
|
125 //put also some extra spaces inside the json string |
|
126 QByteArray json = "{ \"foo\":\"bar\",\n\"number\" : 51.3 , \"array\":[\"item1\", 123]}"; |
|
127 QVariantMap map; |
|
128 map.insert (QLatin1String("foo"), QLatin1String("bar")); |
|
129 map.insert (QLatin1String("number"), 51.3); |
|
130 QVariantList list; |
|
131 list.append (QLatin1String("item1")); |
|
132 list.append (QLatin1String("123")); |
|
133 map.insert (QLatin1String("array"), list); |
|
134 QVariant expected (map); |
|
135 |
|
136 Parser parser; |
|
137 bool ok; |
|
138 QVariant result = parser.parse (json, &ok); |
|
139 QVERIFY (ok); |
|
140 QCOMPARE(result, expected); |
|
141 QVERIFY (result.toMap().value(QLatin1String("number")).canConvert<float>()); |
|
142 QVERIFY (result.toMap().value(QLatin1String("array")).canConvert<QVariantList>()); |
|
143 } |
|
144 |
|
145 void TestParser::parseUrl(){ |
|
146 //"http:\/\/www.last.fm\/venue\/8926427" |
|
147 QByteArray json = "[\"http:\\/\\/www.last.fm\\/venue\\/8926427\"]"; |
|
148 QVariantList list; |
|
149 list.append (QVariant(QLatin1String("http://www.last.fm/venue/8926427"))); |
|
150 QVariant expected (list); |
|
151 |
|
152 Parser parser; |
|
153 bool ok; |
|
154 QVariant result = parser.parse (json, &ok); |
|
155 QVERIFY (ok); |
|
156 QCOMPARE(result, expected); |
|
157 } |
|
158 |
|
159 void TestParser::parseSimpleArray() { |
|
160 QByteArray json = "[\"foo\",\"bar\"]"; |
|
161 QVariantList list; |
|
162 list.append (QLatin1String("foo")); |
|
163 list.append (QLatin1String("bar")); |
|
164 QVariant expected (list); |
|
165 |
|
166 Parser parser; |
|
167 bool ok; |
|
168 QVariant result = parser.parse (json, &ok); |
|
169 QVERIFY (ok); |
|
170 QCOMPARE(result, expected); |
|
171 } |
|
172 |
|
173 void TestParser::parseMultipleArray() { |
|
174 //put also some extra spaces inside the json string |
|
175 QByteArray json = "[ {\"foo\":\"bar\"},\n\"number\",51.3 , [\"item1\", 123]]"; |
|
176 QVariantMap map; |
|
177 map.insert (QLatin1String("foo"), QLatin1String("bar")); |
|
178 |
|
179 QVariantList array; |
|
180 array.append (QLatin1String("item1")); |
|
181 array.append (123); |
|
182 |
|
183 QVariantList list; |
|
184 list.append (map); |
|
185 list.append (QLatin1String("number")); |
|
186 list.append (QLatin1String("51.3")); |
|
187 list.append ((QVariant) array); |
|
188 |
|
189 QVariant expected (list); |
|
190 |
|
191 Parser parser; |
|
192 bool ok; |
|
193 QVariant result = parser.parse (json, &ok); |
|
194 QVERIFY (ok); |
|
195 QCOMPARE(result, expected); |
|
196 } |
|
197 |
|
198 void TestParser::testTrueFalseNullValues() { |
|
199 QByteArray json = "[true,false, null, {\"foo\" : true}]"; |
|
200 QVariantList list; |
|
201 list.append (QVariant(true)); |
|
202 list.append (QVariant(false)); |
|
203 list.append (QVariant()); |
|
204 QVariantMap map; |
|
205 map.insert (QLatin1String("foo"), true); |
|
206 list.append (map); |
|
207 QVariant expected (list); |
|
208 |
|
209 Parser parser; |
|
210 bool ok; |
|
211 QVariant result = parser.parse (json, &ok); |
|
212 QVERIFY (ok); |
|
213 QCOMPARE(result, expected); |
|
214 QCOMPARE (result.toList().at(0).toBool(), true); |
|
215 QCOMPARE (result.toList().at(1).toBool(), false); |
|
216 QVERIFY (result.toList().at(2).isNull()); |
|
217 } |
|
218 |
|
219 void TestParser::testEscapeChars() { |
|
220 QByteArray json = "[\"\\b \\f \\n \\r \\t \", \" \\\\ \\/ \\\\\", \"http:\\/\\/foo.com\"]"; |
|
221 |
|
222 QVariantList list; |
|
223 list.append (QLatin1String("\b \f \n \r \t ")); |
|
224 list.append (QLatin1String(" \\ / \\")); |
|
225 list.append (QLatin1String("http://foo.com")); |
|
226 |
|
227 QVariant expected (list); |
|
228 |
|
229 Parser parser; |
|
230 bool ok; |
|
231 QVariant result = parser.parse (json, &ok); |
|
232 QVERIFY (ok); |
|
233 QCOMPARE(result.toList().size(), expected.toList().size() ); |
|
234 QCOMPARE(result, expected); |
|
235 } |
|
236 |
|
237 void TestParser::testNumbers() { |
|
238 QFETCH(QByteArray, input); |
|
239 QFETCH(QVariant, expected); |
|
240 QFETCH(QVariant::Type, type); |
|
241 |
|
242 Parser parser; |
|
243 bool ok; |
|
244 QVariant result = parser.parse ("[" + input +"]", &ok); |
|
245 QVERIFY (ok); |
|
246 |
|
247 QVariant value = result.toList().at(0); |
|
248 QCOMPARE(value, expected); |
|
249 QCOMPARE( value.type(), type); |
|
250 } |
|
251 |
|
252 void TestParser::testNumbers_data() { |
|
253 QTest::addColumn<QByteArray>( "input" ); |
|
254 QTest::addColumn<QVariant>( "expected" ); |
|
255 QTest::addColumn<QVariant::Type>( "type" ); |
|
256 |
|
257 QByteArray input; |
|
258 QVariant output; |
|
259 |
|
260 // simple ulonglong |
|
261 input = QByteArray("1"); |
|
262 output = QVariant(QVariant::ULongLong); |
|
263 output.setValue(1); |
|
264 |
|
265 QTest::newRow("simple ulonglong") << input << output << QVariant::ULongLong; |
|
266 |
|
267 // big number |
|
268 input = QByteArray("128708157440"); |
|
269 output = QVariant(QVariant::ULongLong); |
|
270 output.setValue(128708157440ull); |
|
271 |
|
272 QTest::newRow("big number") << input << output << QVariant::ULongLong; |
|
273 |
|
274 // simple double |
|
275 input = QByteArray("2.4"); |
|
276 output = QVariant(QVariant::Double); |
|
277 output.setValue(2.4); |
|
278 |
|
279 QTest::newRow("simple double") << input << output << QVariant::Double; |
|
280 |
|
281 // negative int |
|
282 input = QByteArray("-100"); |
|
283 output = QVariant(QVariant::LongLong); |
|
284 output.setValue(-100); |
|
285 |
|
286 QTest::newRow("negative int") << input << output << QVariant::LongLong; |
|
287 |
|
288 // negative double |
|
289 input = QByteArray("-3.4"); |
|
290 output = QVariant(QVariant::Double); |
|
291 output.setValue(-3.4); |
|
292 |
|
293 QTest::newRow("negative double") << input << output << QVariant::Double; |
|
294 |
|
295 // exp1 |
|
296 input = QByteArray("-5e+"); |
|
297 output = QVariant(QVariant::ByteArray); |
|
298 output.setValue(input); |
|
299 |
|
300 QTest::newRow("exp1") << input << output << QVariant::ByteArray; |
|
301 |
|
302 // exp2 |
|
303 input = QByteArray("2e"); |
|
304 output = QVariant(QVariant::ByteArray); |
|
305 output.setValue(input); |
|
306 |
|
307 QTest::newRow("exp2") << input << output << QVariant::ByteArray; |
|
308 |
|
309 // exp3 |
|
310 input = QByteArray("3e+"); |
|
311 output = QVariant(QVariant::ByteArray); |
|
312 output.setValue(input); |
|
313 |
|
314 QTest::newRow("exp3") << input << output << QVariant::ByteArray; |
|
315 |
|
316 // exp4 |
|
317 input = QByteArray("4.3E"); |
|
318 output = QVariant(QVariant::ByteArray); |
|
319 output.setValue(input); |
|
320 |
|
321 QTest::newRow("exp4") << input << output << QVariant::ByteArray; |
|
322 |
|
323 // exp5 |
|
324 input = QByteArray("5.4E-"); |
|
325 output = QVariant(QVariant::ByteArray); |
|
326 output.setValue(input); |
|
327 |
|
328 QTest::newRow("exp5") << input << output << QVariant::ByteArray; |
|
329 } |
|
330 |
|
331 QTEST_MAIN(TestParser) |
|
332 #include "moc_testparser.cxx" |