VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstRTCRest-1.cpp@ 75034

Last change on this file since 75034 was 75034, checked in by vboxsync, 7 years ago

tstRTCRest: no change.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 100.8 KB
Line 
1/* $Id: tstRTCRest-1.cpp 75034 2018-10-24 12:18:51Z vboxsync $ */
2/** @file
3 * IPRT Testcase - REST C++ classes.
4 */
5
6/*
7 * Copyright (C) 2018 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#include <iprt/cpp/restbase.h>
32#include <iprt/cpp/restarray.h>
33#include <iprt/cpp/reststringmap.h>
34#include <iprt/cpp/restclient.h>
35#include <iprt/cpp/restoutput.h>
36
37#include <iprt/ctype.h>
38#include <iprt/err.h>
39#include <iprt/message.h>
40#include <iprt/string.h>
41#include <iprt/test.h>
42
43
44/*********************************************************************************************************************************
45* Global Variables *
46*********************************************************************************************************************************/
47static RTTEST g_hTest;
48
49
50static char *toJson(RTCRestObjectBase const *pObj)
51{
52 RTCString str;
53 RTCRestOutputToString Dst(&str, false);
54 pObj->serializeAsJson(Dst);
55
56 static char s_szReturnBuffer[4096];
57 RTStrCopy(s_szReturnBuffer, sizeof(s_szReturnBuffer), str.c_str());
58 return s_szReturnBuffer;
59}
60
61
62static int deserializeFromJson(RTCRestObjectBase *pObj, const char *pszJson, PRTERRINFOSTATIC pErrInfo, const char *pszName)
63{
64 RTJSONVAL hValue;
65 RTTESTI_CHECK_RC_OK_RET(RTJsonParseFromString(&hValue, pszJson, pErrInfo ? RTErrInfoInitStatic(pErrInfo) : NULL), rcCheck);
66 RTCRestJsonPrimaryCursor Cursor(hValue, pszName, pErrInfo ? RTErrInfoInitStatic(pErrInfo) : NULL);
67 return pObj->deserializeFromJson(Cursor.m_Cursor);
68}
69
70
71static int fromString(RTCRestObjectBase *pObj, const char *pszString, PRTERRINFOSTATIC pErrInfo, const char *pszName)
72{
73 RTCString strValue(pszString);
74 return pObj->fromString(strValue, pszName, pErrInfo ? RTErrInfoInitStatic(pErrInfo) : NULL);
75}
76
77
78static void testBool(void)
79{
80 RTTestSub(g_hTest, "RTCRestBool");
81
82 {
83 RTCRestBool obj1;
84 RTTESTI_CHECK(obj1.m_fValue == false);
85 RTTESTI_CHECK(obj1.isNull() == false);
86 RTTESTI_CHECK(strcmp(obj1.typeName(), "bool") == 0);
87 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_Bool);
88 }
89
90 {
91 RTCRestBool obj2(true);
92 RTTESTI_CHECK(obj2.m_fValue == true);
93 RTTESTI_CHECK(obj2.isNull() == false);
94 }
95
96 {
97 RTCRestBool obj2(false);
98 RTTESTI_CHECK(obj2.m_fValue == false);
99 RTTESTI_CHECK(obj2.isNull() == false);
100 }
101
102 {
103 /* Value assignments: */
104 RTCRestBool obj3;
105 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
106 RTTESTI_CHECK(obj3.isNull() == true);
107 obj3.assignValue(true);
108 RTTESTI_CHECK(obj3.m_fValue == true);
109 RTTESTI_CHECK(obj3.isNull() == false);
110
111 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
112 RTTESTI_CHECK(obj3.isNull() == true);
113 obj3.assignValue(false);
114 RTTESTI_CHECK(obj3.m_fValue == false);
115 RTTESTI_CHECK(obj3.isNull() == false);
116
117 obj3.assignValue(true);
118 RTTESTI_CHECK(obj3.m_fValue == true);
119 RTTESTI_CHECK(obj3.isNull() == false);
120
121 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
122 RTTESTI_CHECK(obj3.m_fValue == false);
123 RTTESTI_CHECK(obj3.isNull() == false);
124
125 obj3.assignValue(true);
126 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
127 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
128 RTTESTI_CHECK(obj3.m_fValue == false);
129 RTTESTI_CHECK(obj3.isNull() == false);
130
131 /* Copy assignments: */
132 RTCRestBool obj3True(true);
133 RTTESTI_CHECK(obj3True.m_fValue == true);
134 RTTESTI_CHECK(obj3True.isNull() == false);
135 RTCRestBool obj3False(false);
136 RTTESTI_CHECK(obj3False.m_fValue == false);
137 RTTESTI_CHECK(obj3False.isNull() == false);
138 RTCRestBool obj3Null;
139 obj3Null.setNull();
140 RTTESTI_CHECK(obj3Null.m_fValue == false);
141 RTTESTI_CHECK(obj3Null.isNull() == true);
142
143 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
144 RTTESTI_CHECK_RC(obj3.assignCopy(obj3True), VINF_SUCCESS);
145 RTTESTI_CHECK(obj3.m_fValue == true);
146 RTTESTI_CHECK(obj3.isNull() == false);
147
148 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Null), VINF_SUCCESS);
149 RTTESTI_CHECK(obj3.m_fValue == false);
150 RTTESTI_CHECK(obj3.isNull() == true);
151
152 RTTESTI_CHECK_RC(obj3.assignCopy(obj3False), VINF_SUCCESS);
153 RTTESTI_CHECK(obj3.m_fValue == false);
154 RTTESTI_CHECK(obj3.isNull() == false);
155
156 obj3 = obj3Null;
157 RTTESTI_CHECK(obj3.m_fValue == false);
158 RTTESTI_CHECK(obj3.isNull() == true);
159
160 obj3 = obj3True;
161 RTTESTI_CHECK(obj3.m_fValue == true);
162 RTTESTI_CHECK(obj3.isNull() == false);
163
164 obj3 = obj3Null;
165 RTTESTI_CHECK(obj3.m_fValue == false);
166 RTTESTI_CHECK(obj3.isNull() == true);
167
168 obj3 = obj3False;
169 RTTESTI_CHECK(obj3.m_fValue == false);
170 RTTESTI_CHECK(obj3.isNull() == false);
171
172 /* setNull implies resetToDefault: */
173 obj3 = obj3True;
174 RTTESTI_CHECK(obj3.m_fValue == true);
175 RTTESTI_CHECK(obj3.isNull() == false);
176 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
177 RTTESTI_CHECK(obj3.isNull() == true);
178 RTTESTI_CHECK(obj3.m_fValue == false);
179
180 /* Copy constructors: */
181 {
182 RTCRestBool obj3a(obj3True);
183 RTTESTI_CHECK(obj3a.m_fValue == true);
184 RTTESTI_CHECK(obj3a.isNull() == false);
185 }
186 {
187 RTCRestBool obj3b(obj3False);
188 RTTESTI_CHECK(obj3b.m_fValue == false);
189 RTTESTI_CHECK(obj3b.isNull() == false);
190 }
191 {
192 RTCRestBool obj3c(obj3Null);
193 RTTESTI_CHECK(obj3c.m_fValue == false);
194 RTTESTI_CHECK(obj3c.isNull() == true);
195 }
196
197 /* Serialization to json: */
198 const char *pszJson = toJson(&obj3True);
199 RTTESTI_CHECK_MSG(strcmp(pszJson, "true") == 0, ("pszJson=%s\n", pszJson));
200 pszJson = toJson(&obj3False);
201 RTTESTI_CHECK_MSG(strcmp(pszJson, "false") == 0, ("pszJson=%s\n", pszJson));
202 pszJson = toJson(&obj3Null);
203 RTTESTI_CHECK_MSG(strcmp(pszJson, "null") == 0, ("pszJson=%s\n", pszJson));
204
205 /* Serialization to string. */
206 RTCString str;
207 str = "lead-in:";
208 RTTESTI_CHECK_RC(obj3True.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
209 RTTESTI_CHECK_MSG(str.equals("lead-in:true"), ("str=%s\n", str.c_str()));
210 RTTESTI_CHECK_RC(obj3True.toString(&str), VINF_SUCCESS);
211 RTTESTI_CHECK_MSG(str.equals("true"), ("str=%s\n", str.c_str()));
212
213 str = "lead-in:";
214 RTTESTI_CHECK_RC(obj3False.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
215 RTTESTI_CHECK_MSG(str.equals("lead-in:false"), ("str=%s\n", str.c_str()));
216 RTTESTI_CHECK_RC(obj3False.toString(&str), VINF_SUCCESS);
217 RTTESTI_CHECK_MSG(str.equals("false"), ("str=%s\n", str.c_str()));
218
219 str = "lead-in:";
220 RTTESTI_CHECK_RC(obj3Null.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
221 RTTESTI_CHECK_MSG(str.equals("lead-in:null"), ("str=%s\n", str.c_str()));
222 RTTESTI_CHECK_RC(obj3Null.toString(&str), VINF_SUCCESS);
223 RTTESTI_CHECK_MSG(str.equals("null"), ("str=%s\n", str.c_str()));
224 }
225
226 /* deserialize: */
227 RTERRINFOSTATIC ErrInfo;
228 {
229 RTCRestBool obj4;
230 obj4.setNull();
231 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "false", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
232 RTTESTI_CHECK(obj4.m_fValue == false);
233 RTTESTI_CHECK(obj4.isNull() == false);
234
235 obj4.setNull();
236 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "true", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
237 RTTESTI_CHECK(obj4.m_fValue == true);
238 RTTESTI_CHECK(obj4.isNull() == false);
239
240 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
241 RTTESTI_CHECK(obj4.m_fValue == false);
242 RTTESTI_CHECK(obj4.isNull() == true);
243
244 /* object goes to default state on failure: */
245 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "0", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_BOOL);
246 RTTESTI_CHECK(obj4.m_fValue == false);
247 RTTESTI_CHECK(obj4.isNull() == false);
248 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
249
250 obj4.assignValue(true);
251 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"false\"", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_BOOL);
252 RTTESTI_CHECK(obj4.m_fValue == false);
253 RTTESTI_CHECK(obj4.isNull() == false);
254 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
255
256 obj4.setNull();
257 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "[ null ]", NULL, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_BOOL);
258 RTTESTI_CHECK(obj4.m_fValue == false);
259 RTTESTI_CHECK(obj4.isNull() == false);
260
261 obj4.setNull();
262 RTTESTI_CHECK_RC(fromString(&obj4, "true", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
263 RTTESTI_CHECK(obj4.m_fValue == true);
264 RTTESTI_CHECK(obj4.isNull() == false);
265
266 RTTESTI_CHECK_RC(fromString(&obj4, "false", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
267 RTTESTI_CHECK(obj4.m_fValue == false);
268 RTTESTI_CHECK(obj4.isNull() == false);
269
270 obj4.m_fValue = true;
271 RTTESTI_CHECK_RC(fromString(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
272 RTTESTI_CHECK(obj4.m_fValue == false);
273 RTTESTI_CHECK(obj4.isNull() == true);
274
275 obj4.setNull();
276 RTTESTI_CHECK_RC(fromString(&obj4, " TrUe ", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
277 RTTESTI_CHECK(obj4.m_fValue == true);
278 RTTESTI_CHECK(obj4.isNull() == false);
279
280 RTTESTI_CHECK_RC(fromString(&obj4, "\tfAlSe;", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
281 RTTESTI_CHECK(obj4.m_fValue == false);
282 RTTESTI_CHECK(obj4.isNull() == false);
283
284 RTTESTI_CHECK_RC(fromString(&obj4, "\r\nfAlSe\n;", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
285 RTTESTI_CHECK(obj4.m_fValue == false);
286 RTTESTI_CHECK(obj4.isNull() == false);
287
288 RTTESTI_CHECK_RC(fromString(&obj4, "\r\tNuLl\n;", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
289 RTTESTI_CHECK(obj4.m_fValue == false);
290 RTTESTI_CHECK(obj4.isNull() == true);
291
292 RTTESTI_CHECK_RC(fromString(&obj4, "1", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_UNABLE_TO_PARSE_STRING_AS_BOOL);
293 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
294
295 RTTESTI_CHECK_RC(fromString(&obj4, "0", NULL, RT_XSTR(__LINE__)), VERR_REST_UNABLE_TO_PARSE_STRING_AS_BOOL);
296 }
297}
298
299class Int64Constants
300{
301public:
302 Int64Constants() {}
303 const char *getSubName() const { return "RTCRestInt64"; }
304 int64_t getMin() const { return INT64_MIN; }
305 const char *getMinStr() const { return "-9223372036854775808"; }
306 int64_t getMax() const { return INT64_MAX; }
307 const char *getMaxStr() const { return "9223372036854775807"; }
308 const char *getTypeName() const { return "int64_t"; }
309 RTCRestObjectBase::kTypeClass getTypeClass() const { return RTCRestObjectBase::kTypeClass_Int64; }
310};
311
312class Int32Constants
313{
314public:
315 Int32Constants() { }
316 const char *getSubName() const { return "RTCRestInt32"; }
317 int32_t getMin() const { return INT32_MIN; }
318 const char *getMinStr() const { return "-2147483648"; }
319 int32_t getMax() const { return INT32_MAX; }
320 const char *getMaxStr() const { return "2147483647"; }
321 const char *getTypeName() const { return "int32_t"; }
322 RTCRestObjectBase::kTypeClass getTypeClass() const { return RTCRestObjectBase::kTypeClass_Int32; }
323};
324
325class Int16Constants
326{
327public:
328 Int16Constants() { }
329 const char *getSubName() const { return "RTCRestInt16"; }
330 int16_t getMin() const { return INT16_MIN; }
331 const char *getMinStr() const { return "-32768"; }
332 int16_t getMax() const { return INT16_MAX; }
333 const char *getMaxStr() const { return "32767"; }
334 const char *getTypeName() const { return "int16_t"; }
335 RTCRestObjectBase::kTypeClass getTypeClass() const { return RTCRestObjectBase::kTypeClass_Int16; }
336};
337
338template<typename RestType, typename IntType, typename ConstantClass>
339void testInteger(void)
340{
341 ConstantClass const Consts;
342 RTTestSub(g_hTest, Consts.getSubName());
343
344 {
345 RestType obj1;
346 RTTESTI_CHECK(obj1.m_iValue == 0);
347 RTTESTI_CHECK(obj1.isNull() == false);
348 RTTESTI_CHECK(strcmp(obj1.typeName(), Consts.getTypeName()) == 0);
349 RTTESTI_CHECK(obj1.typeClass() == Consts.getTypeClass());
350 }
351
352 {
353 RestType obj2(2398);
354 RTTESTI_CHECK(obj2.m_iValue == 2398);
355 RTTESTI_CHECK(obj2.isNull() == false);
356 }
357
358 {
359 RestType obj2(-7345);
360 RTTESTI_CHECK(obj2.m_iValue == -7345);
361 RTTESTI_CHECK(obj2.isNull() == false);
362 }
363
364 {
365 /* Value assignments: */
366 RestType obj3;
367 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
368 RTTESTI_CHECK(obj3.isNull() == true);
369 RTTESTI_CHECK(obj3.m_iValue == 0);
370 obj3.assignValue(-1);
371 RTTESTI_CHECK(obj3.m_iValue == -1);
372 RTTESTI_CHECK(obj3.isNull() == false);
373
374 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
375 RTTESTI_CHECK(obj3.isNull() == true);
376 obj3.assignValue(42);
377 RTTESTI_CHECK(obj3.m_iValue == 42);
378 RTTESTI_CHECK(obj3.isNull() == false);
379
380 obj3.assignValue(Consts.getMax());
381 RTTESTI_CHECK(obj3.m_iValue == Consts.getMax());
382 RTTESTI_CHECK(obj3.isNull() == false);
383
384 obj3.assignValue(Consts.getMin());
385 RTTESTI_CHECK(obj3.m_iValue == Consts.getMin());
386 RTTESTI_CHECK(obj3.isNull() == false);
387
388 /* Reset to default: */
389 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
390 RTTESTI_CHECK(obj3.m_iValue == 0);
391 RTTESTI_CHECK(obj3.isNull() == false);
392
393 obj3.assignValue(42);
394 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
395 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
396 RTTESTI_CHECK(obj3.m_iValue == 0);
397 RTTESTI_CHECK(obj3.isNull() == false);
398
399 /* Copy assignments: */
400 RestType obj3Max(Consts.getMax());
401 RTTESTI_CHECK(obj3Max.m_iValue == Consts.getMax());
402 RTTESTI_CHECK(obj3Max.isNull() == false);
403 RestType obj3Min(Consts.getMin());
404 RTTESTI_CHECK(obj3Min.m_iValue == Consts.getMin());
405 RTTESTI_CHECK(obj3Min.isNull() == false);
406 RestType obj3Null;
407 obj3Null.setNull();
408 RTTESTI_CHECK(obj3Null.m_iValue == 0);
409 RTTESTI_CHECK(obj3Null.isNull() == true);
410
411 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
412 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Max), VINF_SUCCESS);
413 RTTESTI_CHECK(obj3.m_iValue == Consts.getMax());
414 RTTESTI_CHECK(obj3.isNull() == false);
415
416 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Null), VINF_SUCCESS);
417 RTTESTI_CHECK(obj3.m_iValue == 0);
418 RTTESTI_CHECK(obj3.isNull() == true);
419
420 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Min), VINF_SUCCESS);
421 RTTESTI_CHECK(obj3.m_iValue == Consts.getMin());
422 RTTESTI_CHECK(obj3.isNull() == false);
423
424 obj3 = obj3Null;
425 RTTESTI_CHECK(obj3.m_iValue == 0);
426 RTTESTI_CHECK(obj3.isNull() == true);
427
428 obj3 = obj3Max;
429 RTTESTI_CHECK(obj3.m_iValue == Consts.getMax());
430 RTTESTI_CHECK(obj3.isNull() == false);
431
432 obj3 = obj3Null;
433 RTTESTI_CHECK(obj3.m_iValue == 0);
434 RTTESTI_CHECK(obj3.isNull() == true);
435
436 obj3 = obj3Min;
437 RTTESTI_CHECK(obj3.m_iValue == Consts.getMin());
438 RTTESTI_CHECK(obj3.isNull() == false);
439
440 /* setNull implies resetToDefault: */
441 obj3 = obj3Max;
442 RTTESTI_CHECK(obj3.m_iValue == Consts.getMax());
443 RTTESTI_CHECK(obj3.isNull() == false);
444 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
445 RTTESTI_CHECK(obj3.isNull() == true);
446 RTTESTI_CHECK(obj3.m_iValue == 0);
447
448 /* Copy constructors: */
449 {
450 RestType obj3a(obj3Max);
451 RTTESTI_CHECK(obj3a.m_iValue == Consts.getMax());
452 RTTESTI_CHECK(obj3a.isNull() == false);
453 }
454 {
455 RestType obj3b(obj3Min);
456 RTTESTI_CHECK(obj3b.m_iValue == Consts.getMin());
457 RTTESTI_CHECK(obj3b.isNull() == false);
458 }
459 {
460 RestType obj3c(obj3Null);
461 RTTESTI_CHECK(obj3c.m_iValue == 0);
462 RTTESTI_CHECK(obj3c.isNull() == true);
463 }
464
465 /* Serialization to json: */
466 const char *pszJson = toJson(&obj3Max);
467 RTTESTI_CHECK_MSG(strcmp(pszJson, Consts.getMaxStr()) == 0, ("pszJson=%s\n", pszJson));
468 pszJson = toJson(&obj3Min);
469 RTTESTI_CHECK_MSG(strcmp(pszJson, Consts.getMinStr()) == 0, ("pszJson=%s\n", pszJson));
470 pszJson = toJson(&obj3Null);
471 RTTESTI_CHECK_MSG(strcmp(pszJson, "null") == 0, ("pszJson=%s\n", pszJson));
472
473 /* Serialization to string. */
474 RTCString str;
475 RTCString strExpect;
476 str = "lead-in:";
477 RTTESTI_CHECK_RC(obj3Max.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
478 strExpect.printf("lead-in:%s", Consts.getMaxStr());
479 RTTESTI_CHECK_MSG(str.equals(strExpect), ("str=%s strExpect=%s\n", str.c_str(), strExpect.c_str()));
480 RTTESTI_CHECK_RC(obj3Max.toString(&str), VINF_SUCCESS);
481 RTTESTI_CHECK_MSG(str.equals(Consts.getMaxStr()), ("str=%s\n", str.c_str()));
482
483 str = "lead-in:";
484 RTTESTI_CHECK_RC(obj3Min.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
485 strExpect.printf("lead-in:%s", Consts.getMinStr());
486 RTTESTI_CHECK_MSG(str.equals(strExpect), ("str=%s strExpect=%s\n", str.c_str(), strExpect.c_str()));
487 RTTESTI_CHECK_RC(obj3Min.toString(&str), VINF_SUCCESS);
488 RTTESTI_CHECK_MSG(str.equals(Consts.getMinStr()), ("str=%s\n", str.c_str()));
489
490 str = "lead-in:";
491 RTTESTI_CHECK_RC(obj3Null.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
492 RTTESTI_CHECK_MSG(str.equals("lead-in:null"), ("str=%s\n", str.c_str()));
493 RTTESTI_CHECK_RC(obj3Null.toString(&str), VINF_SUCCESS);
494 RTTESTI_CHECK_MSG(str.equals("null"), ("str=%s\n", str.c_str()));
495 }
496
497 /* deserialize: */
498 RTERRINFOSTATIC ErrInfo;
499 {
500 /* from json: */
501 RestType obj4;
502 obj4.setNull();
503 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "42", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
504 RTTESTI_CHECK(obj4.m_iValue == 42);
505 RTTESTI_CHECK(obj4.isNull() == false);
506
507 obj4.setNull();
508 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "-22", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
509 RTTESTI_CHECK(obj4.m_iValue == -22);
510 RTTESTI_CHECK(obj4.isNull() == false);
511
512 obj4.setNull();
513 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, Consts.getMaxStr(), &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
514 RTTESTI_CHECK(obj4.m_iValue == Consts.getMax());
515 RTTESTI_CHECK(obj4.isNull() == false);
516
517 obj4.setNull();
518 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, Consts.getMinStr(), &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
519 RTTESTI_CHECK(obj4.m_iValue == Consts.getMin());
520 RTTESTI_CHECK(obj4.isNull() == false);
521
522 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
523 RTTESTI_CHECK(obj4.m_iValue == 0);
524 RTTESTI_CHECK(obj4.isNull() == true);
525
526 /* object goes to default state on failure: */
527 obj4.assignValue(Consts.getMin());
528 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "0.0", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_INTEGER);
529 RTTESTI_CHECK(obj4.m_iValue == 0);
530 RTTESTI_CHECK(obj4.isNull() == false);
531 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
532
533 obj4.assignValue(Consts.getMax());
534 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"false\"", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_INTEGER);
535 RTTESTI_CHECK(obj4.m_iValue == 0);
536 RTTESTI_CHECK(obj4.isNull() == false);
537 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
538
539 obj4.setNull();
540 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "[ null ]", NULL, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_INTEGER);
541 RTTESTI_CHECK(obj4.m_iValue == 0);
542 RTTESTI_CHECK(obj4.isNull() == false);
543
544 /* from string: */
545 obj4.setNull();
546 RTTESTI_CHECK_RC(fromString(&obj4, "22", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
547 RTTESTI_CHECK(obj4.m_iValue == 22);
548 RTTESTI_CHECK(obj4.isNull() == false);
549
550 RTTESTI_CHECK_RC(fromString(&obj4, "-42", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
551 RTTESTI_CHECK(obj4.m_iValue == -42);
552 RTTESTI_CHECK(obj4.isNull() == false);
553
554 RTTESTI_CHECK_RC(fromString(&obj4, Consts.getMaxStr(), &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
555 RTTESTI_CHECK(obj4.m_iValue == Consts.getMax());
556 RTTESTI_CHECK(obj4.isNull() == false);
557
558 RTTESTI_CHECK_RC(fromString(&obj4, Consts.getMinStr(), &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
559 RTTESTI_CHECK(obj4.m_iValue == Consts.getMin());
560 RTTESTI_CHECK(obj4.isNull() == false);
561
562 obj4.m_iValue = 33;
563 RTTESTI_CHECK_RC(fromString(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
564 RTTESTI_CHECK(obj4.m_iValue == 0);
565 RTTESTI_CHECK(obj4.isNull() == true);
566
567 obj4.m_iValue = 33;
568 RTTESTI_CHECK_RC(fromString(&obj4, " nULl;", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
569 RTTESTI_CHECK(obj4.m_iValue == 0);
570 RTTESTI_CHECK(obj4.isNull() == true);
571
572 obj4.setNull();
573 RTTESTI_CHECK_RC(fromString(&obj4, " 0x42 ", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
574 RTTESTI_CHECK(obj4.m_iValue == 0x42);
575 RTTESTI_CHECK(obj4.isNull() == false);
576
577 RTTESTI_CHECK_RC(fromString(&obj4, "\t010\t", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
578 RTTESTI_CHECK(obj4.m_iValue == 8);
579 RTTESTI_CHECK(obj4.isNull() == false);
580
581 RTTESTI_CHECK_RC(fromString(&obj4, "\r\t0X4FDB\t", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
582 RTTESTI_CHECK(obj4.m_iValue == 0x4fdb);
583 RTTESTI_CHECK(obj4.isNull() == false);
584
585 RTTESTI_CHECK_RC(fromString(&obj4, "1.1", &ErrInfo, RT_XSTR(__LINE__)), VERR_TRAILING_CHARS);
586 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
587
588 RTTESTI_CHECK_RC(fromString(&obj4, "false", NULL, RT_XSTR(__LINE__)), VERR_NO_DIGITS);
589 }
590}
591
592
593void testDouble(void)
594{
595 RTTestSub(g_hTest, "RTCRestDouble");
596#if defined(RT_OS_WINDOWS)
597# define TST_DBL_MAX_STRING "1.7976931348623157e+308"
598# define TST_DBL_MIN_STRING "2.2250738585072014e-308"
599# define TST_DBL_MAX (1.7976931348623157e+308)
600# define TST_DBL_MIN (2.2250738585072014e-308)
601#else
602# define TST_DBL_MAX_STRING "1.79769313486231571e+308"
603# define TST_DBL_MIN_STRING "2.22507385850720138e-308"
604# define TST_DBL_MAX (1.79769313486231571e+308)
605# define TST_DBL_MIN (2.22507385850720138e-308)
606#endif
607
608 {
609 RTCRestDouble obj1;
610 RTTESTI_CHECK(obj1.m_rdValue == 0.0);
611 RTTESTI_CHECK(obj1.isNull() == false);
612 RTTESTI_CHECK(strcmp(obj1.typeName(), "double") == 0);
613 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_Double);
614 }
615
616 {
617 RTCRestDouble obj2(2398.1);
618 RTTESTI_CHECK(obj2.m_rdValue == 2398.1);
619 RTTESTI_CHECK(obj2.isNull() == false);
620 }
621
622 {
623 RTCRestDouble obj2(-7345.2);
624 RTTESTI_CHECK(obj2.m_rdValue == -7345.2);
625 RTTESTI_CHECK(obj2.isNull() == false);
626 }
627
628 {
629 /* Value assignments: */
630 RTCRestDouble obj3;
631 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
632 RTTESTI_CHECK(obj3.isNull() == true);
633 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
634 obj3.assignValue(-1.0);
635 RTTESTI_CHECK(obj3.m_rdValue == -1.0);
636 RTTESTI_CHECK(obj3.isNull() == false);
637
638 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
639 RTTESTI_CHECK(obj3.isNull() == true);
640 obj3.assignValue(42.42);
641 RTTESTI_CHECK(obj3.m_rdValue == 42.42);
642 RTTESTI_CHECK(obj3.isNull() == false);
643
644 obj3.assignValue(TST_DBL_MAX);
645 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MAX);
646 RTTESTI_CHECK(obj3.isNull() == false);
647
648 obj3.assignValue(TST_DBL_MIN);
649 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MIN);
650 RTTESTI_CHECK(obj3.isNull() == false);
651
652 /* Reset to default: */
653 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
654 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
655 RTTESTI_CHECK(obj3.isNull() == false);
656
657 obj3.assignValue(42);
658 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
659 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
660 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
661 RTTESTI_CHECK(obj3.isNull() == false);
662
663 /* Copy assignments: */
664 RTCRestDouble obj3Max(TST_DBL_MAX);
665 RTTESTI_CHECK(obj3Max.m_rdValue == TST_DBL_MAX);
666 RTTESTI_CHECK(obj3Max.isNull() == false);
667 RTCRestDouble obj3Min(TST_DBL_MIN);
668 RTTESTI_CHECK(obj3Min.m_rdValue == TST_DBL_MIN);
669 RTTESTI_CHECK(obj3Min.isNull() == false);
670 RTCRestDouble obj3Null;
671 obj3Null.setNull();
672 RTTESTI_CHECK(obj3Null.m_rdValue == 0.0);
673 RTTESTI_CHECK(obj3Null.isNull() == true);
674
675 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
676 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Max), VINF_SUCCESS);
677 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MAX);
678 RTTESTI_CHECK(obj3.isNull() == false);
679
680 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Null), VINF_SUCCESS);
681 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
682 RTTESTI_CHECK(obj3.isNull() == true);
683
684 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Min), VINF_SUCCESS);
685 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MIN);
686 RTTESTI_CHECK(obj3.isNull() == false);
687
688 obj3 = obj3Null;
689 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
690 RTTESTI_CHECK(obj3.isNull() == true);
691
692 obj3 = obj3Max;
693 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MAX);
694 RTTESTI_CHECK(obj3.isNull() == false);
695
696 obj3 = obj3Null;
697 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
698 RTTESTI_CHECK(obj3.isNull() == true);
699
700 obj3 = obj3Min;
701 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MIN);
702 RTTESTI_CHECK(obj3.isNull() == false);
703
704 /* setNull implies resetToDefault: */
705 obj3 = obj3Max;
706 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MAX);
707 RTTESTI_CHECK(obj3.isNull() == false);
708 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
709 RTTESTI_CHECK(obj3.isNull() == true);
710 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
711
712 /* Copy constructors: */
713 {
714 RTCRestDouble obj3a(obj3Max);
715 RTTESTI_CHECK(obj3a.m_rdValue == TST_DBL_MAX);
716 RTTESTI_CHECK(obj3a.isNull() == false);
717 }
718 {
719 RTCRestDouble obj3b(obj3Min);
720 RTTESTI_CHECK(obj3b.m_rdValue == TST_DBL_MIN);
721 RTTESTI_CHECK(obj3b.isNull() == false);
722 }
723 {
724 RTCRestDouble obj3c(obj3Null);
725 RTTESTI_CHECK(obj3c.m_rdValue == 0.0);
726 RTTESTI_CHECK(obj3c.isNull() == true);
727 }
728
729 /* Serialization to json: */
730 const char *pszJson = toJson(&obj3Max);
731 RTTESTI_CHECK_MSG(strcmp(pszJson, TST_DBL_MAX_STRING) == 0, ("pszJson=%s\n", pszJson));
732 pszJson = toJson(&obj3Min);
733 RTTESTI_CHECK_MSG(strcmp(pszJson, TST_DBL_MIN_STRING) == 0, ("pszJson=%s\n", pszJson));
734 pszJson = toJson(&obj3Null);
735 RTTESTI_CHECK_MSG(strcmp(pszJson, "null") == 0, ("pszJson=%s\n", pszJson));
736
737 /* Serialization to string. */
738 RTCString str;
739 RTCString strExpect;
740 str = "lead-in:";
741 RTTESTI_CHECK_RC(obj3Max.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
742 strExpect.printf("lead-in:%s", TST_DBL_MAX_STRING);
743 RTTESTI_CHECK_MSG(str.equals(strExpect), ("str=%s strExpect=%s\n", str.c_str(), strExpect.c_str()));
744 RTTESTI_CHECK_RC(obj3Max.toString(&str), VINF_SUCCESS);
745 RTTESTI_CHECK_MSG(str.equals(TST_DBL_MAX_STRING), ("str=%s\n", str.c_str()));
746
747 str = "lead-in:";
748 RTTESTI_CHECK_RC(obj3Min.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
749 strExpect.printf("lead-in:%s", TST_DBL_MIN_STRING);
750 RTTESTI_CHECK_MSG(str.equals(strExpect), ("str=%s strExpect=%s\n", str.c_str(), strExpect.c_str()));
751 RTTESTI_CHECK_RC(obj3Min.toString(&str), VINF_SUCCESS);
752 RTTESTI_CHECK_MSG(str.equals(TST_DBL_MIN_STRING), ("str=%s\n", str.c_str()));
753
754 str = "lead-in:";
755 RTTESTI_CHECK_RC(obj3Null.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
756 RTTESTI_CHECK_MSG(str.equals("lead-in:null"), ("str=%s\n", str.c_str()));
757 RTTESTI_CHECK_RC(obj3Null.toString(&str), VINF_SUCCESS);
758 RTTESTI_CHECK_MSG(str.equals("null"), ("str=%s\n", str.c_str()));
759 }
760
761 /* deserialize: */
762 RTERRINFOSTATIC ErrInfo;
763 {
764 /* from json: */
765 RTCRestDouble obj4;
766 obj4.setNull();
767 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "42.42", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
768 RTTESTI_CHECK(obj4.m_rdValue == 42.42);
769 RTTESTI_CHECK(obj4.isNull() == false);
770
771 obj4.setNull();
772 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "-22.22", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
773 RTTESTI_CHECK(obj4.m_rdValue == -22.22);
774 RTTESTI_CHECK(obj4.isNull() == false);
775
776 obj4.setNull();
777 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, TST_DBL_MAX_STRING, &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
778 RTTESTI_CHECK(obj4.m_rdValue == TST_DBL_MAX);
779 RTTESTI_CHECK(obj4.isNull() == false);
780
781 obj4.setNull();
782 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, TST_DBL_MIN_STRING, &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
783 RTTESTI_CHECK(obj4.m_rdValue == TST_DBL_MIN);
784 RTTESTI_CHECK(obj4.isNull() == false);
785
786 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
787 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
788 RTTESTI_CHECK(obj4.isNull() == true);
789
790 obj4.setNull();
791 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "14323", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
792 RTTESTI_CHECK(obj4.m_rdValue == 14323.0);
793 RTTESTI_CHECK(obj4.isNull() == false);
794
795 obj4.setNull();
796 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "-234875", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
797 RTTESTI_CHECK(obj4.m_rdValue == -234875.0);
798 RTTESTI_CHECK(obj4.isNull() == false);
799
800 /* object goes to default state on failure: */
801 obj4.assignValue(TST_DBL_MIN);
802 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "false", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DOUBLE);
803 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
804 RTTESTI_CHECK(obj4.isNull() == false);
805 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
806
807 obj4.assignValue(TST_DBL_MAX);
808 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"false\"", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DOUBLE);
809 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
810 RTTESTI_CHECK(obj4.isNull() == false);
811 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
812
813 obj4.setNull();
814 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "[ null ]", NULL, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DOUBLE);
815 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
816 RTTESTI_CHECK(obj4.isNull() == false);
817
818 /* from string: */
819 obj4.setNull();
820 RTTESTI_CHECK_RC(fromString(&obj4, "22.42", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
821 RTTESTI_CHECK(obj4.m_rdValue == 22.42);
822 RTTESTI_CHECK(obj4.isNull() == false);
823
824 RTTESTI_CHECK_RC(fromString(&obj4, "-42.22", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
825 RTTESTI_CHECK(obj4.m_rdValue == -42.22);
826 RTTESTI_CHECK(obj4.isNull() == false);
827
828 RTTESTI_CHECK_RC(fromString(&obj4, TST_DBL_MAX_STRING, &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
829 RTTESTI_CHECK(obj4.m_rdValue == TST_DBL_MAX);
830 RTTESTI_CHECK(obj4.isNull() == false);
831
832 RTTESTI_CHECK_RC(fromString(&obj4, TST_DBL_MIN_STRING, &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
833 RTTESTI_CHECK(obj4.m_rdValue == TST_DBL_MIN);
834 RTTESTI_CHECK(obj4.isNull() == false);
835
836 obj4.m_rdValue = 33.33;
837 RTTESTI_CHECK_RC(fromString(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
838 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
839 RTTESTI_CHECK(obj4.isNull() == true);
840
841 obj4.m_rdValue = 33.33;
842 RTTESTI_CHECK_RC(fromString(&obj4, " nULl;", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
843 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
844 RTTESTI_CHECK(obj4.isNull() == true);
845
846 obj4.setNull();
847 RTTESTI_CHECK_RC(fromString(&obj4, " 42.22 ", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
848 RTTESTI_CHECK(obj4.m_rdValue == 42.22);
849 RTTESTI_CHECK(obj4.isNull() == false);
850
851 RTTESTI_CHECK_RC(fromString(&obj4, "\t010\t", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
852 RTTESTI_CHECK(obj4.m_rdValue ==10.0);
853 RTTESTI_CHECK(obj4.isNull() == false);
854
855 RTTESTI_CHECK_RC(fromString(&obj4, "\r\t03495.344\t\r\n", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
856 RTTESTI_CHECK(obj4.m_rdValue == 3495.344);
857 RTTESTI_CHECK(obj4.isNull() == false);
858
859 RTTESTI_CHECK_RC(fromString(&obj4, "1.1;", &ErrInfo, RT_XSTR(__LINE__)), VERR_TRAILING_CHARS);
860 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
861
862 RTTESTI_CHECK_RC(fromString(&obj4, "false", NULL, RT_XSTR(__LINE__)), VERR_NO_DIGITS);
863
864#if defined(RT_OS_WINDOWS)
865 RTTESTI_CHECK_RC(fromString(&obj4, " 0x42 ", &ErrInfo, RT_XSTR(__LINE__)), VERR_TRAILING_CHARS);
866 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
867#else
868 RTTESTI_CHECK_RC(fromString(&obj4, " 0x42 ", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
869 RTTESTI_CHECK(obj4.m_rdValue == 66.0);
870#endif
871 RTTESTI_CHECK(obj4.isNull() == false);
872 }
873}
874
875
876void testString(const char *pszDummy, ...)
877{
878 RTTestSub(g_hTest, "RTCRestString");
879
880 {
881 RTCRestString obj1;
882 RTTESTI_CHECK(obj1.isEmpty());
883 RTTESTI_CHECK(obj1.isNull() == false);
884 RTTESTI_CHECK(strcmp(obj1.typeName(), "RTCString") == 0);
885 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_String);
886 }
887
888 {
889 RTCRestString obj2(RTCString("2398.1"));
890 RTTESTI_CHECK(obj2 == "2398.1");
891 RTTESTI_CHECK(obj2.isNull() == false);
892 }
893
894 {
895 RTCRestString obj2("-7345.2");
896 RTTESTI_CHECK(obj2 == "-7345.2");
897 RTTESTI_CHECK(obj2.isNull() == false);
898 }
899
900 {
901 /* Value assignments: */
902 RTCRestString obj3;
903 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
904 RTTESTI_CHECK(obj3.isNull() == true);
905 RTTESTI_CHECK(obj3.isEmpty());
906 obj3 = "-1.0";
907 RTTESTI_CHECK(obj3 == "-1.0");
908 RTTESTI_CHECK(obj3.isNull() == false);
909
910 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
911 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
912 obj3 = RTCString("-2.0");
913 RTTESTI_CHECK(obj3 == "-2.0");
914 RTTESTI_CHECK(obj3.isNull() == false);
915
916 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
917 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
918 obj3 = RTCRestString("-3.0");
919 RTTESTI_CHECK(obj3 == "-3.0");
920 RTTESTI_CHECK(obj3.isNull() == false);
921
922 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
923 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
924 RTTESTI_CHECK_RC(obj3.assignNoThrow(RTCRestString("4.0")), VINF_SUCCESS);
925 RTTESTI_CHECK(obj3 == "4.0");
926 RTTESTI_CHECK(obj3.isNull() == false);
927
928 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
929 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
930 RTTESTI_CHECK_RC(obj3.assignNoThrow("-4.0"), VINF_SUCCESS);
931 RTTESTI_CHECK(obj3 == "-4.0");
932 RTTESTI_CHECK(obj3.isNull() == false);
933
934 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
935 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
936 RTTESTI_CHECK_RC(obj3.assignNoThrow(RTCRestString("0123456789"), 3, 5), VINF_SUCCESS);
937 RTTESTI_CHECK(obj3 == "34567");
938 RTTESTI_CHECK(obj3.isNull() == false);
939
940 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
941 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
942 RTTESTI_CHECK_RC(obj3.assignNoThrow("0123456789", 4), VINF_SUCCESS);
943 RTTESTI_CHECK(obj3 == "0123");
944 RTTESTI_CHECK(obj3.isNull() == false);
945
946 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
947 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
948 RTTESTI_CHECK_RC(obj3.assignNoThrow(8, 'x'), VINF_SUCCESS);
949 RTTESTI_CHECK(obj3 == "xxxxxxxx");
950 RTTESTI_CHECK(obj3.isNull() == false);
951
952 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
953 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
954 RTTESTI_CHECK_RC(obj3.printfNoThrow("%d%s%d", 42, "asdf", 22), VINF_SUCCESS);
955 RTTESTI_CHECK(obj3 == "42asdf22");
956 RTTESTI_CHECK(obj3.isNull() == false);
957
958 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
959 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
960 va_list va;
961 va_start(va, pszDummy);
962 RTTESTI_CHECK_RC(obj3.printfVNoThrow("asdf", va), VINF_SUCCESS);
963 va_end(va);
964 RTTESTI_CHECK(obj3 == "asdf");
965 RTTESTI_CHECK(obj3.isNull() == false);
966
967 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
968 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
969 obj3.assign(RTCRestString("4.0"));
970 RTTESTI_CHECK(obj3 == "4.0");
971 RTTESTI_CHECK(obj3.isNull() == false);
972
973 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
974 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
975 obj3.assign("-4.0");
976 RTTESTI_CHECK(obj3 == "-4.0");
977 RTTESTI_CHECK(obj3.isNull() == false);
978
979 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
980 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
981 obj3.assign(RTCRestString("0123456789"), 3, 5);
982 RTTESTI_CHECK(obj3 == "34567");
983 RTTESTI_CHECK(obj3.isNull() == false);
984
985 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
986 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
987 obj3.assign("0123456789", 4);
988 RTTESTI_CHECK(obj3 == "0123");
989 RTTESTI_CHECK(obj3.isNull() == false);
990
991 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
992 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
993 obj3.assign(8, 'x');
994 RTTESTI_CHECK(obj3 == "xxxxxxxx");
995 RTTESTI_CHECK(obj3.isNull() == false);
996
997 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
998 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
999 obj3.printf("%d%s%d", 42, "asdf", 22);
1000 RTTESTI_CHECK(obj3 == "42asdf22");
1001 RTTESTI_CHECK(obj3.isNull() == false);
1002
1003 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1004 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1005 va_start(va, pszDummy);
1006 obj3.printfV("asdf", va);
1007 va_end(va);
1008 RTTESTI_CHECK(obj3 == "asdf");
1009 RTTESTI_CHECK(obj3.isNull() == false);
1010
1011 /* Reset to default: */
1012 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
1013 RTTESTI_CHECK(obj3.isEmpty());
1014 RTTESTI_CHECK(obj3.isNull() == false);
1015
1016 obj3 = "1";
1017 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1018 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
1019 RTTESTI_CHECK(obj3.isEmpty());
1020 RTTESTI_CHECK(obj3.isNull() == false);
1021
1022 /* Copy assignments: */
1023 RTCRestString const obj3Max("max");
1024 RTTESTI_CHECK(obj3Max == "max");
1025 RTTESTI_CHECK(obj3Max.isNull() == false);
1026 RTCRestString obj3Null;
1027 obj3Null.setNull();
1028 RTTESTI_CHECK(obj3Null.isEmpty());
1029 RTTESTI_CHECK(obj3Null.isNull() == true);
1030 RTCRestString obj3Empty;
1031 RTTESTI_CHECK(obj3Empty.isEmpty());
1032 RTTESTI_CHECK(obj3Empty.isNull() == false);
1033
1034 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1035 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1036 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Max), VINF_SUCCESS);
1037 RTTESTI_CHECK(obj3 == "max");
1038 RTTESTI_CHECK(obj3.isNull() == false);
1039
1040 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1041 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1042 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Null), VINF_SUCCESS);
1043 RTTESTI_CHECK(obj3.isEmpty());
1044 RTTESTI_CHECK(obj3.isNull() == true);
1045
1046 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1047 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1048 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Empty), VINF_SUCCESS);
1049 RTTESTI_CHECK(obj3 == "");
1050 RTTESTI_CHECK(obj3.isEmpty());
1051 RTTESTI_CHECK(obj3.isNull() == false);
1052
1053 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1054 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1055 RTTESTI_CHECK_RC(obj3.assignCopy(RTCString("11.0")), VINF_SUCCESS);
1056 RTTESTI_CHECK(obj3 == "11.0");
1057 RTTESTI_CHECK(obj3.isNull() == false);
1058
1059 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1060 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1061 RTTESTI_CHECK_RC(obj3.assignCopy("12.0"), VINF_SUCCESS);
1062 RTTESTI_CHECK(obj3 == "12.0");
1063 RTTESTI_CHECK(obj3.isNull() == false);
1064
1065 /* setNull implies resetToDefault: */
1066 obj3 = obj3Max;
1067 RTTESTI_CHECK(obj3 == "max");
1068 RTTESTI_CHECK(obj3.isNull() == false);
1069 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1070 RTTESTI_CHECK(obj3.isNull() == true);
1071 RTTESTI_CHECK(obj3.isEmpty());
1072
1073 /* Copy constructors: */
1074 {
1075 RTCRestString obj3a(obj3Max);
1076 RTTESTI_CHECK(obj3a == "max");
1077 RTTESTI_CHECK(obj3a.isNull() == false);
1078 }
1079 {
1080 RTCRestString const obj3c(obj3Null);
1081 RTTESTI_CHECK(obj3c.isEmpty());
1082 RTTESTI_CHECK(obj3c.isNull() == true);
1083 }
1084
1085 /* Serialization to json: */
1086 const char *pszJson = toJson(&obj3Max);
1087 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"max\"") == 0, ("pszJson=%s\n", pszJson));
1088 pszJson = toJson(&obj3Null);
1089 RTTESTI_CHECK_MSG(strcmp(pszJson, "null") == 0, ("pszJson=%s\n", pszJson));
1090 pszJson = toJson(&obj3Empty);
1091 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"\"") == 0, ("pszJson=%s\n", pszJson));
1092
1093 /* Serialization to string. */
1094 RTCString str;
1095 RTCString strExpect;
1096 str = "lead-in:";
1097 RTTESTI_CHECK_RC(obj3Max.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1098 RTTESTI_CHECK_MSG(str.equals("lead-in:max"), ("str=%s\n", str.c_str()));
1099 RTTESTI_CHECK_RC(obj3Max.toString(&str), VINF_SUCCESS);
1100 RTTESTI_CHECK_MSG(str.equals("max"), ("str=%s\n", str.c_str()));
1101
1102 str = "lead-in:";
1103 RTTESTI_CHECK_RC(obj3Empty.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1104 RTTESTI_CHECK_MSG(str.equals("lead-in:"), ("str=%s\n", str.c_str()));
1105 RTTESTI_CHECK_RC(obj3Empty.toString(&str), VINF_SUCCESS);
1106 RTTESTI_CHECK_MSG(str.equals(""), ("str=%s\n", str.c_str()));
1107
1108 str = "lead-in:";
1109 RTTESTI_CHECK_RC(obj3Null.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1110 RTTESTI_CHECK_MSG(str.equals("lead-in:"), ("str=%s\n", str.c_str()));
1111 RTTESTI_CHECK_RC(obj3Null.toString(&str), VINF_SUCCESS);
1112 RTTESTI_CHECK_MSG(str.equals(""), ("str=%s\n", str.c_str()));
1113 }
1114
1115 /* deserialize: */
1116 RTERRINFOSTATIC ErrInfo;
1117 {
1118 /* from json: */
1119 RTCRestString obj4;
1120 obj4.setNull();
1121 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"42.42\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1122 RTTESTI_CHECK(obj4 == "42.42");
1123 RTTESTI_CHECK(obj4.isNull() == false);
1124
1125 obj4.setNull();
1126 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"-22.22\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1127 RTTESTI_CHECK(obj4 == "-22.22");
1128 RTTESTI_CHECK(obj4.isNull() == false);
1129
1130 obj4.setNull();
1131 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"maximum\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1132 RTTESTI_CHECK(obj4 == "maximum");
1133 RTTESTI_CHECK(obj4.isNull() == false);
1134
1135 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1136 RTTESTI_CHECK(obj4.isEmpty());
1137 RTTESTI_CHECK(obj4.isNull() == true);
1138
1139 obj4.setNull();
1140 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"\\u0020\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1141 RTTESTI_CHECK(obj4 == " ");
1142 RTTESTI_CHECK(obj4.isNull() == false);
1143
1144 obj4.setNull();
1145 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"\\u004f\\u004D\\u0047\\u0021 :-)\"",
1146 &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1147 RTTESTI_CHECK(obj4 == "OMG! :-)");
1148 RTTESTI_CHECK(obj4.isNull() == false);
1149
1150 obj4.setNull();
1151 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"42:\\uD801\\udC37\\ud852\\uDf62:42\"", /* U+10437 U+24B62 */
1152 &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1153 RTTESTI_CHECK(obj4 == "42:" "\xf0\x90\x90\xb7" "\xf0\xa4\xad\xa2" ":42");
1154 RTTESTI_CHECK(obj4.isNull() == false);
1155
1156 /* object goes to default state on failure: */
1157 obj4 = "asdf";
1158 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "false", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_STRING);
1159 RTTESTI_CHECK(obj4.isEmpty());
1160 RTTESTI_CHECK(obj4.isNull() == false);
1161 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
1162
1163 obj4 = "asdf";
1164 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "1", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_STRING);
1165 RTTESTI_CHECK(obj4.isEmpty());
1166 RTTESTI_CHECK(obj4.isNull() == false);
1167 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
1168
1169 obj4.setNull();
1170 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "[ null ]", NULL, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_STRING);
1171 RTTESTI_CHECK(obj4.isEmpty());
1172 RTTESTI_CHECK(obj4.isNull() == false);
1173
1174 /* from string: */
1175 obj4.setNull();
1176 RTTESTI_CHECK_RC(fromString(&obj4, "22.42", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1177 RTTESTI_CHECK(obj4 == "22.42");
1178 RTTESTI_CHECK(obj4.isNull() == false);
1179
1180 RTTESTI_CHECK_RC(fromString(&obj4, "-42.22", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1181 RTTESTI_CHECK(obj4 == "-42.22");
1182 RTTESTI_CHECK(obj4.isNull() == false);
1183
1184 obj4.setNull();
1185 RTTESTI_CHECK_RC(fromString(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1186 RTTESTI_CHECK(obj4 == "null");
1187 RTTESTI_CHECK(obj4.isNull() == false);
1188 }
1189}
1190
1191
1192void testDate()
1193{
1194 RTTestSub(g_hTest, "RTCRestDate");
1195 int64_t const iRecent = INT64_C(1536580687739632500);
1196 int64_t const iRecentSec = INT64_C(1536580687000000000);
1197 RTTIMESPEC TimeSpec;
1198
1199#define CHECK_DATE(a_obj, a_fNull, a_fOkay, a_i64Nano, a_sz, a_fUtc) \
1200 do { \
1201 RTTESTI_CHECK((a_obj).isOkay() == (a_fOkay)); \
1202 if ((a_obj).getEpochNano() != (a_i64Nano)) \
1203 RTTestIFailed("line " RT_XSTR(__LINE__) ": getEpochNano=%RI64, expected %RI64", (a_obj).getEpochNano(), (int64_t)(a_i64Nano)); \
1204 if (!(a_obj).getString().equals(a_sz)) \
1205 RTTestIFailed("line " RT_XSTR(__LINE__) ": getString=%s, expected %s", (a_obj).getString().c_str(), a_sz); \
1206 RTTESTI_CHECK((a_obj).isUtc() == (a_fUtc)); \
1207 RTTESTI_CHECK((a_obj).isNull() == (a_fNull)); \
1208 } while (0)
1209#define CHECK_DATE_FMT(a_obj, a_fNull, a_fOkay, a_i64Nano, a_sz, a_fUtc, a_enmFormat) \
1210 do { \
1211 CHECK_DATE(a_obj, a_fNull, a_fOkay, a_i64Nano, a_sz, a_fUtc); \
1212 if ((a_obj).getFormat() != (a_enmFormat)) \
1213 RTTestIFailed("line " RT_XSTR(__LINE__) ": getFormat=%d, expected %d (%s)", (a_obj).getFormat(), (a_enmFormat), #a_enmFormat); \
1214 } while (0)
1215
1216 {
1217 RTCRestDate obj1;
1218 CHECK_DATE(obj1, true, false, 0, "", true);
1219 RTTESTI_CHECK(strcmp(obj1.typeName(), "RTCRestDate") == 0);
1220 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_Date);
1221 }
1222
1223 {
1224 /* Value assignments: */
1225 RTCRestDate obj3;
1226 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339), VINF_SUCCESS);
1227 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00Z", true);
1228
1229 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1230 CHECK_DATE(obj3, true, false, 0, "", true);
1231 RTTESTI_CHECK_RC(obj3.assignValueRfc3339(RTTimeSpecSetNano(&TimeSpec, 0)), VINF_SUCCESS);
1232 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00Z", true);
1233
1234 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1235 CHECK_DATE(obj3, true, false, 0, "", true);
1236 RTTESTI_CHECK_RC(obj3.assignValueRfc2822(RTTimeSpecSetNano(&TimeSpec, 0)), VINF_SUCCESS);
1237 CHECK_DATE(obj3, false, true, 0, "Thu, 1 Jan 1970 00:00:00 -0000", true);
1238
1239 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1240 RTTESTI_CHECK_RC(obj3.assignValueRfc7131(RTTimeSpecSetNano(&TimeSpec, 0)), VINF_SUCCESS);
1241 CHECK_DATE(obj3, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true);
1242
1243 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1244 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1245 CHECK_DATE(obj3, false, true, 0, "Thu, 1 Jan 1970 00:00:00 -0000", true);
1246
1247 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1248 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc7131), VINF_SUCCESS);
1249 CHECK_DATE(obj3, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true);
1250
1251 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1252 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_9), VINF_SUCCESS);
1253 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.000000000Z", true);
1254
1255 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1256 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_6), VINF_SUCCESS);
1257 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.000000Z", true);
1258
1259 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1260 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_3), VINF_SUCCESS);
1261 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.000Z", true);
1262
1263 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1264 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_2), VINF_SUCCESS);
1265 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.00Z", true);
1266
1267 /* Format changes: */
1268 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 59123456789), RTCRestDate::kFormat_Rfc3339_Fraction_9), VINF_SUCCESS);
1269 CHECK_DATE(obj3, false, true, 59123456789, "1970-01-01T00:00:59.123456789Z", true);
1270 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1271 CHECK_DATE(obj3, false, true, 59123456789, "Thu, 1 Jan 1970 00:00:59 -0000", true);
1272 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc7131), VINF_SUCCESS);
1273 CHECK_DATE(obj3, false, true, 59123456789, "Thu, 1 Jan 1970 00:00:59 GMT", true);
1274 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc3339), VINF_SUCCESS);
1275 CHECK_DATE(obj3, false, true, 59123456789, "1970-01-01T00:00:59Z", true);
1276 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc3339_Fraction_2), VINF_SUCCESS);
1277 CHECK_DATE(obj3, false, true, 59123456789, "1970-01-01T00:00:59.12Z", true);
1278 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc3339_Fraction_3), VINF_SUCCESS);
1279 CHECK_DATE(obj3, false, true, 59123456789, "1970-01-01T00:00:59.123Z", true);
1280 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc3339_Fraction_6), VINF_SUCCESS);
1281 CHECK_DATE(obj3, false, true, 59123456789, "1970-01-01T00:00:59.123456Z", true);
1282 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc3339_Fraction_9), VINF_SUCCESS);
1283 CHECK_DATE(obj3, false, true, 59123456789, "1970-01-01T00:00:59.123456789Z", true);
1284
1285 /* Reset to default and setNull works identically: */
1286 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
1287 CHECK_DATE(obj3, true, false, 0, "", true);
1288
1289 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_2), VINF_SUCCESS);
1290 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.00Z", true);
1291 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1292 CHECK_DATE(obj3, true, false, 0, "", true);
1293
1294 /* Copy assignments: */
1295 RTCRestDate obj3Epoch_3339_9;
1296 RTTESTI_CHECK_RC(obj3Epoch_3339_9.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_9), VINF_SUCCESS);
1297 CHECK_DATE(obj3Epoch_3339_9, false, true, 0, "1970-01-01T00:00:00.000000000Z", true);
1298
1299 RTCRestDate obj3Epoch_7131;
1300 RTTESTI_CHECK_RC(obj3Epoch_7131.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc7131), VINF_SUCCESS);
1301 CHECK_DATE(obj3Epoch_7131, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true);
1302
1303 RTCRestDate obj3Recent_3339;
1304 RTTESTI_CHECK_RC(obj3Recent_3339.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc3339), VINF_SUCCESS);
1305 CHECK_DATE(obj3Recent_3339, false, true, iRecent, "2018-09-10T11:58:07Z", true);
1306
1307 RTCRestDate obj3Recent_2822;
1308 RTTESTI_CHECK_RC(obj3Recent_2822.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1309 CHECK_DATE(obj3Recent_2822, false, true, iRecent, "Mon, 10 Sep 2018 11:58:07 -0000", true);
1310
1311 RTCRestDate const obj3Null;
1312 CHECK_DATE(obj3Null, true, false, 0, "", true);
1313
1314 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1315 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Epoch_3339_9), VINF_SUCCESS);
1316 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.000000000Z", true);
1317
1318 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1319 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Epoch_7131), VINF_SUCCESS);
1320 CHECK_DATE(obj3, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true);
1321
1322 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Recent_3339), VINF_SUCCESS);
1323 CHECK_DATE(obj3Recent_2822, false, true, iRecent, "Mon, 10 Sep 2018 11:58:07 -0000", true);
1324
1325 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Null), VINF_SUCCESS);
1326 CHECK_DATE(obj3, true, false, 0, "", true);
1327
1328 obj3 = obj3Recent_2822;
1329 CHECK_DATE(obj3Recent_2822, false, true, iRecent, "Mon, 10 Sep 2018 11:58:07 -0000", true);
1330
1331 obj3 = obj3Epoch_3339_9;
1332 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.000000000Z", true);
1333
1334 obj3 = obj3Null;
1335 CHECK_DATE(obj3, true, false, 0, "", true);
1336
1337 /* Copy constructors: */
1338 {
1339 RTCRestDate obj3a(obj3Epoch_3339_9);
1340 CHECK_DATE(obj3a, false, true, 0, "1970-01-01T00:00:00.000000000Z", true);
1341 }
1342 {
1343 RTCRestDate obj3b(obj3Epoch_7131);
1344 CHECK_DATE(obj3b, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true);
1345 }
1346 {
1347 RTCRestDate obj3c(obj3Recent_3339);
1348 CHECK_DATE(obj3Recent_3339, false, true, iRecent, "2018-09-10T11:58:07Z", true);
1349 }
1350 {
1351 RTCRestDate obj3d(obj3Recent_2822);
1352 CHECK_DATE(obj3d, false, true, iRecent, "Mon, 10 Sep 2018 11:58:07 -0000", true);
1353 }
1354 {
1355 RTCRestDate obj3e(obj3Null);
1356 CHECK_DATE(obj3e, true, false, 0, "", true);
1357 }
1358
1359 /* Serialization to json: */
1360 const char *pszJson = toJson(&obj3Epoch_3339_9);
1361 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"1970-01-01T00:00:00.000000000Z\"") == 0, ("pszJson=%s\n", pszJson));
1362 pszJson = toJson(&obj3Epoch_7131);
1363 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"Thu, 1 Jan 1970 00:00:00 GMT\"") == 0, ("pszJson=%s\n", pszJson));
1364 pszJson = toJson(&obj3Recent_3339);
1365 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"2018-09-10T11:58:07Z\"") == 0, ("pszJson=%s\n", pszJson));
1366 pszJson = toJson(&obj3Recent_2822);
1367 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"Mon, 10 Sep 2018 11:58:07 -0000\"") == 0, ("pszJson=%s\n", pszJson));
1368 pszJson = toJson(&obj3Null);
1369 RTTESTI_CHECK_MSG(strcmp(pszJson, "null") == 0, ("pszJson=%s\n", pszJson));
1370
1371 /* Serialization to string. */
1372 RTCString str;
1373 str = "lead-in:";
1374 RTTESTI_CHECK_RC(obj3Epoch_7131.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1375 RTTESTI_CHECK_MSG(str.equals("lead-in:Thu, 1 Jan 1970 00:00:00 GMT"), ("str=%s\n", str.c_str()));
1376 RTTESTI_CHECK_RC(obj3Epoch_7131.toString(&str), VINF_SUCCESS);
1377 RTTESTI_CHECK_MSG(str.equals("Thu, 1 Jan 1970 00:00:00 GMT"), ("str=%s\n", str.c_str()));
1378
1379 str = "lead-in:";
1380 RTTESTI_CHECK_RC(obj3Recent_3339.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1381 RTTESTI_CHECK_MSG(str.equals("lead-in:2018-09-10T11:58:07Z"), ("str=%s\n", str.c_str()));
1382 RTTESTI_CHECK_RC(obj3Recent_3339.toString(&str), VINF_SUCCESS);
1383 RTTESTI_CHECK_MSG(str.equals("2018-09-10T11:58:07Z"), ("str=%s\n", str.c_str()));
1384
1385 str = "lead-in:";
1386 RTTESTI_CHECK_RC(obj3Null.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1387 RTTESTI_CHECK_MSG(str.equals("lead-in:null"), ("str=%s\n", str.c_str()));
1388 RTTESTI_CHECK_RC(obj3Null.toString(&str), VINF_SUCCESS);
1389 RTTESTI_CHECK_MSG(str.equals("null"), ("str=%s\n", str.c_str()));
1390 }
1391
1392 /* deserialize: */
1393 RTERRINFOSTATIC ErrInfo;
1394 {
1395 RTCRestDate obj4;
1396 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"Thu, 1 Jan 1970 00:00:00 GMT\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1397 CHECK_DATE_FMT(obj4, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true, RTCRestDate::kFormat_Rfc7131);
1398
1399 obj4.setNull();
1400 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"Thu, 1 Jan 1970 00:00:00.0000 GMT\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1401 CHECK_DATE_FMT(obj4, false, true, 0, "Thu, 1 Jan 1970 00:00:00.0000 GMT", true, RTCRestDate::kFormat_Rfc7131);
1402
1403 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"1 Jan 1970 00:00:00 GMT\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1404 CHECK_DATE_FMT(obj4, false, true, 0, "1 Jan 1970 00:00:00 GMT", true, RTCRestDate::kFormat_Rfc7131);
1405
1406 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"1 Jan 1970 00:00:00\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1407 CHECK_DATE_FMT(obj4, false, true, 0, "1 Jan 1970 00:00:00", false, RTCRestDate::kFormat_Rfc2822);
1408
1409 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"1 Jan 070 00:00:00\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1410 CHECK_DATE_FMT(obj4, false, true, 0, "1 Jan 070 00:00:00", false, RTCRestDate::kFormat_Rfc2822);
1411
1412 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"2018-09-10T11:58:07Z\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1413 CHECK_DATE_FMT(obj4, false, true, iRecentSec , "2018-09-10T11:58:07Z", true, RTCRestDate::kFormat_Rfc3339);
1414
1415 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"1 Jan 70 00:00:00\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1416 CHECK_DATE_FMT(obj4, false, true, 0, "1 Jan 70 00:00:00", false, RTCRestDate::kFormat_Rfc2822);
1417
1418 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"2018-09-10T11:58:07.739632500Z\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1419 CHECK_DATE_FMT(obj4, false, true, iRecent, "2018-09-10T11:58:07.739632500Z", true, RTCRestDate::kFormat_Rfc3339_Fraction_9);
1420
1421 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1422 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc3339_Fraction_9);
1423
1424 /* object goes to default state if not string and to non-okay if string: */
1425 RTTESTI_CHECK_RC(obj4.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1426 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "true", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DATE);
1427 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc2822);
1428
1429 RTTESTI_CHECK_RC(obj4.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1430 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"string\"", &ErrInfo, RT_XSTR(__LINE__)), VWRN_REST_UNABLE_TO_DECODE_DATE);
1431 CHECK_DATE_FMT(obj4, false, false, 0, "string", false, RTCRestDate::kFormat_Rfc2822);
1432
1433 RTTESTI_CHECK_RC(obj4.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1434 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"0x199 string\"", &ErrInfo, RT_XSTR(__LINE__)), VWRN_REST_UNABLE_TO_DECODE_DATE);
1435 CHECK_DATE_FMT(obj4, false, false, 0, "0x199 string", false, RTCRestDate::kFormat_Rfc2822);
1436
1437 RTTESTI_CHECK_RC(obj4.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1438 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "[ null ]", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DATE);
1439 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc2822);
1440
1441 RTTESTI_CHECK_RC(obj4.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1442 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "{ \"foo\": 1 }", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DATE);
1443 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc2822);
1444
1445 /* From string: */
1446 obj4.setNull();
1447 RTTESTI_CHECK_RC(fromString(&obj4, "Thu, 1 Jan 1970 00:00:00 GMT", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1448 CHECK_DATE_FMT(obj4, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true, RTCRestDate::kFormat_Rfc7131);
1449
1450 RTTESTI_CHECK_RC(fromString(&obj4, "Mon, 10 Sep 2018 11:58:07 -0000", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1451 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "Mon, 10 Sep 2018 11:58:07 -0000", true, RTCRestDate::kFormat_Rfc2822);
1452
1453 RTTESTI_CHECK_RC(fromString(&obj4, "\t\n\rnull;\r\n\t", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1454 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc2822);
1455
1456 RTTESTI_CHECK_RC(fromString(&obj4, "Mon, 10 Sep 2018 11:58:07 +0000", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1457 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "Mon, 10 Sep 2018 11:58:07 +0000", false, RTCRestDate::kFormat_Rfc2822);
1458
1459 RTTESTI_CHECK_RC(fromString(&obj4, "1970-01-01T00:00:00.000000000Z", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1460 CHECK_DATE_FMT(obj4, false, true, 0, "1970-01-01T00:00:00.000000000Z", true, RTCRestDate::kFormat_Rfc3339_Fraction_9);
1461
1462 RTTESTI_CHECK_RC(fromString(&obj4, "10 Sep 2018 11:58:07 -0000", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1463 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "10 Sep 2018 11:58:07 -0000", true, RTCRestDate::kFormat_Rfc2822);
1464
1465 RTTESTI_CHECK_RC(fromString(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1466 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc2822);
1467
1468 RTTESTI_CHECK_RC(fromString(&obj4, "Mon, 10 Sep 18 11:58:07 -0000", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1469 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "Mon, 10 Sep 18 11:58:07 -0000", true, RTCRestDate::kFormat_Rfc2822);
1470
1471 RTTESTI_CHECK_RC(fromString(&obj4, "fa;se", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_UNABLE_TO_DECODE_DATE);
1472 CHECK_DATE_FMT(obj4, false, false, 0, "fa;se", false, RTCRestDate::kFormat_Rfc2822);
1473
1474 RTTESTI_CHECK_RC(fromString(&obj4, "10 Sep 18 11:58:07", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1475 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "10 Sep 18 11:58:07", false, RTCRestDate::kFormat_Rfc2822);
1476
1477 obj4.setNull();
1478 RTTESTI_CHECK_RC(fromString(&obj4, "10 Sep 118 11:58:07", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1479 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "10 Sep 118 11:58:07", false, RTCRestDate::kFormat_Rfc2822);
1480 }
1481}
1482
1483
1484/** Wraps RTCRestInt16 to check for leaks. */
1485class MyRestInt16 : public RTCRestInt16
1486{
1487public:
1488 static size_t s_cInstances;
1489 MyRestInt16() : RTCRestInt16() { s_cInstances++; /*printf("%p: default %02u; cInstances %zu\n", this, m_iValue, s_cInstances);*/ }
1490 MyRestInt16(MyRestInt16 const &a_rThat) : RTCRestInt16(a_rThat) { s_cInstances++; /*printf("%p: copy %02u; cInstances %zu\n", this, m_iValue, s_cInstances);*/ }
1491 MyRestInt16(int16_t a_iValue) : RTCRestInt16(a_iValue) { s_cInstances++; /*printf("%p: value %02u; cInstances %zu\n", this, m_iValue, s_cInstances);*/ }
1492 ~MyRestInt16() { s_cInstances--; /*printf("%p: delete %02u; cInstances %zu\n", this, m_iValue, s_cInstances);*/ }
1493 virtual RTCRestObjectBase *baseClone() const RT_NOEXCEPT RT_OVERRIDE { /*printf("clone\n");*/ return new MyRestInt16(*this); }
1494};
1495
1496size_t MyRestInt16::s_cInstances = 0;
1497
1498
1499static void verifyArray(RTCRestArray<MyRestInt16> const &rArray, int iLine, unsigned cElements, ...)
1500{
1501 if (rArray.size() != cElements)
1502 RTTestIFailed("line %u: size() -> %zu, expected %u", iLine, rArray.size(), cElements);
1503 va_list va;
1504 va_start(va, cElements);
1505 for (unsigned i = 0; i < cElements; i++)
1506 {
1507 int iExpected = va_arg(va, int);
1508 if (rArray.at(i)->m_iValue != iExpected)
1509 RTTestIFailed("line %u: element #%u: %d, expected %d", iLine, i, rArray.at(i)->m_iValue, iExpected);
1510 }
1511 va_end(va);
1512}
1513
1514
1515static void testArray()
1516{
1517 RTTestSub(g_hTest, "RTCRestArray");
1518
1519 {
1520 RTCRestArray<RTCRestBool> obj1;
1521 RTTESTI_CHECK(obj1.size() == 0);
1522 RTTESTI_CHECK(obj1.isEmpty() == true);
1523 RTTESTI_CHECK(obj1.isNull() == false);
1524 RTTESTI_CHECK(strcmp(obj1.typeName(), "RTCRestArray<ElementType>") == 0);
1525 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_Array);
1526 }
1527
1528 /* Some random order insertion and manipulations: */
1529 {
1530 RTCRestArray<MyRestInt16> Arr2;
1531 RTCRestArray<MyRestInt16> const *pConstArr2 = &Arr2;
1532
1533 RTTESTI_CHECK_RC(Arr2.insert(0, new MyRestInt16(3)), VINF_SUCCESS);
1534 verifyArray(Arr2, __LINE__, 1, 3);
1535 RTTESTI_CHECK_RC(Arr2.append( new MyRestInt16(7)), VINF_SUCCESS);
1536 verifyArray(Arr2, __LINE__, 2, 3, 7);
1537 RTTESTI_CHECK_RC(Arr2.insert(1, new MyRestInt16(5)), VINF_SUCCESS);
1538 verifyArray(Arr2, __LINE__, 3, 3, 5, 7);
1539 RTTESTI_CHECK_RC(Arr2.insert(2, new MyRestInt16(6)), VINF_SUCCESS);
1540 verifyArray(Arr2, __LINE__, 4, 3, 5, 6, 7);
1541 RTTESTI_CHECK_RC(Arr2.prepend( new MyRestInt16(0)), VINF_SUCCESS);
1542 verifyArray(Arr2, __LINE__, 5, 0, 3, 5, 6, 7);
1543 RTTESTI_CHECK_RC(Arr2.append( new MyRestInt16(9)), VINF_SUCCESS);
1544 verifyArray(Arr2, __LINE__, 6, 0, 3, 5, 6, 7, 9);
1545 RTTESTI_CHECK_RC(Arr2.insert(5, new MyRestInt16(8)), VINF_SUCCESS);
1546 verifyArray(Arr2, __LINE__, 7, 0, 3, 5, 6, 7, 8, 9);
1547 RTTESTI_CHECK_RC(Arr2.insert(1, new MyRestInt16(1)), VINF_SUCCESS);
1548 verifyArray(Arr2, __LINE__, 8, 0, 1, 3, 5, 6, 7, 8, 9);
1549 RTTESTI_CHECK_RC(Arr2.insert(3, new MyRestInt16(4)), VINF_SUCCESS);
1550 verifyArray(Arr2, __LINE__, 9, 0, 1, 3, 4, 5, 6, 7, 8, 9);
1551 RTTESTI_CHECK_RC(Arr2.insert(2, new MyRestInt16(2)), VINF_SUCCESS);
1552 verifyArray(Arr2, __LINE__, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
1553 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1554
1555 RTTESTI_CHECK(Arr2.size() == 10);
1556
1557 for (size_t i = 0; i < Arr2.size(); i++)
1558 {
1559 MyRestInt16 *pCur = Arr2.at(i);
1560 RTTESTI_CHECK(pCur->m_iValue == (int16_t)i);
1561
1562 MyRestInt16 const *pCur2 = pConstArr2->at(i);
1563 RTTESTI_CHECK(pCur2->m_iValue == (int16_t)i);
1564 }
1565
1566 RTTESTI_CHECK_RC(Arr2.replace(2, new MyRestInt16(22)), VWRN_ALREADY_EXISTS);
1567 verifyArray(Arr2, __LINE__, 10, 0, 1, 22, 3, 4, 5, 6, 7, 8, 9);
1568
1569 RTTESTI_CHECK_RC(Arr2.replace(7, new MyRestInt16(77)), VWRN_ALREADY_EXISTS);
1570 verifyArray(Arr2, __LINE__, 10, 0, 1, 22, 3, 4, 5, 6, 77, 8, 9);
1571
1572 RTTESTI_CHECK_RC(Arr2.replace(10, new MyRestInt16(10)), VINF_SUCCESS);
1573 verifyArray(Arr2, __LINE__, 11, 0, 1, 22, 3, 4, 5, 6, 77, 8, 9, 10);
1574
1575 RTTESTI_CHECK_RC(Arr2.replaceCopy(2, MyRestInt16(2)), VWRN_ALREADY_EXISTS);
1576 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1577 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1578
1579 /* copy constructor: */
1580 {
1581 RTCRestArray<MyRestInt16> const Arr2Copy(Arr2);
1582 verifyArray(Arr2Copy, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1583 }
1584 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1585 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1586
1587 {
1588 RTCRestArray<MyRestInt16> Arr2Copy2(Arr2);
1589 verifyArray(Arr2Copy2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1590 RTTESTI_CHECK_RC(Arr2Copy2.removeAt(7), VINF_SUCCESS);
1591 verifyArray(Arr2Copy2, __LINE__, 10, 0, 1, 2, 3, 4, 5, 6, 8, 9, 10);
1592 }
1593 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1594 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1595
1596 /* copy method + clear: */
1597 {
1598 RTCRestArray<MyRestInt16> Arr2Copy3;
1599 RTTESTI_CHECK_RC(Arr2Copy3.assignCopy(Arr2), VINF_SUCCESS);
1600 verifyArray(Arr2Copy3, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1601 Arr2Copy3.at(3)->m_iValue = 33;
1602 verifyArray(Arr2Copy3, __LINE__, 11, 0, 1, 2, 33, 4, 5, 6, 77, 8, 9, 10);
1603 Arr2Copy3.clear();
1604 verifyArray(Arr2Copy3, __LINE__, 0);
1605 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1606 }
1607 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1608 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1609
1610 /* Check setNull and resetToDefaults with copies: */
1611 {
1612 RTCRestArray<MyRestInt16> Arr2Copy4(Arr2);
1613 verifyArray(Arr2Copy4, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1614
1615 RTTESTI_CHECK_RC(Arr2Copy4.setNull(), VINF_SUCCESS);
1616 verifyArray(Arr2Copy4, __LINE__, 0);
1617 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1618 RTTESTI_CHECK(Arr2Copy4.isNull() == true);
1619
1620 RTTESTI_CHECK_RC(Arr2Copy4.resetToDefault(), VINF_SUCCESS);
1621 RTTESTI_CHECK(Arr2Copy4.isNull() == false);
1622 verifyArray(Arr2Copy4, __LINE__, 0);
1623 }
1624 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1625 {
1626 RTCRestArray<MyRestInt16> Arr2Copy5(Arr2);
1627 verifyArray(Arr2Copy5, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1628
1629 RTTESTI_CHECK_RC(Arr2Copy5.resetToDefault(), VINF_SUCCESS);
1630 verifyArray(Arr2Copy5, __LINE__, 0);
1631 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1632 RTTESTI_CHECK(Arr2Copy5.isNull() == false);
1633
1634 RTTESTI_CHECK_RC(Arr2Copy5.setNull(), VINF_SUCCESS);
1635 RTTESTI_CHECK(Arr2Copy5.isNull() == true);
1636
1637 RTTESTI_CHECK_RC(Arr2Copy5.append(new MyRestInt16(100)), VINF_SUCCESS);
1638 RTTESTI_CHECK(Arr2Copy5.isNull() == false);
1639 verifyArray(Arr2Copy5, __LINE__, 1, 100);
1640 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size() + 1, ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size() + 1));
1641 }
1642 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1643
1644 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1645 }
1646 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == 0, ("%zu\n", MyRestInt16::s_cInstances));
1647
1648 {
1649 RTCRestArray<RTCRestInt64> Arr3;
1650 RTCRestArray<RTCRestInt64> const *pConstArr3 = &Arr3;
1651
1652 /* Insert a range of numbers into a int64 array. */
1653 for (int64_t i = 0; i < _64K; i++)
1654 {
1655 if (i & 1)
1656 {
1657 RTCRestInt64 toCopy(i);
1658 if (i & 2)
1659 RTTESTI_CHECK_RC(Arr3.insertCopy(i, toCopy), VINF_SUCCESS);
1660 else
1661 RTTESTI_CHECK_RC(Arr3.appendCopy(toCopy), VINF_SUCCESS);
1662 }
1663 else
1664 {
1665 RTCRestInt64 *pDirect = new RTCRestInt64(i);
1666 if (i & 2)
1667 RTTESTI_CHECK_RC(Arr3.insert(i, pDirect), VINF_SUCCESS);
1668 else
1669 RTTESTI_CHECK_RC(Arr3.append(pDirect), VINF_SUCCESS);
1670 }
1671 RTTESTI_CHECK(Arr3.size() == (size_t)i + 1);
1672 RTTESTI_CHECK(Arr3.isEmpty() == false);
1673 }
1674
1675 /* Verify insertions: */
1676 size_t cElements = _64K;
1677 RTTESTI_CHECK(Arr3.size() == cElements);
1678
1679 for (int64_t i = 0; i < _64K; i++)
1680 {
1681 RTCRestInt64 *pCur = Arr3.at(i);
1682 RTTESTI_CHECK(pCur->m_iValue == i);
1683
1684 RTCRestInt64 const *pCur2 = pConstArr3->at(i);
1685 RTTESTI_CHECK(pCur2->m_iValue == i);
1686 }
1687 RTTESTI_CHECK(Arr3.first()->m_iValue == 0);
1688 RTTESTI_CHECK(Arr3.last()->m_iValue == _64K - 1);
1689 RTTESTI_CHECK(pConstArr3->first()->m_iValue == 0);
1690 RTTESTI_CHECK(pConstArr3->last()->m_iValue == _64K - 1);
1691
1692 /* Remove every 3rd element: */
1693 RTTESTI_CHECK(Arr3.size() == cElements);
1694 for (int64_t i = _64K - 1; i >= 0; i -= 3)
1695 {
1696 RTTESTI_CHECK_RC(Arr3.removeAt(i), VINF_SUCCESS);
1697 cElements--;
1698 RTTESTI_CHECK(Arr3.size() == cElements);
1699 }
1700
1701 /* Verify after removal: */
1702 for (int64_t i = 0, iValue = 0; i < (ssize_t)Arr3.size(); i++, iValue++)
1703 {
1704 if ((iValue % 3) == 0)
1705 iValue++;
1706 RTTESTI_CHECK_MSG(Arr3.at(i)->m_iValue == iValue, ("%RI64: %RI64 vs %RI64\n", i, Arr3.at(i)->m_iValue, iValue));
1707 }
1708
1709 /* Clear it and we're done: */
1710 Arr3.clear();
1711 RTTESTI_CHECK(Arr3.size() == 0);
1712 RTTESTI_CHECK(Arr3.isEmpty() == true);
1713 }
1714
1715 {
1716 RTCRestArray<RTCRestInt32> Arr4;
1717
1718 /* Insert a range of numbers into a int32 array, in reverse order. */
1719 for (int32_t i = 0; i < 2048; i++)
1720 {
1721 if (i & 1)
1722 {
1723 RTCRestInt32 toCopy(i);
1724 if (i & 2)
1725 RTTESTI_CHECK_RC(Arr4.insertCopy(0, toCopy), VINF_SUCCESS);
1726 else
1727 RTTESTI_CHECK_RC(Arr4.prependCopy(toCopy), VINF_SUCCESS);
1728 }
1729 else
1730 {
1731 RTCRestInt32 *pDirect = new RTCRestInt32(i);
1732 if (i & 2)
1733 RTTESTI_CHECK_RC(Arr4.insert(0, pDirect), VINF_SUCCESS);
1734 else
1735 RTTESTI_CHECK_RC(Arr4.prepend(pDirect), VINF_SUCCESS);
1736 }
1737 RTTESTI_CHECK((ssize_t)Arr4.size() == i + 1);
1738 RTTESTI_CHECK(Arr4.isEmpty() == false);
1739 }
1740
1741 for (int32_t i = 0, iValue = (int32_t)Arr4.size() - 1; i < (ssize_t)Arr4.size(); i++, iValue--)
1742 RTTESTI_CHECK_MSG(Arr4.at(i)->m_iValue == iValue, ("%RI32: %RI32 vs %RI32\n", i, Arr4.at(i)->m_iValue, iValue));
1743
1744 for (int32_t i = 0; i < 512; i++)
1745 RTTESTI_CHECK_RC(Arr4.removeAt(0), VINF_SUCCESS);
1746 RTTESTI_CHECK(Arr4.size() == 1536);
1747
1748 for (int32_t i = 0; i < 512; i++)
1749 RTTESTI_CHECK_RC(Arr4.removeAt(~(size_t)0), VINF_SUCCESS);
1750 RTTESTI_CHECK(Arr4.size() == 1024);
1751
1752 for (int32_t i = 0, iValue = 1535; i < (ssize_t)Arr4.size(); i++, iValue--)
1753 RTTESTI_CHECK_MSG(Arr4.at(i)->m_iValue == iValue, ("%RI32: %RI32 vs %RI32\n", i, Arr4.at(i)->m_iValue, iValue));
1754 }
1755}
1756
1757
1758static void verifyMap(RTCRestStringMap<MyRestInt16> const &rMap, int iLine, unsigned cEntries, ...)
1759{
1760 if (rMap.size() != cEntries)
1761 RTTestIFailed("line %u: size() -> %zu, expected %u", iLine, rMap.size(), cEntries);
1762 if (rMap.isEmpty() != (cEntries ? false : true))
1763 RTTestIFailed("line %u: isEmpty() -> %RTbool, with %u entries", iLine, rMap.isEmpty(), cEntries);
1764
1765 va_list va;
1766 va_start(va, cEntries);
1767 for (unsigned i = 0; i < cEntries; i++)
1768 {
1769 const char *pszKey = va_arg(va, const char *);
1770 int iValue = va_arg(va, int);
1771 if ( rMap.containsKey(pszKey) != true
1772 || rMap.containsKey(RTCString(pszKey)) != true
1773 || rMap.get(pszKey) == NULL
1774 || rMap.get(RTCString(pszKey)) == NULL)
1775 RTTestIFailed("line %u: entry '%s' not found!", iLine, pszKey);
1776 else if (rMap.get(pszKey)->m_iValue != iValue)
1777 RTTestIFailed("line %u: entry '%s' value mismatch: %d, expected %d",
1778 iLine, pszKey, rMap.get(pszKey)->m_iValue, iValue);
1779 RTTESTI_CHECK(rMap.get(pszKey) == rMap.get(RTCString(pszKey)));
1780 }
1781 va_end(va);
1782 RTTESTI_CHECK(rMap.isNull() == false);
1783
1784 uint64_t fFound = 0;
1785 for (RTCRestStringMapBase::ConstIterator it = rMap.begin(); it != rMap.end(); ++it)
1786 {
1787 MyRestInt16 const *pObj = (MyRestInt16 const *)it.getValue();
1788 RTTESTI_CHECK(RT_VALID_PTR(pObj));
1789
1790 bool fFoundIt = false;
1791 va_start(va, cEntries);
1792 for (unsigned i = 0; i < cEntries; i++)
1793 {
1794 const char *pszKey = va_arg(va, const char *);
1795 int iValue = va_arg(va, int);
1796 if (it.getKey().equals(pszKey))
1797 {
1798 if (fFound & RT_BIT_64(i))
1799 RTTestIFailed("line %u: base enum: entry '%s' returned more than once!", iLine, pszKey);
1800 if (pObj->m_iValue != iValue)
1801 RTTestIFailed("line %u: base enum: entry '%s' value mismatch: %d, expected %d",
1802 iLine, pszKey, pObj->m_iValue, iValue);
1803 fFound |= RT_BIT_64(i);
1804 fFoundIt = true;
1805 va_end(va);
1806 return;
1807 }
1808 }
1809 va_end(va);
1810 if (!fFoundIt)
1811 RTTestIFailed("line %u: base enum: entry '%s' not expected!", iLine, it.getKey().c_str());
1812 }
1813}
1814
1815
1816void testStringMap(void)
1817{
1818 RTTestSub(g_hTest, "RTCRestMap");
1819
1820 {
1821 RTCRestStringMap<RTCRestString> obj1;
1822 RTTESTI_CHECK(obj1.size() == 0);
1823 RTTESTI_CHECK(obj1.isEmpty() == true);
1824 RTTESTI_CHECK(obj1.isNull() == false);
1825 RTTESTI_CHECK(strcmp(obj1.typeName(), "RTCRestStringMap<ValueType>") == 0);
1826 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_StringMap);
1827 }
1828
1829 /* Basic operations: */
1830 {
1831 MyRestInt16::s_cInstances = 0;
1832 RTCRestStringMap<MyRestInt16> Map2;
1833 verifyMap(Map2, __LINE__, 0);
1834
1835 RTTESTI_CHECK_RC(Map2.putCopy("0x0004", MyRestInt16(4)), VINF_SUCCESS);
1836 verifyMap(Map2, __LINE__, 1, "0x0004", 4);
1837 RTTESTI_CHECK(MyRestInt16::s_cInstances == 1);
1838 RTTESTI_CHECK_RC(Map2.put("0x0001", new MyRestInt16(1)), VINF_SUCCESS);
1839 verifyMap(Map2, __LINE__, 2, "0x0004",4, "0x0001",1);
1840 RTTESTI_CHECK_RC(Map2.put("0x0003", new MyRestInt16(3)), VINF_SUCCESS);
1841 verifyMap(Map2, __LINE__, 3, "0x0004",4, "0x0001",1, "0x0003",3);
1842 RTTESTI_CHECK_RC(Map2.put("0x0002", new MyRestInt16(2)), VINF_SUCCESS);
1843 verifyMap(Map2, __LINE__, 4, "0x0004",4, "0x0001",1, "0x0003",3, "0x0002",2);
1844 RTTESTI_CHECK(MyRestInt16::s_cInstances == 4);
1845 RTTESTI_CHECK_RC(Map2.put("0x0000", new MyRestInt16(0)), VINF_SUCCESS);
1846 verifyMap(Map2, __LINE__, 5, "0x0004",4, "0x0001",1, "0x0003",3, "0x0002",2, "0x0000",0);
1847 RTTESTI_CHECK(MyRestInt16::s_cInstances == 5);
1848 RTTESTI_CHECK_RC(Map2.putCopy("towel", MyRestInt16(42)), VINF_SUCCESS);
1849 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0003",3, "0x0002",2, "0x0000",0, "towel",42);
1850 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1851
1852 RTTESTI_CHECK(Map2.containsKey("0x0005") == false);
1853 RTTESTI_CHECK(Map2.get("0x0005") == NULL);
1854
1855 RTTESTI_CHECK(Map2.remove("0x0003") == true);
1856 verifyMap(Map2, __LINE__, 5, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42);
1857 RTTESTI_CHECK(MyRestInt16::s_cInstances == 5);
1858
1859 RTTESTI_CHECK(Map2.remove("0x0003") == false);
1860 verifyMap(Map2, __LINE__, 5, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42);
1861 RTTESTI_CHECK(MyRestInt16::s_cInstances == 5);
1862
1863 RTCRestObjectBase *pNewBase = NULL;
1864 RTTESTI_CHECK_RC(Map2.putNewValue(&pNewBase, "putNewValue"), VINF_SUCCESS);
1865 ((MyRestInt16 *)pNewBase)->m_iValue = 88;
1866 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1867 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",88);
1868
1869 pNewBase = NULL;
1870 RTTESTI_CHECK_RC(Map2.putNewValue(&pNewBase, RTCString("putNewValue")), VERR_ALREADY_EXISTS);
1871 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",88);
1872 pNewBase = NULL;
1873 RTTESTI_CHECK_RC(Map2.putNewValue(&pNewBase, RTCString("putNewValue"), true /*a_fReplace*/), VWRN_ALREADY_EXISTS);
1874 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1875 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1876
1877 /* Make copy and remove all: */
1878 {
1879 RTCRestStringMap<MyRestInt16> Map2Copy1;
1880
1881 RTTESTI_CHECK_RC(Map2Copy1.assignCopy(Map2), VINF_SUCCESS);
1882 verifyMap(Map2Copy1, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1883 RTTESTI_CHECK(MyRestInt16::s_cInstances == 12);
1884
1885 RTTESTI_CHECK(Map2Copy1.remove("0x0004") == true);
1886 verifyMap(Map2Copy1, __LINE__, 5, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1887 RTTESTI_CHECK(MyRestInt16::s_cInstances == 11);
1888
1889 RTTESTI_CHECK(Map2Copy1.remove("putNewValue") == true);
1890 verifyMap(Map2Copy1, __LINE__, 4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42);
1891 RTTESTI_CHECK(MyRestInt16::s_cInstances == 10);
1892
1893 RTTESTI_CHECK(Map2Copy1.remove("towel") == true);
1894 verifyMap(Map2Copy1, __LINE__, 3, "0x0001",1, "0x0002",2, "0x0000",0);
1895 RTTESTI_CHECK(MyRestInt16::s_cInstances == 9);
1896
1897 RTTESTI_CHECK(Map2Copy1.remove("0x0002") == true);
1898 verifyMap(Map2Copy1, __LINE__, 2, "0x0001",1, "0x0000",0);
1899 RTTESTI_CHECK(MyRestInt16::s_cInstances == 8);
1900
1901 RTTESTI_CHECK(Map2Copy1.remove("0x0000") == true);
1902 verifyMap(Map2Copy1, __LINE__, 1, "0x0001",1);
1903 RTTESTI_CHECK(MyRestInt16::s_cInstances == 7);
1904
1905 RTTESTI_CHECK(Map2Copy1.remove("0x0001") == true);
1906 verifyMap(Map2Copy1, __LINE__, 0);
1907 RTTESTI_CHECK(Map2Copy1.isEmpty() == true);
1908 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1909 }
1910 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1911
1912 /* Make copy and use clear: */
1913 {
1914 RTCRestStringMap<MyRestInt16> Map2Copy2(Map2);
1915 verifyMap(Map2Copy2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1916 RTTESTI_CHECK(MyRestInt16::s_cInstances == 12);
1917 Map2Copy2.clear();
1918 verifyMap(Map2Copy2, __LINE__, 0);
1919 RTTESTI_CHECK(Map2Copy2.isEmpty() == true);
1920 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1921 }
1922 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1923
1924 /* Make copy and reset to default: */
1925 {
1926 RTCRestStringMap<MyRestInt16> Map2Copy3(Map2);
1927 verifyMap(Map2Copy3, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1928 RTTESTI_CHECK(MyRestInt16::s_cInstances == 12);
1929 RTTESTI_CHECK_RC(Map2Copy3.resetToDefault(), VINF_SUCCESS);
1930 verifyMap(Map2Copy3, __LINE__, 0);
1931 RTTESTI_CHECK(Map2Copy3.isEmpty() == true);
1932 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1933 }
1934 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1935
1936 /* Make copy and set to null: */
1937 {
1938 RTCRestStringMap<MyRestInt16> Map2Copy4;
1939 Map2Copy4 = Map2;
1940 verifyMap(Map2Copy4, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1941 RTTESTI_CHECK(MyRestInt16::s_cInstances == 12);
1942 RTTESTI_CHECK_RC(Map2Copy4.setNull(), VINF_SUCCESS);
1943 RTTESTI_CHECK(Map2Copy4.size() == 0);
1944 RTTESTI_CHECK(Map2Copy4.isEmpty() == true);
1945 RTTESTI_CHECK(Map2Copy4.isNull() == true);
1946 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1947 }
1948 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1949 }
1950 RTTESTI_CHECK(MyRestInt16::s_cInstances == 0);
1951
1952 /* Check that null indicator is reset when it should: */
1953 {
1954 RTCRestStringMap<MyRestInt16> Map3;
1955 Map3.setNull();
1956 RTTESTI_CHECK_RC(Map3.setNull(), VINF_SUCCESS);
1957 RTTESTI_CHECK(Map3.size() == 0);
1958 RTTESTI_CHECK(Map3.isEmpty() == true);
1959 RTTESTI_CHECK(Map3.isNull() == true);
1960 RTTESTI_CHECK_RC(Map3.putCopy("not-null-anymore", MyRestInt16(1)), VINF_SUCCESS);
1961 verifyMap(Map3, __LINE__, 1, "not-null-anymore",1);
1962 }
1963 RTTESTI_CHECK(MyRestInt16::s_cInstances == 0);
1964
1965 {
1966 RTCRestStringMap<MyRestInt16> Map4;
1967 Map4.setNull();
1968 RTTESTI_CHECK_RC(Map4.setNull(), VINF_SUCCESS);
1969 RTTESTI_CHECK(Map4.size() == 0);
1970 RTTESTI_CHECK(Map4.isEmpty() == true);
1971 RTTESTI_CHECK(Map4.isNull() == true);
1972 RTCRestObjectBase *pNewBase = NULL;
1973 RTTESTI_CHECK_RC(Map4.putNewValue(&pNewBase, "putNewValue"), VINF_SUCCESS);
1974 verifyMap(Map4, __LINE__, 1, "putNewValue",0);
1975 }
1976 RTTESTI_CHECK(MyRestInt16::s_cInstances == 0);
1977}
1978
1979
1980class TestRequest : public RTCRestClientRequestBase
1981{
1982public:
1983 RTCRestString m_strValue;
1984 RTCRestInt64 m_iValue;
1985 RTCRestArray<RTCRestString> m_Array;
1986 RTCRestStringMap<RTCRestString> m_Map;
1987 /** @todo add more attributes. */
1988
1989 TestRequest(const char *a_pszValue, int64_t a_iValue, unsigned a_cElements, ...)
1990 : RTCRestClientRequestBase()
1991 , m_strValue(a_pszValue)
1992 , m_iValue(a_iValue)
1993 {
1994 m_fIsSet = UINT64_MAX;
1995 va_list va;
1996 va_start(va, a_cElements);
1997 for (unsigned i = 0; i < a_cElements; i++)
1998 m_Array.append(new RTCRestString(va_arg(va, const char *)));
1999 va_end(va);
2000 }
2001
2002 int resetToDefault() RT_NOEXCEPT RT_OVERRIDE
2003 {
2004 m_strValue = "";
2005 m_iValue = 0;
2006 return m_Array.resetToDefault();
2007 }
2008
2009 int xmitPrepare(RTCString *a_pStrPath, RTCString *a_pStrQuery, RTHTTP a_hHttp, RTCString *a_pStrBody) const RT_NOEXCEPT RT_OVERRIDE
2010 {
2011 RT_NOREF(a_pStrPath, a_pStrQuery, a_hHttp, a_pStrBody);
2012 return VINF_SUCCESS;
2013 }
2014
2015 void xmitComplete(int a_rcStatus, RTHTTP a_hHttp) const RT_NOEXCEPT RT_OVERRIDE
2016 {
2017 RT_NOREF(a_rcStatus, a_hHttp);
2018 }
2019
2020 void testPath(const char *a_pszExpected)
2021 {
2022 static PATHPARAMDESC const s_aParams[] =
2023 {
2024 { RT_STR_TUPLE("{string}"), 0, 0 },
2025 { RT_STR_TUPLE("{integer}"), 0, 0 },
2026 { RT_STR_TUPLE("{array}"), 0, 0 },
2027 };
2028 PATHPARAMSTATE aState[] = { { &m_strValue, 0 }, { &m_iValue, 0 }, { &m_Array, 0 } };
2029 RTCString strPath;
2030 RTTESTI_CHECK_RC(doPathParameters(&strPath, RT_STR_TUPLE("my/{integer}/{string}/array:{array}/path"),
2031 s_aParams, aState, RT_ELEMENTS(aState)), VINF_SUCCESS);
2032 RTTESTI_CHECK_MSG(strPath.equals(a_pszExpected), ("actual: '%s'\nexpect: '%s'\n", strPath.c_str(), a_pszExpected));
2033 }
2034
2035 void testQuery(const char *a_pszCsv,
2036 const char *a_pszSsv,
2037 const char *a_pszTsv,
2038 const char *a_pszPipes,
2039 const char *a_pszMulti)
2040 {
2041 QUERYPARAMDESC aParams[] =
2042 {
2043 { "string", 0, true, 0 },
2044 { "integer", 0, true, 0 },
2045 { "array", 0, true, 0 },
2046 };
2047
2048 RTCRestObjectBase const *apObjects[] = { &m_strValue, &m_iValue, &m_Array };
2049 RTCString strQuery;
2050 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2051 RTTESTI_CHECK_MSG(strQuery.equals(a_pszCsv), ("actual: '%s'\nexpect: %s\n", strQuery.c_str(), a_pszCsv));
2052
2053 strQuery.setNull();
2054 aParams[2].fFlags = RTCRestObjectBase::kCollectionFormat_csv;
2055 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2056 RTTESTI_CHECK_MSG(strQuery.equals(a_pszCsv), ("actual: '%s'\nexpect: %s\n", strQuery.c_str(), a_pszCsv));
2057
2058 strQuery.setNull();
2059 aParams[2].fFlags = RTCRestObjectBase::kCollectionFormat_ssv;
2060 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2061 RTTESTI_CHECK_MSG(strQuery.equals(a_pszSsv), ("actual: '%s'\nexpect: %s\n", strQuery.c_str(), a_pszSsv));
2062
2063 strQuery.setNull();
2064 aParams[2].fFlags = RTCRestObjectBase::kCollectionFormat_tsv;
2065 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2066 RTTESTI_CHECK_MSG(strQuery.equals(a_pszTsv), ("actual: '%s'\nexpect: %s\n", strQuery.c_str(), a_pszTsv));
2067
2068 strQuery.setNull();
2069 aParams[2].fFlags = RTCRestObjectBase::kCollectionFormat_pipes;
2070 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2071 RTTESTI_CHECK_MSG(strQuery.equals(a_pszPipes), ("actual: '%s'\nexpect: %s\n", strQuery.c_str(), a_pszPipes));
2072
2073 strQuery.setNull();
2074 aParams[2].fFlags = RTCRestObjectBase::kCollectionFormat_multi;
2075 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2076 RTTESTI_CHECK_MSG(strQuery.equals(a_pszMulti), ("actual: '%s'\nexpect: %s\n", strQuery.c_str(), a_pszMulti));
2077 }
2078
2079 void testHeader(unsigned a_cHeaders, ...)
2080 {
2081 HEADERPARAMDESC aParams[] =
2082 {
2083 { "x-string", 0, true, 0, false },
2084 { "x-integer", 0, true, 0, false },
2085 { "x-array", 0, true, 0, false },
2086 { "x-map-", 0, true, 0, true },
2087 };
2088 RTCRestObjectBase const *apObjects[] = { &m_strValue, &m_iValue, &m_Array, &m_Map };
2089 RTHTTP hHttp = NIL_RTHTTP;
2090 RTTESTI_CHECK_RC(RTHttpCreate(&hHttp), VINF_SUCCESS);
2091 RTTESTI_CHECK_RC(doHeaderParameters(hHttp, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2092 RTTESTI_CHECK(RTHttpGetHeaderCount(hHttp) == a_cHeaders);
2093 va_list va;
2094 va_start(va, a_cHeaders);
2095 for (size_t i = 0; i < a_cHeaders; i++)
2096 {
2097 const char *pszField = va_arg(va, const char *);
2098 const char *pszValue = va_arg(va, const char *);
2099 const char *pszActual = RTHttpGetHeader(hHttp, pszField, RTSTR_MAX);
2100 RTTESTI_CHECK_MSG(RTStrCmp(pszActual, pszValue) == 0,
2101 ("Header '%s' value is '%s' rather than '%s'", pszField, pszActual, pszValue));
2102 }
2103 va_end(va);
2104 RTTESTI_CHECK_RC(RTHttpDestroy(hHttp), VINF_SUCCESS);
2105 }
2106};
2107
2108
2109void testClientRequestBase()
2110{
2111 RTTestSub(g_hTest, "RTCRestClientRequestBase");
2112 {
2113 TestRequest Req1("this-is-a-string", 123456789, 5, "1", "22", "333", "444", "555");
2114 Req1.testPath("my/123456789/this-is-a-string/array:1%2C22%2C333%2C444%2C555/path");
2115 Req1.testQuery("?string=this-is-a-string&integer=123456789&array=1%2C22%2C333%2C444%2C555",
2116 "?string=this-is-a-string&integer=123456789&array=1%2022%20333%20444%20555",
2117 "?string=this-is-a-string&integer=123456789&array=1%0922%09333%09444%09555",
2118 "?string=this-is-a-string&integer=123456789&array=1%7C22%7C333%7C444%7C555",
2119 "?string=this-is-a-string&integer=123456789&array=1&array=22&array=333&array=444&array=555");
2120 Req1.testHeader(3, "x-string","this-is-a-string", "x-integer","123456789", "x-array","1,22,333,444,555");
2121 }
2122 {
2123 TestRequest Req2(";'[]", 42, 3, "null", "foo", "bar");
2124 RTTESTI_CHECK_RC(Req2.m_Map.put("stuff-1", new RTCRestString("stuffy-value-1")), VINF_SUCCESS);
2125 RTTESTI_CHECK_RC(Req2.m_Map.put("stuff-2", new RTCRestString("stuffy-value-2")), VINF_SUCCESS);
2126 RTTESTI_CHECK_RC(Req2.m_Map.put("2222", new RTCRestString("33")), VINF_SUCCESS);
2127 Req2.testPath("my/42/%3B%27%5B%5D/array:null%2Cfoo%2Cbar/path");
2128 Req2.testQuery("?string=%3B%27%5B%5D&integer=42&array=null%2Cfoo%2Cbar",
2129 "?string=%3B%27%5B%5D&integer=42&array=null%20foo%20bar",
2130 "?string=%3B%27%5B%5D&integer=42&array=null%09foo%09bar",
2131 "?string=%3B%27%5B%5D&integer=42&array=null%7Cfoo%7Cbar",
2132 "?string=%3B%27%5B%5D&integer=42&array=null&array=foo&array=bar");
2133 Req2.testHeader(6, "x-string",";'[]", "x-integer","42", "x-array","null,foo,bar",
2134 "x-map-stuff-1","stuffy-value-1",
2135 "x-map-stuff-2","stuffy-value-2",
2136 "x-map-2222","33");
2137 }
2138}
2139
2140
2141class TestResponse : public RTCRestClientResponseBase
2142{
2143public:
2144 RTCRestArray<RTCRestString> *m_pArray;
2145 RTCRestStringMap<RTCRestString> *m_pMap;
2146 RTCRestInt64 *m_pInteger;
2147 RTCRestString *m_pStrContentType;
2148
2149 TestResponse() : m_pArray(NULL), m_pMap(NULL), m_pInteger(NULL), m_pStrContentType(NULL)
2150 { }
2151
2152protected:
2153 virtual int consumeHeader(uint32_t a_uMatchWord, const char *a_pchField, size_t a_cchField,
2154 const char *a_pchValue, size_t a_cchValue) RT_NOEXCEPT RT_OVERRIDE
2155 {
2156 int rc = RTCRestClientResponseBase::consumeHeader(a_uMatchWord, a_pchField, a_cchField, a_pchValue, a_cchValue);
2157 AssertRCReturn(rc, rc);
2158
2159#define MATCH_FIELD(a_sz) (sizeof(a_sz) - 1 == a_cchField && RTStrNICmpAscii(a_pchField, RT_STR_TUPLE(a_sz)) == 0)
2160 if (MATCH_FIELD("x-array"))
2161 {
2162 if (!m_pArray)
2163 {
2164 m_pArray = new (std::nothrow) RTCRestArray<RTCRestString>();
2165 AssertReturn(m_pArray, VERR_NO_MEMORY);
2166 return deserializeHeader(m_pArray, a_pchValue, a_cchValue, RTCRestObjectBase::kCollectionFormat_csv, "x-array");
2167 }
2168 }
2169 else if (a_cchField >= sizeof("x-map-") - 1 && RTStrNICmpAscii(a_pchField, RT_STR_TUPLE("x-map-")) == 0)
2170 {
2171 if (!m_pMap)
2172 {
2173 m_pMap = new (std::nothrow) RTCRestStringMap<RTCRestString>();
2174 AssertReturn(m_pMap, VERR_NO_MEMORY);
2175 }
2176 return deserializeHeaderIntoMap(m_pMap, a_pchField + 6, a_cchField - 6, a_pchValue, a_cchValue, 0, "x-map-");
2177 }
2178 else if (MATCH_FIELD("x-integer"))
2179 {
2180 if (!m_pInteger)
2181 {
2182 m_pInteger = new (std::nothrow) RTCRestInt64();
2183 AssertReturn(m_pInteger, VERR_NO_MEMORY);
2184 return deserializeHeader(m_pInteger, a_pchValue, a_cchValue, 0, "x-integer");
2185 }
2186 }
2187 else if (MATCH_FIELD("content-type"))
2188 {
2189 if (!m_pStrContentType)
2190 {
2191 m_pStrContentType = new (std::nothrow) RTCRestString();
2192 AssertReturn(m_pStrContentType, VERR_NO_MEMORY);
2193 return deserializeHeader(m_pStrContentType, a_pchValue, a_cchValue, 0, "content-type");
2194 }
2195 }
2196 else
2197 return VWRN_NOT_FOUND;
2198 RT_NOREF(a_uMatchWord);
2199 return addError(VERR_ALREADY_EXISTS, "Already have field '%.*s'!", a_cchField, a_pchField);
2200 }
2201
2202public:
2203 int pushHeader(const char *pszField, const char *pszValue)
2204 {
2205 size_t const cchField = strlen(pszField);
2206 void *pvFieldCopy = RTTestGuardedAllocTail(g_hTest, cchField);
2207 RTTESTI_CHECK_RET(pvFieldCopy, VERR_NO_MEMORY);
2208 memcpy(pvFieldCopy, pszField, cchField);
2209
2210 size_t const cchValue = strlen(pszValue);
2211 void *pvValueCopy = RTTestGuardedAllocTail(g_hTest, cchValue);
2212 RTTESTI_CHECK_RET(pvValueCopy, VERR_NO_MEMORY);
2213 memcpy(pvValueCopy, pszValue, cchValue);
2214
2215 uint32_t uWord = RTHTTP_MAKE_HDR_MATCH_WORD(cchField,
2216 cchField >= 1 ? RT_C_TO_LOWER(pszField[0]) : 0,
2217 cchField >= 2 ? RT_C_TO_LOWER(pszField[1]) : 0,
2218 cchField >= 3 ? RT_C_TO_LOWER(pszField[2]) : 0);
2219 int rc = consumeHeader(uWord, (const char *)pvFieldCopy, cchField, (const char *)pvValueCopy, cchValue);
2220 RTTestGuardedFree(g_hTest, pvValueCopy);
2221 RTTestGuardedFree(g_hTest, pvFieldCopy);
2222 return rc;
2223 }
2224};
2225
2226
2227void testClientResponseBase()
2228{
2229 RTTestSub(g_hTest, "RTCRestClientResponseBase");
2230 {
2231 TestResponse Resp1;
2232 RTTESTI_CHECK_RC(Resp1.pushHeader("content-type", "application/json; charset=utf-8"), VINF_SUCCESS);
2233 RTTESTI_CHECK(Resp1.getContentType().equals("application/json; charset=utf-8"));
2234 RTTESTI_CHECK(Resp1.m_pStrContentType && Resp1.m_pStrContentType->equals("application/json; charset=utf-8"));
2235
2236 RTTESTI_CHECK_RC(Resp1.pushHeader("content-typ2", "oopsy daisy"), VWRN_NOT_FOUND);
2237 RTTESTI_CHECK_RC(Resp1.pushHeader("content-type2", "oopsy daisy"), VWRN_NOT_FOUND);
2238 RTTESTI_CHECK(Resp1.getContentType().equals("application/json; charset=utf-8"));
2239 RTTESTI_CHECK(Resp1.m_pStrContentType && Resp1.m_pStrContentType->equals("application/json; charset=utf-8"));
2240
2241 RTTESTI_CHECK_RC(Resp1.pushHeader("x-integer", "398679406"), VINF_SUCCESS);
2242 RTTESTI_CHECK(Resp1.m_pInteger && Resp1.m_pInteger->m_iValue == 398679406);
2243
2244 RTTESTI_CHECK_RC(Resp1.pushHeader("x-array", "zero,one,two,three"), VINF_SUCCESS);
2245 RTTESTI_CHECK(Resp1.m_pArray && Resp1.m_pArray->size() == 4);
2246
2247 RTTESTI_CHECK_RC(Resp1.pushHeader("x-map-", "empty-key"), VINF_SUCCESS);
2248 RTTESTI_CHECK(Resp1.m_pMap && Resp1.m_pMap->size() == 1 && Resp1.m_pMap->get("") != NULL && Resp1.m_pMap->get("")->equals("empty-key"));
2249
2250 RTTESTI_CHECK_RC(Resp1.pushHeader("x-map-42", "key-is-42"), VINF_SUCCESS);
2251 RTTESTI_CHECK(Resp1.m_pMap && Resp1.m_pMap->size() == 2 && Resp1.m_pMap->get("42") != NULL && Resp1.m_pMap->get("42")->equals("key-is-42"));
2252 }
2253}
2254
2255
2256int main()
2257{
2258 RTEXITCODE rcExit = RTTestInitAndCreate("tstRTRest-1", &g_hTest);
2259 if (rcExit == RTEXITCODE_SUCCESS )
2260 {
2261 testBool();
2262 testInteger<RTCRestInt64, int64_t, Int64Constants>();
2263 testInteger<RTCRestInt32, int32_t, Int32Constants>();
2264 testInteger<RTCRestInt16, int16_t, Int16Constants>();
2265 testDouble();
2266 testString("dummy", 1, 2);
2267 testDate();
2268 testArray();
2269 testStringMap();
2270 testClientRequestBase();
2271 testClientResponseBase();
2272
2273 rcExit = RTTestSummaryAndDestroy(g_hTest);
2274 }
2275 return rcExit;
2276}
2277
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette