VirtualBox

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

Last change on this file since 93174 was 93115, checked in by vboxsync, 3 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 102.4 KB
Line 
1/* $Id: tstRTCRest-1.cpp 93115 2022-01-01 11:31:46Z vboxsync $ */
2/** @file
3 * IPRT Testcase - REST C++ classes.
4 */
5
6/*
7 * Copyright (C) 2018-2022 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#define TST_DBL_MAX (1.79769313486231571e+308)
597#define TST_DBL_MIN (2.22507385850720138e-308)
598#define TST_DBL_MAX_STRING1 "1.79769313486231571e+308"
599#define TST_DBL_MAX_STRING2 "1.7976931348623157e+308"
600#define TST_DBL_MAX_EQUAL(a_psz) ( strcmp(a_psz, TST_DBL_MAX_STRING1) == 0 || strcmp(a_psz, TST_DBL_MAX_STRING2) == 0 )
601#define TST_DBL_MIN_STRING1 "2.22507385850720138e-308"
602#define TST_DBL_MIN_STRING2 "2.2250738585072014e-308"
603#define TST_DBL_MIN_EQUAL(a_psz) ( strcmp(a_psz, TST_DBL_MIN_STRING1) == 0 || strcmp(a_psz, TST_DBL_MIN_STRING2) == 0 )
604
605 {
606 RTCRestDouble obj1;
607 RTTESTI_CHECK(obj1.m_rdValue == 0.0);
608 RTTESTI_CHECK(obj1.isNull() == false);
609 RTTESTI_CHECK(strcmp(obj1.typeName(), "double") == 0);
610 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_Double);
611 }
612
613 {
614 RTCRestDouble obj2(2398.1);
615 RTTESTI_CHECK(obj2.m_rdValue == 2398.1);
616 RTTESTI_CHECK(obj2.isNull() == false);
617 }
618
619 {
620 RTCRestDouble obj2(-7345.2);
621 RTTESTI_CHECK(obj2.m_rdValue == -7345.2);
622 RTTESTI_CHECK(obj2.isNull() == false);
623 }
624
625 {
626 /* Value assignments: */
627 RTCRestDouble obj3;
628 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
629 RTTESTI_CHECK(obj3.isNull() == true);
630 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
631 obj3.assignValue(-1.0);
632 RTTESTI_CHECK(obj3.m_rdValue == -1.0);
633 RTTESTI_CHECK(obj3.isNull() == false);
634
635 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
636 RTTESTI_CHECK(obj3.isNull() == true);
637 obj3.assignValue(42.42);
638 RTTESTI_CHECK(obj3.m_rdValue == 42.42);
639 RTTESTI_CHECK(obj3.isNull() == false);
640
641 obj3.assignValue(TST_DBL_MAX);
642 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MAX);
643 RTTESTI_CHECK(obj3.isNull() == false);
644
645 obj3.assignValue(TST_DBL_MIN);
646 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MIN);
647 RTTESTI_CHECK(obj3.isNull() == false);
648
649 /* Reset to default: */
650 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
651 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
652 RTTESTI_CHECK(obj3.isNull() == false);
653
654 obj3.assignValue(42);
655 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
656 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
657 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
658 RTTESTI_CHECK(obj3.isNull() == false);
659
660 /* Copy assignments: */
661 RTCRestDouble obj3Max(TST_DBL_MAX);
662 RTTESTI_CHECK(obj3Max.m_rdValue == TST_DBL_MAX);
663 RTTESTI_CHECK(obj3Max.isNull() == false);
664 RTCRestDouble obj3Min(TST_DBL_MIN);
665 RTTESTI_CHECK(obj3Min.m_rdValue == TST_DBL_MIN);
666 RTTESTI_CHECK(obj3Min.isNull() == false);
667 RTCRestDouble obj3Null;
668 obj3Null.setNull();
669 RTTESTI_CHECK(obj3Null.m_rdValue == 0.0);
670 RTTESTI_CHECK(obj3Null.isNull() == true);
671
672 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
673 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Max), VINF_SUCCESS);
674 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MAX);
675 RTTESTI_CHECK(obj3.isNull() == false);
676
677 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Null), VINF_SUCCESS);
678 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
679 RTTESTI_CHECK(obj3.isNull() == true);
680
681 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Min), VINF_SUCCESS);
682 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MIN);
683 RTTESTI_CHECK(obj3.isNull() == false);
684
685 obj3 = obj3Null;
686 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
687 RTTESTI_CHECK(obj3.isNull() == true);
688
689 obj3 = obj3Max;
690 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MAX);
691 RTTESTI_CHECK(obj3.isNull() == false);
692
693 obj3 = obj3Null;
694 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
695 RTTESTI_CHECK(obj3.isNull() == true);
696
697 obj3 = obj3Min;
698 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MIN);
699 RTTESTI_CHECK(obj3.isNull() == false);
700
701 /* setNull implies resetToDefault: */
702 obj3 = obj3Max;
703 RTTESTI_CHECK(obj3.m_rdValue == TST_DBL_MAX);
704 RTTESTI_CHECK(obj3.isNull() == false);
705 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
706 RTTESTI_CHECK(obj3.isNull() == true);
707 RTTESTI_CHECK(obj3.m_rdValue == 0.0);
708
709 /* Copy constructors: */
710 {
711 RTCRestDouble obj3a(obj3Max);
712 RTTESTI_CHECK(obj3a.m_rdValue == TST_DBL_MAX);
713 RTTESTI_CHECK(obj3a.isNull() == false);
714 }
715 {
716 RTCRestDouble obj3b(obj3Min);
717 RTTESTI_CHECK(obj3b.m_rdValue == TST_DBL_MIN);
718 RTTESTI_CHECK(obj3b.isNull() == false);
719 }
720 {
721 RTCRestDouble obj3c(obj3Null);
722 RTTESTI_CHECK(obj3c.m_rdValue == 0.0);
723 RTTESTI_CHECK(obj3c.isNull() == true);
724 }
725
726 /* Serialization to json: */
727 const char *pszJson = toJson(&obj3Max);
728 RTTESTI_CHECK_MSG(TST_DBL_MAX_EQUAL(pszJson), ("pszJson=%s\n", pszJson));
729 pszJson = toJson(&obj3Min);
730 RTTESTI_CHECK_MSG(TST_DBL_MIN_EQUAL(pszJson), ("pszJson=%s\n", pszJson));
731 pszJson = toJson(&obj3Null);
732 RTTESTI_CHECK_MSG(strcmp(pszJson, "null") == 0, ("pszJson=%s\n", pszJson));
733
734 /* Serialization to string. */
735 RTCString str;
736 RTCString strExpect1;
737 RTCString strExpect2;
738 str = "lead-in:";
739 RTTESTI_CHECK_RC(obj3Max.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
740 strExpect1.printf("lead-in:%s", TST_DBL_MAX_STRING1);
741 strExpect2.printf("lead-in:%s", TST_DBL_MAX_STRING2);
742 RTTESTI_CHECK_MSG(str.equals(strExpect1) || str.equals(strExpect2),
743 ("str=%s strExpect1=%s strExpect2=%s\n", str.c_str(), strExpect1.c_str(), strExpect2.c_str()));
744 RTTESTI_CHECK_RC(obj3Max.toString(&str), VINF_SUCCESS);
745 RTTESTI_CHECK_MSG(TST_DBL_MAX_EQUAL(str.c_str()), ("str=%s\n", str.c_str()));
746
747 str = "lead-in:";
748 RTTESTI_CHECK_RC(obj3Min.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
749 strExpect1.printf("lead-in:%s", TST_DBL_MIN_STRING1);
750 strExpect2.printf("lead-in:%s", TST_DBL_MIN_STRING2);
751 RTTESTI_CHECK_MSG(str.equals(strExpect1) || str.equals(strExpect2),
752 ("str=%s strExpect1=%s strExpect2=%s\n", str.c_str(), strExpect1.c_str(), strExpect2.c_str()));
753 RTTESTI_CHECK_RC(obj3Min.toString(&str), VINF_SUCCESS);
754 RTTESTI_CHECK_MSG(TST_DBL_MIN_EQUAL(str.c_str()), ("str=%s\n", str.c_str()));
755
756 str = "lead-in:";
757 RTTESTI_CHECK_RC(obj3Null.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
758 RTTESTI_CHECK_MSG(str.equals("lead-in:null"), ("str=%s\n", str.c_str()));
759 RTTESTI_CHECK_RC(obj3Null.toString(&str), VINF_SUCCESS);
760 RTTESTI_CHECK_MSG(str.equals("null"), ("str=%s\n", str.c_str()));
761 }
762
763 /* deserialize: */
764 RTERRINFOSTATIC ErrInfo;
765 {
766 /* Some linux systems and probably all solaris fail to parse the longer MIN string, so just detect and skip. */
767 bool fGroksMinString = true;
768#if defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS)
769 RTJSONVAL hTmpValue = NIL_RTJSONVAL;
770 int rcTmp = RTJsonParseFromString(&hTmpValue, TST_DBL_MIN_STRING1, NULL);
771 RTJsonValueRelease(hTmpValue);
772 if (rcTmp == VERR_INVALID_PARAMETER)
773 fGroksMinString = false;
774#endif
775
776 /* from json: */
777 RTCRestDouble obj4;
778 obj4.setNull();
779 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "42.42", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
780 RTTESTI_CHECK(obj4.m_rdValue == 42.42);
781 RTTESTI_CHECK(obj4.isNull() == false);
782
783 obj4.setNull();
784 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "-22.22", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
785 RTTESTI_CHECK(obj4.m_rdValue == -22.22);
786 RTTESTI_CHECK(obj4.isNull() == false);
787
788 obj4.setNull();
789 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, TST_DBL_MAX_STRING1, &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
790 RTTESTI_CHECK(obj4.m_rdValue == TST_DBL_MAX);
791 RTTESTI_CHECK(obj4.isNull() == false);
792
793 if (fGroksMinString)
794 {
795 obj4.setNull();
796 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, TST_DBL_MIN_STRING1, &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
797 RTTESTI_CHECK(obj4.m_rdValue == TST_DBL_MIN);
798 RTTESTI_CHECK(obj4.isNull() == false);
799 }
800
801 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
802 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
803 RTTESTI_CHECK(obj4.isNull() == true);
804
805 obj4.setNull();
806 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "14323", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
807 RTTESTI_CHECK(obj4.m_rdValue == 14323.0);
808 RTTESTI_CHECK(obj4.isNull() == false);
809
810 obj4.setNull();
811 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "-234875", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
812 RTTESTI_CHECK(obj4.m_rdValue == -234875.0);
813 RTTESTI_CHECK(obj4.isNull() == false);
814
815 /* object goes to default state on failure: */
816 obj4.assignValue(TST_DBL_MIN);
817 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "false", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DOUBLE);
818 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
819 RTTESTI_CHECK(obj4.isNull() == false);
820 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
821
822 obj4.assignValue(TST_DBL_MAX);
823 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"false\"", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DOUBLE);
824 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
825 RTTESTI_CHECK(obj4.isNull() == false);
826 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
827
828 obj4.setNull();
829 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "[ null ]", NULL, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DOUBLE);
830 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
831 RTTESTI_CHECK(obj4.isNull() == false);
832
833 /* from string: */
834 obj4.setNull();
835 RTTESTI_CHECK_RC(fromString(&obj4, "22.42", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
836 RTTESTI_CHECK(obj4.m_rdValue == 22.42);
837 RTTESTI_CHECK(obj4.isNull() == false);
838
839 RTTESTI_CHECK_RC(fromString(&obj4, "-42.22", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
840 RTTESTI_CHECK(obj4.m_rdValue == -42.22);
841 RTTESTI_CHECK(obj4.isNull() == false);
842
843 RTTESTI_CHECK_RC(fromString(&obj4, TST_DBL_MAX_STRING1, &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
844 RTTESTI_CHECK(obj4.m_rdValue == TST_DBL_MAX);
845 RTTESTI_CHECK(obj4.isNull() == false);
846
847 if (fGroksMinString)
848 {
849 RTTESTI_CHECK_RC(fromString(&obj4, TST_DBL_MIN_STRING1, &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
850 RTTESTI_CHECK(obj4.m_rdValue == TST_DBL_MIN);
851 RTTESTI_CHECK(obj4.isNull() == false);
852 }
853
854 obj4.m_rdValue = 33.33;
855 RTTESTI_CHECK_RC(fromString(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
856 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
857 RTTESTI_CHECK(obj4.isNull() == true);
858
859 obj4.m_rdValue = 33.33;
860 RTTESTI_CHECK_RC(fromString(&obj4, " nULl;", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
861 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
862 RTTESTI_CHECK(obj4.isNull() == true);
863
864 obj4.setNull();
865 RTTESTI_CHECK_RC(fromString(&obj4, " 42.22 ", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
866 RTTESTI_CHECK(obj4.m_rdValue == 42.22);
867 RTTESTI_CHECK(obj4.isNull() == false);
868
869 RTTESTI_CHECK_RC(fromString(&obj4, "\t010\t", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
870 RTTESTI_CHECK(obj4.m_rdValue ==10.0);
871 RTTESTI_CHECK(obj4.isNull() == false);
872
873 RTTESTI_CHECK_RC(fromString(&obj4, "\r\t03495.344\t\r\n", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
874 RTTESTI_CHECK(obj4.m_rdValue == 3495.344);
875 RTTESTI_CHECK(obj4.isNull() == false);
876
877 RTTESTI_CHECK_RC(fromString(&obj4, "1.1;", &ErrInfo, RT_XSTR(__LINE__)), VERR_TRAILING_CHARS);
878 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
879
880 RTTESTI_CHECK_RC(fromString(&obj4, "false", NULL, RT_XSTR(__LINE__)), VERR_NO_DIGITS);
881
882#if (!defined(RT_OS_SOLARIS) && !defined(RT_OS_WINDOWS)) || RT_MSC_PREREQ(RT_MSC_VER_VS2015)
883 RTTESTI_CHECK_RC(fromString(&obj4, " 0x42 ", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
884 RTTESTI_CHECK(obj4.m_rdValue == 66.0);
885#else
886 RTTESTI_CHECK_RC(fromString(&obj4, " 0x42 ", &ErrInfo, RT_XSTR(__LINE__)), VERR_TRAILING_CHARS);
887 RTTESTI_CHECK(obj4.m_rdValue == 0.0);
888#endif
889 RTTESTI_CHECK(obj4.isNull() == false);
890 }
891}
892
893
894void testString(const char *pszDummy, ...)
895{
896 RTTestSub(g_hTest, "RTCRestString");
897
898 {
899 RTCRestString obj1;
900 RTTESTI_CHECK(obj1.isEmpty());
901 RTTESTI_CHECK(obj1.isNull() == false);
902 RTTESTI_CHECK(strcmp(obj1.typeName(), "RTCString") == 0);
903 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_String);
904 }
905
906 {
907 RTCRestString obj2(RTCString("2398.1"));
908 RTTESTI_CHECK(obj2 == "2398.1");
909 RTTESTI_CHECK(obj2.isNull() == false);
910 }
911
912 {
913 RTCRestString obj2("-7345.2");
914 RTTESTI_CHECK(obj2 == "-7345.2");
915 RTTESTI_CHECK(obj2.isNull() == false);
916 }
917
918 {
919 /* Value assignments: */
920 RTCRestString obj3;
921 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
922 RTTESTI_CHECK(obj3.isNull() == true);
923 RTTESTI_CHECK(obj3.isEmpty());
924 obj3 = "-1.0";
925 RTTESTI_CHECK(obj3 == "-1.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 obj3 = RTCString("-2.0");
931 RTTESTI_CHECK(obj3 == "-2.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 obj3 = RTCRestString("-3.0");
937 RTTESTI_CHECK(obj3 == "-3.0");
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(RTCRestString("4.0")), VINF_SUCCESS);
943 RTTESTI_CHECK(obj3 == "4.0");
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("-4.0"), VINF_SUCCESS);
949 RTTESTI_CHECK(obj3 == "-4.0");
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.assignNoThrow(RTCRestString("0123456789"), 3, 5), VINF_SUCCESS);
955 RTTESTI_CHECK(obj3 == "34567");
956 RTTESTI_CHECK(obj3.isNull() == false);
957
958 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
959 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
960 RTTESTI_CHECK_RC(obj3.assignNoThrow("0123456789", 4), VINF_SUCCESS);
961 RTTESTI_CHECK(obj3 == "0123");
962 RTTESTI_CHECK(obj3.isNull() == false);
963
964 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
965 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
966 RTTESTI_CHECK_RC(obj3.assignNoThrow(8, 'x'), VINF_SUCCESS);
967 RTTESTI_CHECK(obj3 == "xxxxxxxx");
968 RTTESTI_CHECK(obj3.isNull() == false);
969
970 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
971 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
972 RTTESTI_CHECK_RC(obj3.printfNoThrow("%d%s%d", 42, "asdf", 22), VINF_SUCCESS);
973 RTTESTI_CHECK(obj3 == "42asdf22");
974 RTTESTI_CHECK(obj3.isNull() == false);
975
976 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
977 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
978 va_list va;
979 va_start(va, pszDummy);
980 RTTESTI_CHECK_RC(obj3.printfVNoThrow("asdf", va), VINF_SUCCESS);
981 va_end(va);
982 RTTESTI_CHECK(obj3 == "asdf");
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(RTCRestString("4.0"));
988 RTTESTI_CHECK(obj3 == "4.0");
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("-4.0");
994 RTTESTI_CHECK(obj3 == "-4.0");
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.assign(RTCRestString("0123456789"), 3, 5);
1000 RTTESTI_CHECK(obj3 == "34567");
1001 RTTESTI_CHECK(obj3.isNull() == false);
1002
1003 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1004 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1005 obj3.assign("0123456789", 4);
1006 RTTESTI_CHECK(obj3 == "0123");
1007 RTTESTI_CHECK(obj3.isNull() == false);
1008
1009 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1010 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1011 obj3.assign(8, 'x');
1012 RTTESTI_CHECK(obj3 == "xxxxxxxx");
1013 RTTESTI_CHECK(obj3.isNull() == false);
1014
1015 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1016 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1017 obj3.printf("%d%s%d", 42, "asdf", 22);
1018 RTTESTI_CHECK(obj3 == "42asdf22");
1019 RTTESTI_CHECK(obj3.isNull() == false);
1020
1021 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1022 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1023 va_start(va, pszDummy);
1024 obj3.printfV("asdf", va);
1025 va_end(va);
1026 RTTESTI_CHECK(obj3 == "asdf");
1027 RTTESTI_CHECK(obj3.isNull() == false);
1028
1029 /* Reset to default: */
1030 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
1031 RTTESTI_CHECK(obj3.isEmpty());
1032 RTTESTI_CHECK(obj3.isNull() == false);
1033
1034 obj3 = "1";
1035 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1036 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
1037 RTTESTI_CHECK(obj3.isEmpty());
1038 RTTESTI_CHECK(obj3.isNull() == false);
1039
1040 /* Copy assignments: */
1041 RTCRestString const obj3Max("max");
1042 RTTESTI_CHECK(obj3Max == "max");
1043 RTTESTI_CHECK(obj3Max.isNull() == false);
1044 RTCRestString obj3Null;
1045 obj3Null.setNull();
1046 RTTESTI_CHECK(obj3Null.isEmpty());
1047 RTTESTI_CHECK(obj3Null.isNull() == true);
1048 RTCRestString obj3Empty;
1049 RTTESTI_CHECK(obj3Empty.isEmpty());
1050 RTTESTI_CHECK(obj3Empty.isNull() == false);
1051
1052 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1053 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1054 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Max), VINF_SUCCESS);
1055 RTTESTI_CHECK(obj3 == "max");
1056 RTTESTI_CHECK(obj3.isNull() == false);
1057
1058 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1059 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1060 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Null), VINF_SUCCESS);
1061 RTTESTI_CHECK(obj3.isEmpty());
1062 RTTESTI_CHECK(obj3.isNull() == true);
1063
1064 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1065 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1066 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Empty), VINF_SUCCESS);
1067 RTTESTI_CHECK(obj3 == "");
1068 RTTESTI_CHECK(obj3.isEmpty());
1069 RTTESTI_CHECK(obj3.isNull() == false);
1070
1071 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1072 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1073 RTTESTI_CHECK_RC(obj3.assignCopy(RTCString("11.0")), VINF_SUCCESS);
1074 RTTESTI_CHECK(obj3 == "11.0");
1075 RTTESTI_CHECK(obj3.isNull() == false);
1076
1077 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1078 RTTESTI_CHECK(obj3.isNull() == true && obj3.isEmpty());
1079 RTTESTI_CHECK_RC(obj3.assignCopy("12.0"), VINF_SUCCESS);
1080 RTTESTI_CHECK(obj3 == "12.0");
1081 RTTESTI_CHECK(obj3.isNull() == false);
1082
1083 /* setNull implies resetToDefault: */
1084 obj3 = obj3Max;
1085 RTTESTI_CHECK(obj3 == "max");
1086 RTTESTI_CHECK(obj3.isNull() == false);
1087 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1088 RTTESTI_CHECK(obj3.isNull() == true);
1089 RTTESTI_CHECK(obj3.isEmpty());
1090
1091 /* Copy constructors: */
1092 {
1093 RTCRestString obj3a(obj3Max);
1094 RTTESTI_CHECK(obj3a == "max");
1095 RTTESTI_CHECK(obj3a.isNull() == false);
1096 }
1097 {
1098 RTCRestString const obj3c(obj3Null);
1099 RTTESTI_CHECK(obj3c.isEmpty());
1100 RTTESTI_CHECK(obj3c.isNull() == true);
1101 }
1102
1103 /* Serialization to json: */
1104 const char *pszJson = toJson(&obj3Max);
1105 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"max\"") == 0, ("pszJson=%s\n", pszJson));
1106 pszJson = toJson(&obj3Null);
1107 RTTESTI_CHECK_MSG(strcmp(pszJson, "null") == 0, ("pszJson=%s\n", pszJson));
1108 pszJson = toJson(&obj3Empty);
1109 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"\"") == 0, ("pszJson=%s\n", pszJson));
1110
1111 /* Serialization to string. */
1112 RTCString str;
1113 RTCString strExpect;
1114 str = "lead-in:";
1115 RTTESTI_CHECK_RC(obj3Max.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1116 RTTESTI_CHECK_MSG(str.equals("lead-in:max"), ("str=%s\n", str.c_str()));
1117 RTTESTI_CHECK_RC(obj3Max.toString(&str), VINF_SUCCESS);
1118 RTTESTI_CHECK_MSG(str.equals("max"), ("str=%s\n", str.c_str()));
1119
1120 str = "lead-in:";
1121 RTTESTI_CHECK_RC(obj3Empty.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1122 RTTESTI_CHECK_MSG(str.equals("lead-in:"), ("str=%s\n", str.c_str()));
1123 RTTESTI_CHECK_RC(obj3Empty.toString(&str), VINF_SUCCESS);
1124 RTTESTI_CHECK_MSG(str.equals(""), ("str=%s\n", str.c_str()));
1125
1126 str = "lead-in:";
1127 RTTESTI_CHECK_RC(obj3Null.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1128 RTTESTI_CHECK_MSG(str.equals("lead-in:"), ("str=%s\n", str.c_str()));
1129 RTTESTI_CHECK_RC(obj3Null.toString(&str), VINF_SUCCESS);
1130 RTTESTI_CHECK_MSG(str.equals(""), ("str=%s\n", str.c_str()));
1131 }
1132
1133 /* deserialize: */
1134 RTERRINFOSTATIC ErrInfo;
1135 {
1136 /* from json: */
1137 RTCRestString obj4;
1138 obj4.setNull();
1139 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"42.42\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1140 RTTESTI_CHECK(obj4 == "42.42");
1141 RTTESTI_CHECK(obj4.isNull() == false);
1142
1143 obj4.setNull();
1144 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"-22.22\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1145 RTTESTI_CHECK(obj4 == "-22.22");
1146 RTTESTI_CHECK(obj4.isNull() == false);
1147
1148 obj4.setNull();
1149 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"maximum\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1150 RTTESTI_CHECK(obj4 == "maximum");
1151 RTTESTI_CHECK(obj4.isNull() == false);
1152
1153 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1154 RTTESTI_CHECK(obj4.isEmpty());
1155 RTTESTI_CHECK(obj4.isNull() == true);
1156
1157 obj4.setNull();
1158 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"\\u0020\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1159 RTTESTI_CHECK(obj4 == " ");
1160 RTTESTI_CHECK(obj4.isNull() == false);
1161
1162 obj4.setNull();
1163 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"\\u004f\\u004D\\u0047\\u0021 :-)\"",
1164 &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1165 RTTESTI_CHECK(obj4 == "OMG! :-)");
1166 RTTESTI_CHECK(obj4.isNull() == false);
1167
1168 obj4.setNull();
1169 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"42:\\uD801\\udC37\\ud852\\uDf62:42\"", /* U+10437 U+24B62 */
1170 &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1171 RTTESTI_CHECK(obj4 == "42:" "\xf0\x90\x90\xb7" "\xf0\xa4\xad\xa2" ":42");
1172 RTTESTI_CHECK(obj4.isNull() == false);
1173
1174 /* object goes to default state on failure: */
1175 obj4 = "asdf";
1176 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "false", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_STRING);
1177 RTTESTI_CHECK(obj4.isEmpty());
1178 RTTESTI_CHECK(obj4.isNull() == false);
1179 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
1180
1181 obj4 = "asdf";
1182 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "1", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_STRING);
1183 RTTESTI_CHECK(obj4.isEmpty());
1184 RTTESTI_CHECK(obj4.isNull() == false);
1185 RTTESTI_CHECK(RTErrInfoIsSet(&ErrInfo.Core));
1186
1187 obj4.setNull();
1188 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "[ null ]", NULL, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_STRING);
1189 RTTESTI_CHECK(obj4.isEmpty());
1190 RTTESTI_CHECK(obj4.isNull() == false);
1191
1192 /* from string: */
1193 obj4.setNull();
1194 RTTESTI_CHECK_RC(fromString(&obj4, "22.42", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1195 RTTESTI_CHECK(obj4 == "22.42");
1196 RTTESTI_CHECK(obj4.isNull() == false);
1197
1198 RTTESTI_CHECK_RC(fromString(&obj4, "-42.22", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1199 RTTESTI_CHECK(obj4 == "-42.22");
1200 RTTESTI_CHECK(obj4.isNull() == false);
1201
1202 obj4.setNull();
1203 RTTESTI_CHECK_RC(fromString(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1204 RTTESTI_CHECK(obj4 == "null");
1205 RTTESTI_CHECK(obj4.isNull() == false);
1206 }
1207}
1208
1209
1210void testDate()
1211{
1212 RTTestSub(g_hTest, "RTCRestDate");
1213 int64_t const iRecent = INT64_C(1536580687739632500);
1214 int64_t const iRecentSec = INT64_C(1536580687000000000);
1215 RTTIMESPEC TimeSpec;
1216
1217#define CHECK_DATE(a_obj, a_fNull, a_fOkay, a_i64Nano, a_sz, a_fUtc) \
1218 do { \
1219 RTTESTI_CHECK((a_obj).isOkay() == (a_fOkay)); \
1220 if ((a_obj).getEpochNano() != (a_i64Nano)) \
1221 RTTestIFailed("line " RT_XSTR(__LINE__) ": getEpochNano=%RI64, expected %RI64", (a_obj).getEpochNano(), (int64_t)(a_i64Nano)); \
1222 if (!(a_obj).getString().equals(a_sz)) \
1223 RTTestIFailed("line " RT_XSTR(__LINE__) ": getString=%s, expected %s", (a_obj).getString().c_str(), a_sz); \
1224 RTTESTI_CHECK((a_obj).isUtc() == (a_fUtc)); \
1225 RTTESTI_CHECK((a_obj).isNull() == (a_fNull)); \
1226 } while (0)
1227#define CHECK_DATE_FMT(a_obj, a_fNull, a_fOkay, a_i64Nano, a_sz, a_fUtc, a_enmFormat) \
1228 do { \
1229 CHECK_DATE(a_obj, a_fNull, a_fOkay, a_i64Nano, a_sz, a_fUtc); \
1230 if ((a_obj).getFormat() != (a_enmFormat)) \
1231 RTTestIFailed("line " RT_XSTR(__LINE__) ": getFormat=%d, expected %d (%s)", (a_obj).getFormat(), (a_enmFormat), #a_enmFormat); \
1232 } while (0)
1233
1234 {
1235 RTCRestDate obj1;
1236 CHECK_DATE(obj1, true, false, 0, "", true);
1237 RTTESTI_CHECK(strcmp(obj1.typeName(), "RTCRestDate") == 0);
1238 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_Date);
1239 }
1240
1241 {
1242 /* Value assignments: */
1243 RTCRestDate obj3;
1244 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339), VINF_SUCCESS);
1245 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00Z", true);
1246
1247 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1248 CHECK_DATE(obj3, true, false, 0, "", true);
1249 RTTESTI_CHECK_RC(obj3.assignValueRfc3339(RTTimeSpecSetNano(&TimeSpec, 0)), VINF_SUCCESS);
1250 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00Z", true);
1251
1252 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1253 CHECK_DATE(obj3, true, false, 0, "", true);
1254 RTTESTI_CHECK_RC(obj3.assignValueRfc2822(RTTimeSpecSetNano(&TimeSpec, 0)), VINF_SUCCESS);
1255 CHECK_DATE(obj3, false, true, 0, "Thu, 1 Jan 1970 00:00:00 -0000", true);
1256
1257 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1258 RTTESTI_CHECK_RC(obj3.assignValueRfc7131(RTTimeSpecSetNano(&TimeSpec, 0)), VINF_SUCCESS);
1259 CHECK_DATE(obj3, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true);
1260
1261 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1262 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1263 CHECK_DATE(obj3, false, true, 0, "Thu, 1 Jan 1970 00:00:00 -0000", true);
1264
1265 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1266 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc7131), VINF_SUCCESS);
1267 CHECK_DATE(obj3, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true);
1268
1269 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1270 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_9), VINF_SUCCESS);
1271 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.000000000Z", true);
1272
1273 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1274 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_6), VINF_SUCCESS);
1275 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.000000Z", true);
1276
1277 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1278 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_3), VINF_SUCCESS);
1279 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.000Z", true);
1280
1281 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1282 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_2), VINF_SUCCESS);
1283 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.00Z", true);
1284
1285 /* Format changes: */
1286 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, INT64_C(59123456789)), RTCRestDate::kFormat_Rfc3339_Fraction_9), VINF_SUCCESS);
1287 CHECK_DATE(obj3, false, true, INT64_C(59123456789), "1970-01-01T00:00:59.123456789Z", true);
1288 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1289 CHECK_DATE(obj3, false, true, INT64_C(59123456789), "Thu, 1 Jan 1970 00:00:59 -0000", true);
1290 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc7131), VINF_SUCCESS);
1291 CHECK_DATE(obj3, false, true, INT64_C(59123456789), "Thu, 1 Jan 1970 00:00:59 GMT", true);
1292 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc3339), VINF_SUCCESS);
1293 CHECK_DATE(obj3, false, true, INT64_C(59123456789), "1970-01-01T00:00:59Z", true);
1294 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc3339_Fraction_2), VINF_SUCCESS);
1295 CHECK_DATE(obj3, false, true, INT64_C(59123456789), "1970-01-01T00:00:59.12Z", true);
1296 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc3339_Fraction_3), VINF_SUCCESS);
1297 CHECK_DATE(obj3, false, true, INT64_C(59123456789), "1970-01-01T00:00:59.123Z", true);
1298 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc3339_Fraction_6), VINF_SUCCESS);
1299 CHECK_DATE(obj3, false, true, INT64_C(59123456789), "1970-01-01T00:00:59.123456Z", true);
1300 RTTESTI_CHECK_RC(obj3.setFormat(RTCRestDate::kFormat_Rfc3339_Fraction_9), VINF_SUCCESS);
1301 CHECK_DATE(obj3, false, true, INT64_C(59123456789), "1970-01-01T00:00:59.123456789Z", true);
1302
1303 /* Reset to default and setNull works identically: */
1304 RTTESTI_CHECK_RC(obj3.resetToDefault(), VINF_SUCCESS);
1305 CHECK_DATE(obj3, true, false, 0, "", true);
1306
1307 RTTESTI_CHECK_RC(obj3.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_2), VINF_SUCCESS);
1308 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.00Z", true);
1309 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1310 CHECK_DATE(obj3, true, false, 0, "", true);
1311
1312 /* Copy assignments: */
1313 RTCRestDate obj3Epoch_3339_9;
1314 RTTESTI_CHECK_RC(obj3Epoch_3339_9.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc3339_Fraction_9), VINF_SUCCESS);
1315 CHECK_DATE(obj3Epoch_3339_9, false, true, 0, "1970-01-01T00:00:00.000000000Z", true);
1316
1317 RTCRestDate obj3Epoch_7131;
1318 RTTESTI_CHECK_RC(obj3Epoch_7131.assignValue(RTTimeSpecSetNano(&TimeSpec, 0), RTCRestDate::kFormat_Rfc7131), VINF_SUCCESS);
1319 CHECK_DATE(obj3Epoch_7131, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true);
1320
1321 RTCRestDate obj3Recent_3339;
1322 RTTESTI_CHECK_RC(obj3Recent_3339.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc3339), VINF_SUCCESS);
1323 CHECK_DATE(obj3Recent_3339, false, true, iRecent, "2018-09-10T11:58:07Z", true);
1324
1325 RTCRestDate obj3Recent_2822;
1326 RTTESTI_CHECK_RC(obj3Recent_2822.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1327 CHECK_DATE(obj3Recent_2822, false, true, iRecent, "Mon, 10 Sep 2018 11:58:07 -0000", true);
1328
1329 RTCRestDate const obj3Null;
1330 CHECK_DATE(obj3Null, true, false, 0, "", true);
1331
1332 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1333 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Epoch_3339_9), VINF_SUCCESS);
1334 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.000000000Z", true);
1335
1336 RTTESTI_CHECK_RC(obj3.setNull(), VINF_SUCCESS);
1337 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Epoch_7131), VINF_SUCCESS);
1338 CHECK_DATE(obj3, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true);
1339
1340 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Recent_3339), VINF_SUCCESS);
1341 CHECK_DATE(obj3Recent_2822, false, true, iRecent, "Mon, 10 Sep 2018 11:58:07 -0000", true);
1342
1343 RTTESTI_CHECK_RC(obj3.assignCopy(obj3Null), VINF_SUCCESS);
1344 CHECK_DATE(obj3, true, false, 0, "", true);
1345
1346 obj3 = obj3Recent_2822;
1347 CHECK_DATE(obj3Recent_2822, false, true, iRecent, "Mon, 10 Sep 2018 11:58:07 -0000", true);
1348
1349 obj3 = obj3Epoch_3339_9;
1350 CHECK_DATE(obj3, false, true, 0, "1970-01-01T00:00:00.000000000Z", true);
1351
1352 obj3 = obj3Null;
1353 CHECK_DATE(obj3, true, false, 0, "", true);
1354
1355 /* Copy constructors: */
1356 {
1357 RTCRestDate obj3a(obj3Epoch_3339_9);
1358 CHECK_DATE(obj3a, false, true, 0, "1970-01-01T00:00:00.000000000Z", true);
1359 }
1360 {
1361 RTCRestDate obj3b(obj3Epoch_7131);
1362 CHECK_DATE(obj3b, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true);
1363 }
1364 {
1365 RTCRestDate obj3c(obj3Recent_3339);
1366 CHECK_DATE(obj3Recent_3339, false, true, iRecent, "2018-09-10T11:58:07Z", true);
1367 }
1368 {
1369 RTCRestDate obj3d(obj3Recent_2822);
1370 CHECK_DATE(obj3d, false, true, iRecent, "Mon, 10 Sep 2018 11:58:07 -0000", true);
1371 }
1372 {
1373 RTCRestDate obj3e(obj3Null);
1374 CHECK_DATE(obj3e, true, false, 0, "", true);
1375 }
1376
1377 /* Serialization to json: */
1378 const char *pszJson = toJson(&obj3Epoch_3339_9);
1379 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"1970-01-01T00:00:00.000000000Z\"") == 0, ("pszJson=%s\n", pszJson));
1380 pszJson = toJson(&obj3Epoch_7131);
1381 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"Thu, 1 Jan 1970 00:00:00 GMT\"") == 0, ("pszJson=%s\n", pszJson));
1382 pszJson = toJson(&obj3Recent_3339);
1383 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"2018-09-10T11:58:07Z\"") == 0, ("pszJson=%s\n", pszJson));
1384 pszJson = toJson(&obj3Recent_2822);
1385 RTTESTI_CHECK_MSG(strcmp(pszJson, "\"Mon, 10 Sep 2018 11:58:07 -0000\"") == 0, ("pszJson=%s\n", pszJson));
1386 pszJson = toJson(&obj3Null);
1387 RTTESTI_CHECK_MSG(strcmp(pszJson, "null") == 0, ("pszJson=%s\n", pszJson));
1388
1389 /* Serialization to string. */
1390 RTCString str;
1391 str = "lead-in:";
1392 RTTESTI_CHECK_RC(obj3Epoch_7131.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1393 RTTESTI_CHECK_MSG(str.equals("lead-in:Thu, 1 Jan 1970 00:00:00 GMT"), ("str=%s\n", str.c_str()));
1394 RTTESTI_CHECK_RC(obj3Epoch_7131.toString(&str), VINF_SUCCESS);
1395 RTTESTI_CHECK_MSG(str.equals("Thu, 1 Jan 1970 00:00:00 GMT"), ("str=%s\n", str.c_str()));
1396
1397 str = "lead-in:";
1398 RTTESTI_CHECK_RC(obj3Recent_3339.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1399 RTTESTI_CHECK_MSG(str.equals("lead-in:2018-09-10T11:58:07Z"), ("str=%s\n", str.c_str()));
1400 RTTESTI_CHECK_RC(obj3Recent_3339.toString(&str), VINF_SUCCESS);
1401 RTTESTI_CHECK_MSG(str.equals("2018-09-10T11:58:07Z"), ("str=%s\n", str.c_str()));
1402
1403 str = "lead-in:";
1404 RTTESTI_CHECK_RC(obj3Null.toString(&str, RTCRestObjectBase::kToString_Append), VINF_SUCCESS);
1405 RTTESTI_CHECK_MSG(str.equals("lead-in:null"), ("str=%s\n", str.c_str()));
1406 RTTESTI_CHECK_RC(obj3Null.toString(&str), VINF_SUCCESS);
1407 RTTESTI_CHECK_MSG(str.equals("null"), ("str=%s\n", str.c_str()));
1408 }
1409
1410 /* deserialize: */
1411 RTERRINFOSTATIC ErrInfo;
1412 {
1413 RTCRestDate obj4;
1414 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"Thu, 1 Jan 1970 00:00:00 GMT\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1415 CHECK_DATE_FMT(obj4, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true, RTCRestDate::kFormat_Rfc7131);
1416
1417 obj4.setNull();
1418 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"Thu, 1 Jan 1970 00:00:00.0000 GMT\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1419 CHECK_DATE_FMT(obj4, false, true, 0, "Thu, 1 Jan 1970 00:00:00.0000 GMT", true, RTCRestDate::kFormat_Rfc7131);
1420
1421 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"1 Jan 1970 00:00:00 GMT\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1422 CHECK_DATE_FMT(obj4, false, true, 0, "1 Jan 1970 00:00:00 GMT", true, RTCRestDate::kFormat_Rfc7131);
1423
1424 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"1 Jan 1970 00:00:00\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1425 CHECK_DATE_FMT(obj4, false, true, 0, "1 Jan 1970 00:00:00", false, RTCRestDate::kFormat_Rfc2822);
1426
1427 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"1 Jan 070 00:00:00\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1428 CHECK_DATE_FMT(obj4, false, true, 0, "1 Jan 070 00:00:00", false, RTCRestDate::kFormat_Rfc2822);
1429
1430 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"2018-09-10T11:58:07Z\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1431 CHECK_DATE_FMT(obj4, false, true, iRecentSec , "2018-09-10T11:58:07Z", true, RTCRestDate::kFormat_Rfc3339);
1432
1433 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"1 Jan 70 00:00:00\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1434 CHECK_DATE_FMT(obj4, false, true, 0, "1 Jan 70 00:00:00", false, RTCRestDate::kFormat_Rfc2822);
1435
1436 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"2018-09-10T11:58:07.739632500Z\"", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1437 CHECK_DATE_FMT(obj4, false, true, iRecent, "2018-09-10T11:58:07.739632500Z", true, RTCRestDate::kFormat_Rfc3339_Fraction_9);
1438
1439 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1440 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc3339_Fraction_9);
1441
1442 /* object goes to default state if not string and to non-okay if string: */
1443 RTTESTI_CHECK_RC(obj4.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1444 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "true", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DATE);
1445 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc2822);
1446
1447 RTTESTI_CHECK_RC(obj4.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1448 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"string\"", &ErrInfo, RT_XSTR(__LINE__)), VWRN_REST_UNABLE_TO_DECODE_DATE);
1449 CHECK_DATE_FMT(obj4, false, false, 0, "string", false, RTCRestDate::kFormat_Rfc2822);
1450
1451 RTTESTI_CHECK_RC(obj4.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1452 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "\"0x199 string\"", &ErrInfo, RT_XSTR(__LINE__)), VWRN_REST_UNABLE_TO_DECODE_DATE);
1453 CHECK_DATE_FMT(obj4, false, false, 0, "0x199 string", false, RTCRestDate::kFormat_Rfc2822);
1454
1455 RTTESTI_CHECK_RC(obj4.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1456 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "[ null ]", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DATE);
1457 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc2822);
1458
1459 RTTESTI_CHECK_RC(obj4.assignValue(RTTimeSpecSetNano(&TimeSpec, iRecent), RTCRestDate::kFormat_Rfc2822), VINF_SUCCESS);
1460 RTTESTI_CHECK_RC(deserializeFromJson(&obj4, "{ \"foo\": 1 }", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_WRONG_JSON_TYPE_FOR_DATE);
1461 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc2822);
1462
1463 /* From string: */
1464 obj4.setNull();
1465 RTTESTI_CHECK_RC(fromString(&obj4, "Thu, 1 Jan 1970 00:00:00 GMT", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1466 CHECK_DATE_FMT(obj4, false, true, 0, "Thu, 1 Jan 1970 00:00:00 GMT", true, RTCRestDate::kFormat_Rfc7131);
1467
1468 RTTESTI_CHECK_RC(fromString(&obj4, "Mon, 10 Sep 2018 11:58:07 -0000", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1469 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "Mon, 10 Sep 2018 11:58:07 -0000", true, RTCRestDate::kFormat_Rfc2822);
1470
1471 RTTESTI_CHECK_RC(fromString(&obj4, "\t\n\rnull;\r\n\t", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1472 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc2822);
1473
1474 RTTESTI_CHECK_RC(fromString(&obj4, "Mon, 10 Sep 2018 11:58:07 +0000", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1475 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "Mon, 10 Sep 2018 11:58:07 +0000", false, RTCRestDate::kFormat_Rfc2822);
1476
1477 RTTESTI_CHECK_RC(fromString(&obj4, "1970-01-01T00:00:00.000000000Z", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1478 CHECK_DATE_FMT(obj4, false, true, 0, "1970-01-01T00:00:00.000000000Z", true, RTCRestDate::kFormat_Rfc3339_Fraction_9);
1479
1480 RTTESTI_CHECK_RC(fromString(&obj4, "10 Sep 2018 11:58:07 -0000", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1481 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "10 Sep 2018 11:58:07 -0000", true, RTCRestDate::kFormat_Rfc2822);
1482
1483 RTTESTI_CHECK_RC(fromString(&obj4, "null", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1484 CHECK_DATE_FMT(obj4, true, false, 0, "", true, RTCRestDate::kFormat_Rfc2822);
1485
1486 RTTESTI_CHECK_RC(fromString(&obj4, "Mon, 10 Sep 18 11:58:07 -0000", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1487 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "Mon, 10 Sep 18 11:58:07 -0000", true, RTCRestDate::kFormat_Rfc2822);
1488
1489 RTTESTI_CHECK_RC(fromString(&obj4, "fa;se", &ErrInfo, RT_XSTR(__LINE__)), VERR_REST_UNABLE_TO_DECODE_DATE);
1490 CHECK_DATE_FMT(obj4, false, false, 0, "fa;se", false, RTCRestDate::kFormat_Rfc2822);
1491
1492 RTTESTI_CHECK_RC(fromString(&obj4, "10 Sep 18 11:58:07", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1493 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "10 Sep 18 11:58:07", false, RTCRestDate::kFormat_Rfc2822);
1494
1495 obj4.setNull();
1496 RTTESTI_CHECK_RC(fromString(&obj4, "10 Sep 118 11:58:07", &ErrInfo, RT_XSTR(__LINE__)), VINF_SUCCESS);
1497 CHECK_DATE_FMT(obj4, false, true, iRecentSec, "10 Sep 118 11:58:07", false, RTCRestDate::kFormat_Rfc2822);
1498 }
1499}
1500
1501
1502/** Wraps RTCRestInt16 to check for leaks. */
1503class MyRestInt16 : public RTCRestInt16
1504{
1505public:
1506 static size_t s_cInstances;
1507 MyRestInt16() : RTCRestInt16() { s_cInstances++; /*printf("%p: default %02u; cInstances %zu\n", this, m_iValue, s_cInstances);*/ }
1508 MyRestInt16(MyRestInt16 const &a_rThat) : RTCRestInt16(a_rThat) { s_cInstances++; /*printf("%p: copy %02u; cInstances %zu\n", this, m_iValue, s_cInstances);*/ }
1509 MyRestInt16(int16_t a_iValue) : RTCRestInt16(a_iValue) { s_cInstances++; /*printf("%p: value %02u; cInstances %zu\n", this, m_iValue, s_cInstances);*/ }
1510 ~MyRestInt16() { s_cInstances--; /*printf("%p: delete %02u; cInstances %zu\n", this, m_iValue, s_cInstances);*/ }
1511 virtual RTCRestObjectBase *baseClone() const RT_NOEXCEPT RT_OVERRIDE { /*printf("clone\n");*/ return new MyRestInt16(*this); }
1512};
1513
1514size_t MyRestInt16::s_cInstances = 0;
1515
1516
1517static void verifyArray(RTCRestArray<MyRestInt16> const &rArray, int iLine, unsigned cElements, ...)
1518{
1519 if (rArray.size() != cElements)
1520 RTTestIFailed("line %u: size() -> %zu, expected %u", iLine, rArray.size(), cElements);
1521 va_list va;
1522 va_start(va, cElements);
1523 for (unsigned i = 0; i < cElements; i++)
1524 {
1525 int iExpected = va_arg(va, int);
1526 if (rArray.at(i)->m_iValue != iExpected)
1527 RTTestIFailed("line %u: element #%u: %d, expected %d", iLine, i, rArray.at(i)->m_iValue, iExpected);
1528 }
1529 va_end(va);
1530}
1531
1532
1533static void testArray()
1534{
1535 RTTestSub(g_hTest, "RTCRestArray");
1536
1537 {
1538 RTCRestArray<RTCRestBool> obj1;
1539 RTTESTI_CHECK(obj1.size() == 0);
1540 RTTESTI_CHECK(obj1.isEmpty() == true);
1541 RTTESTI_CHECK(obj1.isNull() == false);
1542 RTTESTI_CHECK(strcmp(obj1.typeName(), "RTCRestArray<ElementType>") == 0);
1543 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_Array);
1544 }
1545
1546 /* Some random order insertion and manipulations: */
1547 {
1548 RTCRestArray<MyRestInt16> Arr2;
1549 RTCRestArray<MyRestInt16> const *pConstArr2 = &Arr2;
1550
1551 RTTESTI_CHECK_RC(Arr2.insert(0, new MyRestInt16(3)), VINF_SUCCESS);
1552 verifyArray(Arr2, __LINE__, 1, 3);
1553 RTTESTI_CHECK_RC(Arr2.append( new MyRestInt16(7)), VINF_SUCCESS);
1554 verifyArray(Arr2, __LINE__, 2, 3, 7);
1555 RTTESTI_CHECK_RC(Arr2.insert(1, new MyRestInt16(5)), VINF_SUCCESS);
1556 verifyArray(Arr2, __LINE__, 3, 3, 5, 7);
1557 RTTESTI_CHECK_RC(Arr2.insert(2, new MyRestInt16(6)), VINF_SUCCESS);
1558 verifyArray(Arr2, __LINE__, 4, 3, 5, 6, 7);
1559 RTTESTI_CHECK_RC(Arr2.prepend( new MyRestInt16(0)), VINF_SUCCESS);
1560 verifyArray(Arr2, __LINE__, 5, 0, 3, 5, 6, 7);
1561 RTTESTI_CHECK_RC(Arr2.append( new MyRestInt16(9)), VINF_SUCCESS);
1562 verifyArray(Arr2, __LINE__, 6, 0, 3, 5, 6, 7, 9);
1563 RTTESTI_CHECK_RC(Arr2.insert(5, new MyRestInt16(8)), VINF_SUCCESS);
1564 verifyArray(Arr2, __LINE__, 7, 0, 3, 5, 6, 7, 8, 9);
1565 RTTESTI_CHECK_RC(Arr2.insert(1, new MyRestInt16(1)), VINF_SUCCESS);
1566 verifyArray(Arr2, __LINE__, 8, 0, 1, 3, 5, 6, 7, 8, 9);
1567 RTTESTI_CHECK_RC(Arr2.insert(3, new MyRestInt16(4)), VINF_SUCCESS);
1568 verifyArray(Arr2, __LINE__, 9, 0, 1, 3, 4, 5, 6, 7, 8, 9);
1569 RTTESTI_CHECK_RC(Arr2.insert(2, new MyRestInt16(2)), VINF_SUCCESS);
1570 verifyArray(Arr2, __LINE__, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
1571 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1572
1573 RTTESTI_CHECK(Arr2.size() == 10);
1574
1575 for (size_t i = 0; i < Arr2.size(); i++)
1576 {
1577 MyRestInt16 *pCur = Arr2.at(i);
1578 RTTESTI_CHECK(pCur->m_iValue == (int16_t)i);
1579
1580 MyRestInt16 const *pCur2 = pConstArr2->at(i);
1581 RTTESTI_CHECK(pCur2->m_iValue == (int16_t)i);
1582 }
1583
1584 RTTESTI_CHECK_RC(Arr2.replace(2, new MyRestInt16(22)), VWRN_ALREADY_EXISTS);
1585 verifyArray(Arr2, __LINE__, 10, 0, 1, 22, 3, 4, 5, 6, 7, 8, 9);
1586
1587 RTTESTI_CHECK_RC(Arr2.replace(7, new MyRestInt16(77)), VWRN_ALREADY_EXISTS);
1588 verifyArray(Arr2, __LINE__, 10, 0, 1, 22, 3, 4, 5, 6, 77, 8, 9);
1589
1590 RTTESTI_CHECK_RC(Arr2.replace(10, new MyRestInt16(10)), VINF_SUCCESS);
1591 verifyArray(Arr2, __LINE__, 11, 0, 1, 22, 3, 4, 5, 6, 77, 8, 9, 10);
1592
1593 RTTESTI_CHECK_RC(Arr2.replaceCopy(2, MyRestInt16(2)), VWRN_ALREADY_EXISTS);
1594 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1595 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1596
1597 /* copy constructor: */
1598 {
1599 RTCRestArray<MyRestInt16> const Arr2Copy(Arr2);
1600 verifyArray(Arr2Copy, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1601 }
1602 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1603 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1604
1605 {
1606 RTCRestArray<MyRestInt16> Arr2Copy2(Arr2);
1607 verifyArray(Arr2Copy2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1608 RTTESTI_CHECK_RC(Arr2Copy2.removeAt(7), VINF_SUCCESS);
1609 verifyArray(Arr2Copy2, __LINE__, 10, 0, 1, 2, 3, 4, 5, 6, 8, 9, 10);
1610 }
1611 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1612 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1613
1614 /* copy method + clear: */
1615 {
1616 RTCRestArray<MyRestInt16> Arr2Copy3;
1617 RTTESTI_CHECK_RC(Arr2Copy3.assignCopy(Arr2), VINF_SUCCESS);
1618 verifyArray(Arr2Copy3, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1619 Arr2Copy3.at(3)->m_iValue = 33;
1620 verifyArray(Arr2Copy3, __LINE__, 11, 0, 1, 2, 33, 4, 5, 6, 77, 8, 9, 10);
1621 Arr2Copy3.clear();
1622 verifyArray(Arr2Copy3, __LINE__, 0);
1623 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1624 }
1625 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1626 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1627
1628 /* Check setNull and resetToDefaults with copies: */
1629 {
1630 RTCRestArray<MyRestInt16> Arr2Copy4(Arr2);
1631 verifyArray(Arr2Copy4, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1632
1633 RTTESTI_CHECK_RC(Arr2Copy4.setNull(), VINF_SUCCESS);
1634 verifyArray(Arr2Copy4, __LINE__, 0);
1635 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1636 RTTESTI_CHECK(Arr2Copy4.isNull() == true);
1637
1638 RTTESTI_CHECK_RC(Arr2Copy4.resetToDefault(), VINF_SUCCESS);
1639 RTTESTI_CHECK(Arr2Copy4.isNull() == false);
1640 verifyArray(Arr2Copy4, __LINE__, 0);
1641 }
1642 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1643 {
1644 RTCRestArray<MyRestInt16> Arr2Copy5(Arr2);
1645 verifyArray(Arr2Copy5, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1646
1647 RTTESTI_CHECK_RC(Arr2Copy5.resetToDefault(), VINF_SUCCESS);
1648 verifyArray(Arr2Copy5, __LINE__, 0);
1649 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1650 RTTESTI_CHECK(Arr2Copy5.isNull() == false);
1651
1652 RTTESTI_CHECK_RC(Arr2Copy5.setNull(), VINF_SUCCESS);
1653 RTTESTI_CHECK(Arr2Copy5.isNull() == true);
1654
1655 RTTESTI_CHECK_RC(Arr2Copy5.append(new MyRestInt16(100)), VINF_SUCCESS);
1656 RTTESTI_CHECK(Arr2Copy5.isNull() == false);
1657 verifyArray(Arr2Copy5, __LINE__, 1, 100);
1658 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size() + 1, ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size() + 1));
1659 }
1660 verifyArray(Arr2, __LINE__, 11, 0, 1, 2, 3, 4, 5, 6, 77, 8, 9, 10);
1661
1662 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == Arr2.size(), ("%zu vs %zu\n", MyRestInt16::s_cInstances, Arr2.size()));
1663 }
1664 RTTESTI_CHECK_MSG(MyRestInt16::s_cInstances == 0, ("%zu\n", MyRestInt16::s_cInstances));
1665
1666 {
1667 RTCRestArray<RTCRestInt64> Arr3;
1668 RTCRestArray<RTCRestInt64> const *pConstArr3 = &Arr3;
1669
1670 /* Insert a range of numbers into a int64 array. */
1671 for (int64_t i = 0; i < _64K; i++)
1672 {
1673 if (i & 1)
1674 {
1675 RTCRestInt64 toCopy(i);
1676 if (i & 2)
1677 RTTESTI_CHECK_RC(Arr3.insertCopy(i, toCopy), VINF_SUCCESS);
1678 else
1679 RTTESTI_CHECK_RC(Arr3.appendCopy(toCopy), VINF_SUCCESS);
1680 }
1681 else
1682 {
1683 RTCRestInt64 *pDirect = new RTCRestInt64(i);
1684 if (i & 2)
1685 RTTESTI_CHECK_RC(Arr3.insert(i, pDirect), VINF_SUCCESS);
1686 else
1687 RTTESTI_CHECK_RC(Arr3.append(pDirect), VINF_SUCCESS);
1688 }
1689 RTTESTI_CHECK(Arr3.size() == (size_t)i + 1);
1690 RTTESTI_CHECK(Arr3.isEmpty() == false);
1691 }
1692
1693 /* Verify insertions: */
1694 size_t cElements = _64K;
1695 RTTESTI_CHECK(Arr3.size() == cElements);
1696
1697 for (int64_t i = 0; i < _64K; i++)
1698 {
1699 RTCRestInt64 *pCur = Arr3.at(i);
1700 RTTESTI_CHECK(pCur->m_iValue == i);
1701
1702 RTCRestInt64 const *pCur2 = pConstArr3->at(i);
1703 RTTESTI_CHECK(pCur2->m_iValue == i);
1704 }
1705 RTTESTI_CHECK(Arr3.first()->m_iValue == 0);
1706 RTTESTI_CHECK(Arr3.last()->m_iValue == _64K - 1);
1707 RTTESTI_CHECK(pConstArr3->first()->m_iValue == 0);
1708 RTTESTI_CHECK(pConstArr3->last()->m_iValue == _64K - 1);
1709
1710 /* Remove every 3rd element: */
1711 RTTESTI_CHECK(Arr3.size() == cElements);
1712 for (int64_t i = _64K - 1; i >= 0; i -= 3)
1713 {
1714 RTTESTI_CHECK_RC(Arr3.removeAt(i), VINF_SUCCESS);
1715 cElements--;
1716 RTTESTI_CHECK(Arr3.size() == cElements);
1717 }
1718
1719 /* Verify after removal: */
1720 for (int64_t i = 0, iValue = 0; i < (ssize_t)Arr3.size(); i++, iValue++)
1721 {
1722 if ((iValue % 3) == 0)
1723 iValue++;
1724 RTTESTI_CHECK_MSG(Arr3.at(i)->m_iValue == iValue, ("%RI64: %RI64 vs %RI64\n", i, Arr3.at(i)->m_iValue, iValue));
1725 }
1726
1727 /* Clear it and we're done: */
1728 Arr3.clear();
1729 RTTESTI_CHECK(Arr3.size() == 0);
1730 RTTESTI_CHECK(Arr3.isEmpty() == true);
1731 }
1732
1733 {
1734 RTCRestArray<RTCRestInt32> Arr4;
1735
1736 /* Insert a range of numbers into a int32 array, in reverse order. */
1737 for (int32_t i = 0; i < 2048; i++)
1738 {
1739 if (i & 1)
1740 {
1741 RTCRestInt32 toCopy(i);
1742 if (i & 2)
1743 RTTESTI_CHECK_RC(Arr4.insertCopy(0, toCopy), VINF_SUCCESS);
1744 else
1745 RTTESTI_CHECK_RC(Arr4.prependCopy(toCopy), VINF_SUCCESS);
1746 }
1747 else
1748 {
1749 RTCRestInt32 *pDirect = new RTCRestInt32(i);
1750 if (i & 2)
1751 RTTESTI_CHECK_RC(Arr4.insert(0, pDirect), VINF_SUCCESS);
1752 else
1753 RTTESTI_CHECK_RC(Arr4.prepend(pDirect), VINF_SUCCESS);
1754 }
1755 RTTESTI_CHECK((ssize_t)Arr4.size() == i + 1);
1756 RTTESTI_CHECK(Arr4.isEmpty() == false);
1757 }
1758
1759 for (int32_t i = 0, iValue = (int32_t)Arr4.size() - 1; i < (ssize_t)Arr4.size(); i++, iValue--)
1760 RTTESTI_CHECK_MSG(Arr4.at(i)->m_iValue == iValue, ("%RI32: %RI32 vs %RI32\n", i, Arr4.at(i)->m_iValue, iValue));
1761
1762 for (int32_t i = 0; i < 512; i++)
1763 RTTESTI_CHECK_RC(Arr4.removeAt(0), VINF_SUCCESS);
1764 RTTESTI_CHECK(Arr4.size() == 1536);
1765
1766 for (int32_t i = 0; i < 512; i++)
1767 RTTESTI_CHECK_RC(Arr4.removeAt(~(size_t)0), VINF_SUCCESS);
1768 RTTESTI_CHECK(Arr4.size() == 1024);
1769
1770 for (int32_t i = 0, iValue = 1535; i < (ssize_t)Arr4.size(); i++, iValue--)
1771 RTTESTI_CHECK_MSG(Arr4.at(i)->m_iValue == iValue, ("%RI32: %RI32 vs %RI32\n", i, Arr4.at(i)->m_iValue, iValue));
1772 }
1773}
1774
1775
1776static void verifyMap(RTCRestStringMap<MyRestInt16> const &rMap, int iLine, unsigned cEntries, ...)
1777{
1778 if (rMap.size() != cEntries)
1779 RTTestIFailed("line %u: size() -> %zu, expected %u", iLine, rMap.size(), cEntries);
1780 if (rMap.isEmpty() != (cEntries ? false : true))
1781 RTTestIFailed("line %u: isEmpty() -> %RTbool, with %u entries", iLine, rMap.isEmpty(), cEntries);
1782
1783 va_list va;
1784 va_start(va, cEntries);
1785 for (unsigned i = 0; i < cEntries; i++)
1786 {
1787 const char *pszKey = va_arg(va, const char *);
1788 int iValue = va_arg(va, int);
1789 if ( rMap.containsKey(pszKey) != true
1790 || rMap.containsKey(RTCString(pszKey)) != true
1791 || rMap.get(pszKey) == NULL
1792 || rMap.get(RTCString(pszKey)) == NULL)
1793 RTTestIFailed("line %u: entry '%s' not found!", iLine, pszKey);
1794 else if (rMap.get(pszKey)->m_iValue != iValue)
1795 RTTestIFailed("line %u: entry '%s' value mismatch: %d, expected %d",
1796 iLine, pszKey, rMap.get(pszKey)->m_iValue, iValue);
1797 RTTESTI_CHECK(rMap.get(pszKey) == rMap.get(RTCString(pszKey)));
1798 }
1799 va_end(va);
1800 RTTESTI_CHECK(rMap.isNull() == false);
1801
1802 uint64_t fFound = 0;
1803 for (RTCRestStringMapBase::ConstIterator it = rMap.begin(); it != rMap.end(); ++it)
1804 {
1805 MyRestInt16 const *pObj = (MyRestInt16 const *)it.getValue();
1806 RTTESTI_CHECK(RT_VALID_PTR(pObj));
1807
1808 bool fFoundIt = false;
1809 va_start(va, cEntries);
1810 for (unsigned i = 0; i < cEntries; i++)
1811 {
1812 const char *pszKey = va_arg(va, const char *);
1813 int iValue = va_arg(va, int);
1814 if (it.getKey().equals(pszKey))
1815 {
1816 if (fFound & RT_BIT_64(i))
1817 RTTestIFailed("line %u: base enum: entry '%s' returned more than once!", iLine, pszKey);
1818 if (pObj->m_iValue != iValue)
1819 RTTestIFailed("line %u: base enum: entry '%s' value mismatch: %d, expected %d",
1820 iLine, pszKey, pObj->m_iValue, iValue);
1821 fFound |= RT_BIT_64(i);
1822 fFoundIt = true;
1823 va_end(va);
1824 return;
1825 }
1826 }
1827 va_end(va);
1828 if (!fFoundIt)
1829 RTTestIFailed("line %u: base enum: entry '%s' not expected!", iLine, it.getKey().c_str());
1830 }
1831}
1832
1833
1834void testStringMap(void)
1835{
1836 RTTestSub(g_hTest, "RTCRestMap");
1837
1838 {
1839 RTCRestStringMap<RTCRestString> obj1;
1840 RTTESTI_CHECK(obj1.size() == 0);
1841 RTTESTI_CHECK(obj1.isEmpty() == true);
1842 RTTESTI_CHECK(obj1.isNull() == false);
1843 RTTESTI_CHECK(strcmp(obj1.typeName(), "RTCRestStringMap<ValueType>") == 0);
1844 RTTESTI_CHECK(obj1.typeClass() == RTCRestObjectBase::kTypeClass_StringMap);
1845 }
1846
1847 /* Basic operations: */
1848 {
1849 MyRestInt16::s_cInstances = 0;
1850 RTCRestStringMap<MyRestInt16> Map2;
1851 verifyMap(Map2, __LINE__, 0);
1852
1853 RTTESTI_CHECK_RC(Map2.putCopy("0x0004", MyRestInt16(4)), VINF_SUCCESS);
1854 verifyMap(Map2, __LINE__, 1, "0x0004", 4);
1855 RTTESTI_CHECK(MyRestInt16::s_cInstances == 1);
1856 RTTESTI_CHECK_RC(Map2.put("0x0001", new MyRestInt16(1)), VINF_SUCCESS);
1857 verifyMap(Map2, __LINE__, 2, "0x0004",4, "0x0001",1);
1858 RTTESTI_CHECK_RC(Map2.put("0x0003", new MyRestInt16(3)), VINF_SUCCESS);
1859 verifyMap(Map2, __LINE__, 3, "0x0004",4, "0x0001",1, "0x0003",3);
1860 RTTESTI_CHECK_RC(Map2.put("0x0002", new MyRestInt16(2)), VINF_SUCCESS);
1861 verifyMap(Map2, __LINE__, 4, "0x0004",4, "0x0001",1, "0x0003",3, "0x0002",2);
1862 RTTESTI_CHECK(MyRestInt16::s_cInstances == 4);
1863 RTTESTI_CHECK_RC(Map2.put("0x0000", new MyRestInt16(0)), VINF_SUCCESS);
1864 verifyMap(Map2, __LINE__, 5, "0x0004",4, "0x0001",1, "0x0003",3, "0x0002",2, "0x0000",0);
1865 RTTESTI_CHECK(MyRestInt16::s_cInstances == 5);
1866 RTTESTI_CHECK_RC(Map2.putCopy("towel", MyRestInt16(42)), VINF_SUCCESS);
1867 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0003",3, "0x0002",2, "0x0000",0, "towel",42);
1868 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1869
1870 RTTESTI_CHECK(Map2.containsKey("0x0005") == false);
1871 RTTESTI_CHECK(Map2.get("0x0005") == NULL);
1872
1873 RTTESTI_CHECK(Map2.remove("0x0003") == true);
1874 verifyMap(Map2, __LINE__, 5, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42);
1875 RTTESTI_CHECK(MyRestInt16::s_cInstances == 5);
1876
1877 RTTESTI_CHECK(Map2.remove("0x0003") == false);
1878 verifyMap(Map2, __LINE__, 5, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42);
1879 RTTESTI_CHECK(MyRestInt16::s_cInstances == 5);
1880
1881 RTCRestObjectBase *pNewBase = NULL;
1882 RTTESTI_CHECK_RC(Map2.putNewValue(&pNewBase, "putNewValue"), VINF_SUCCESS);
1883 ((MyRestInt16 *)pNewBase)->m_iValue = 88;
1884 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1885 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",88);
1886
1887 pNewBase = NULL;
1888 RTTESTI_CHECK_RC(Map2.putNewValue(&pNewBase, RTCString("putNewValue")), VERR_ALREADY_EXISTS);
1889 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",88);
1890 pNewBase = NULL;
1891 RTTESTI_CHECK_RC(Map2.putNewValue(&pNewBase, RTCString("putNewValue"), true /*a_fReplace*/), VWRN_ALREADY_EXISTS);
1892 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1893 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1894
1895 /* Make copy and remove all: */
1896 {
1897 RTCRestStringMap<MyRestInt16> Map2Copy1;
1898
1899 RTTESTI_CHECK_RC(Map2Copy1.assignCopy(Map2), VINF_SUCCESS);
1900 verifyMap(Map2Copy1, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1901 RTTESTI_CHECK(MyRestInt16::s_cInstances == 12);
1902
1903 RTTESTI_CHECK(Map2Copy1.remove("0x0004") == true);
1904 verifyMap(Map2Copy1, __LINE__, 5, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1905 RTTESTI_CHECK(MyRestInt16::s_cInstances == 11);
1906
1907 RTTESTI_CHECK(Map2Copy1.remove("putNewValue") == true);
1908 verifyMap(Map2Copy1, __LINE__, 4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42);
1909 RTTESTI_CHECK(MyRestInt16::s_cInstances == 10);
1910
1911 RTTESTI_CHECK(Map2Copy1.remove("towel") == true);
1912 verifyMap(Map2Copy1, __LINE__, 3, "0x0001",1, "0x0002",2, "0x0000",0);
1913 RTTESTI_CHECK(MyRestInt16::s_cInstances == 9);
1914
1915 RTTESTI_CHECK(Map2Copy1.remove("0x0002") == true);
1916 verifyMap(Map2Copy1, __LINE__, 2, "0x0001",1, "0x0000",0);
1917 RTTESTI_CHECK(MyRestInt16::s_cInstances == 8);
1918
1919 RTTESTI_CHECK(Map2Copy1.remove("0x0000") == true);
1920 verifyMap(Map2Copy1, __LINE__, 1, "0x0001",1);
1921 RTTESTI_CHECK(MyRestInt16::s_cInstances == 7);
1922
1923 RTTESTI_CHECK(Map2Copy1.remove("0x0001") == true);
1924 verifyMap(Map2Copy1, __LINE__, 0);
1925 RTTESTI_CHECK(Map2Copy1.isEmpty() == true);
1926 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1927 }
1928 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1929
1930 /* Make copy and use clear: */
1931 {
1932 RTCRestStringMap<MyRestInt16> Map2Copy2(Map2);
1933 verifyMap(Map2Copy2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1934 RTTESTI_CHECK(MyRestInt16::s_cInstances == 12);
1935 Map2Copy2.clear();
1936 verifyMap(Map2Copy2, __LINE__, 0);
1937 RTTESTI_CHECK(Map2Copy2.isEmpty() == true);
1938 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1939 }
1940 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1941
1942 /* Make copy and reset to default: */
1943 {
1944 RTCRestStringMap<MyRestInt16> Map2Copy3(Map2);
1945 verifyMap(Map2Copy3, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1946 RTTESTI_CHECK(MyRestInt16::s_cInstances == 12);
1947 RTTESTI_CHECK_RC(Map2Copy3.resetToDefault(), VINF_SUCCESS);
1948 verifyMap(Map2Copy3, __LINE__, 0);
1949 RTTESTI_CHECK(Map2Copy3.isEmpty() == true);
1950 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1951 }
1952 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1953
1954 /* Make copy and set to null: */
1955 {
1956 RTCRestStringMap<MyRestInt16> Map2Copy4;
1957 Map2Copy4 = Map2;
1958 verifyMap(Map2Copy4, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1959 RTTESTI_CHECK(MyRestInt16::s_cInstances == 12);
1960 RTTESTI_CHECK_RC(Map2Copy4.setNull(), VINF_SUCCESS);
1961 RTTESTI_CHECK(Map2Copy4.size() == 0);
1962 RTTESTI_CHECK(Map2Copy4.isEmpty() == true);
1963 RTTESTI_CHECK(Map2Copy4.isNull() == true);
1964 RTTESTI_CHECK(MyRestInt16::s_cInstances == 6);
1965 }
1966 verifyMap(Map2, __LINE__, 6, "0x0004",4, "0x0001",1, "0x0002",2, "0x0000",0, "towel",42, "putNewValue",0);
1967 }
1968 RTTESTI_CHECK(MyRestInt16::s_cInstances == 0);
1969
1970 /* Check that null indicator is reset when it should: */
1971 {
1972 RTCRestStringMap<MyRestInt16> Map3;
1973 Map3.setNull();
1974 RTTESTI_CHECK_RC(Map3.setNull(), VINF_SUCCESS);
1975 RTTESTI_CHECK(Map3.size() == 0);
1976 RTTESTI_CHECK(Map3.isEmpty() == true);
1977 RTTESTI_CHECK(Map3.isNull() == true);
1978 RTTESTI_CHECK_RC(Map3.putCopy("not-null-anymore", MyRestInt16(1)), VINF_SUCCESS);
1979 verifyMap(Map3, __LINE__, 1, "not-null-anymore",1);
1980 }
1981 RTTESTI_CHECK(MyRestInt16::s_cInstances == 0);
1982
1983 {
1984 RTCRestStringMap<MyRestInt16> Map4;
1985 Map4.setNull();
1986 RTTESTI_CHECK_RC(Map4.setNull(), VINF_SUCCESS);
1987 RTTESTI_CHECK(Map4.size() == 0);
1988 RTTESTI_CHECK(Map4.isEmpty() == true);
1989 RTTESTI_CHECK(Map4.isNull() == true);
1990 RTCRestObjectBase *pNewBase = NULL;
1991 RTTESTI_CHECK_RC(Map4.putNewValue(&pNewBase, "putNewValue"), VINF_SUCCESS);
1992 verifyMap(Map4, __LINE__, 1, "putNewValue",0);
1993 }
1994 RTTESTI_CHECK(MyRestInt16::s_cInstances == 0);
1995}
1996
1997
1998class TestRequest : public RTCRestClientRequestBase
1999{
2000public:
2001 RTCRestString m_strValue;
2002 RTCRestInt64 m_iValue;
2003 RTCRestArray<RTCRestString> m_Array;
2004 RTCRestStringMap<RTCRestString> m_Map;
2005 /** @todo add more attributes. */
2006
2007 TestRequest(const char *a_pszValue, int64_t a_iValue, unsigned a_cElements, ...)
2008 : RTCRestClientRequestBase()
2009 , m_strValue(a_pszValue)
2010 , m_iValue(a_iValue)
2011 {
2012 m_fIsSet = UINT64_MAX;
2013 va_list va;
2014 va_start(va, a_cElements);
2015 for (unsigned i = 0; i < a_cElements; i++)
2016 m_Array.append(new RTCRestString(va_arg(va, const char *)));
2017 va_end(va);
2018 }
2019
2020 int resetToDefault() RT_NOEXCEPT RT_OVERRIDE
2021 {
2022 m_strValue = "";
2023 m_iValue = 0;
2024 return m_Array.resetToDefault();
2025 }
2026
2027 const char *getOperationName() const RT_NOEXCEPT RT_OVERRIDE
2028 {
2029 return "Test";
2030 }
2031
2032 int xmitPrepare(RTCString *a_pStrPath, RTCString *a_pStrQuery, RTHTTP a_hHttp, RTCString *a_pStrBody) const RT_NOEXCEPT RT_OVERRIDE
2033 {
2034 RT_NOREF(a_pStrPath, a_pStrQuery, a_hHttp, a_pStrBody);
2035 return VINF_SUCCESS;
2036 }
2037
2038 void xmitComplete(int a_rcStatus, RTHTTP a_hHttp) const RT_NOEXCEPT RT_OVERRIDE
2039 {
2040 RT_NOREF(a_rcStatus, a_hHttp);
2041 }
2042
2043 void testPath(const char *a_pszExpected)
2044 {
2045 static PATHPARAMDESC const s_aParams[] =
2046 {
2047 { RT_STR_TUPLE("{string}"), 0, 0 },
2048 { RT_STR_TUPLE("{integer}"), 0, 0 },
2049 { RT_STR_TUPLE("{array}"), 0, 0 },
2050 };
2051 PATHPARAMSTATE aState[] = { { &m_strValue, 0 }, { &m_iValue, 0 }, { &m_Array, 0 } };
2052 RTCString strPath;
2053 RTTESTI_CHECK_RC(doPathParameters(&strPath, RT_STR_TUPLE("my/{integer}/{string}/array:{array}/path"),
2054 s_aParams, aState, RT_ELEMENTS(aState)), VINF_SUCCESS);
2055 RTTESTI_CHECK_MSG(strPath.equals(a_pszExpected), ("actual: %s\nexpect: %s\n", strPath.c_str(), a_pszExpected));
2056 }
2057
2058 void testQuery(const char *a_pszCsv,
2059 const char *a_pszSsv,
2060 const char *a_pszTsv,
2061 const char *a_pszPipes,
2062 const char *a_pszMulti)
2063 {
2064 QUERYPARAMDESC aParams[] =
2065 {
2066 { "string", 0, true, 0 },
2067 { "integer", 0, true, 0 },
2068 { "array", 0, true, 0 },
2069 };
2070
2071 RTCRestObjectBase const *apObjects[] = { &m_strValue, &m_iValue, &m_Array };
2072 RTCString strQuery;
2073 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2074 RTTESTI_CHECK_MSG(strQuery.equals(a_pszCsv), ("actual: %s\nexpect: %s\n", strQuery.c_str(), a_pszCsv));
2075
2076 strQuery.setNull();
2077 aParams[2].fFlags = RTCRestObjectBase::kCollectionFormat_csv;
2078 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2079 RTTESTI_CHECK_MSG(strQuery.equals(a_pszCsv), ("actual: %s\nexpect: %s\n", strQuery.c_str(), a_pszCsv));
2080
2081 strQuery.setNull();
2082 aParams[2].fFlags = RTCRestObjectBase::kCollectionFormat_ssv;
2083 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2084 RTTESTI_CHECK_MSG(strQuery.equals(a_pszSsv), ("actual: %s\nexpect: %s\n", strQuery.c_str(), a_pszSsv));
2085
2086 strQuery.setNull();
2087 aParams[2].fFlags = RTCRestObjectBase::kCollectionFormat_tsv;
2088 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2089 RTTESTI_CHECK_MSG(strQuery.equals(a_pszTsv), ("actual: %s\nexpect: %s\n", strQuery.c_str(), a_pszTsv));
2090
2091 strQuery.setNull();
2092 aParams[2].fFlags = RTCRestObjectBase::kCollectionFormat_pipes;
2093 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2094 RTTESTI_CHECK_MSG(strQuery.equals(a_pszPipes), ("actual: %s\nexpect: %s\n", strQuery.c_str(), a_pszPipes));
2095
2096 strQuery.setNull();
2097 aParams[2].fFlags = RTCRestObjectBase::kCollectionFormat_multi;
2098 RTTESTI_CHECK_RC(doQueryParameters(&strQuery, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2099 RTTESTI_CHECK_MSG(strQuery.equals(a_pszMulti), ("actual: %s\nexpect: %s\n", strQuery.c_str(), a_pszMulti));
2100 }
2101
2102 void testHeader(unsigned a_cHeaders, ...)
2103 {
2104 HEADERPARAMDESC aParams[] =
2105 {
2106 { "x-string", 0, true, 0, false },
2107 { "x-integer", 0, true, 0, false },
2108 { "x-array", 0, true, 0, false },
2109 { "x-map-", 0, true, 0, true },
2110 };
2111 RTCRestObjectBase const *apObjects[] = { &m_strValue, &m_iValue, &m_Array, &m_Map };
2112 RTHTTP hHttp = NIL_RTHTTP;
2113 RTTESTI_CHECK_RC(RTHttpCreate(&hHttp), VINF_SUCCESS);
2114 RTTESTI_CHECK_RC(doHeaderParameters(hHttp, aParams, apObjects, RT_ELEMENTS(apObjects)), VINF_SUCCESS);
2115 RTTESTI_CHECK(RTHttpGetHeaderCount(hHttp) == a_cHeaders);
2116 va_list va;
2117 va_start(va, a_cHeaders);
2118 for (size_t i = 0; i < a_cHeaders; i++)
2119 {
2120 const char *pszField = va_arg(va, const char *);
2121 const char *pszValue = va_arg(va, const char *);
2122 const char *pszActual = RTHttpGetHeader(hHttp, pszField, RTSTR_MAX);
2123 RTTESTI_CHECK_MSG(RTStrCmp(pszActual, pszValue) == 0,
2124 ("Header '%s' value is '%s' rather than '%s'", pszField, pszActual, pszValue));
2125 }
2126 va_end(va);
2127 RTTESTI_CHECK_RC(RTHttpDestroy(hHttp), VINF_SUCCESS);
2128 }
2129};
2130
2131
2132void testClientRequestBase()
2133{
2134 RTTestSub(g_hTest, "RTCRestClientRequestBase");
2135 {
2136 TestRequest Req1("this-is-a-string", 123456789, 5, "1", "22", "333", "444", "555");
2137 Req1.testPath("my/123456789/this-is-a-string/array:1%2C22%2C333%2C444%2C555/path");
2138 Req1.testQuery("?string=this-is-a-string&integer=123456789&array=1%2C22%2C333%2C444%2C555",
2139 "?string=this-is-a-string&integer=123456789&array=1%2022%20333%20444%20555",
2140 "?string=this-is-a-string&integer=123456789&array=1%0922%09333%09444%09555",
2141 "?string=this-is-a-string&integer=123456789&array=1%7C22%7C333%7C444%7C555",
2142 "?string=this-is-a-string&integer=123456789&array=1&array=22&array=333&array=444&array=555");
2143 Req1.testHeader(3, "x-string","this-is-a-string", "x-integer","123456789", "x-array","1,22,333,444,555");
2144 }
2145 {
2146 TestRequest Req2(";'[]", 42, 3, "null", "foo", "bar");
2147 RTTESTI_CHECK_RC(Req2.m_Map.put("stuff-1", new RTCRestString("stuffy-value-1")), VINF_SUCCESS);
2148 RTTESTI_CHECK_RC(Req2.m_Map.put("stuff-2", new RTCRestString("stuffy-value-2")), VINF_SUCCESS);
2149 RTTESTI_CHECK_RC(Req2.m_Map.put("2222", new RTCRestString("33")), VINF_SUCCESS);
2150 Req2.testPath("my/42/%3B%27%5B%5D/array:null%2Cfoo%2Cbar/path");
2151 Req2.testQuery("?string=%3B%27%5B%5D&integer=42&array=null%2Cfoo%2Cbar",
2152 "?string=%3B%27%5B%5D&integer=42&array=null%20foo%20bar",
2153 "?string=%3B%27%5B%5D&integer=42&array=null%09foo%09bar",
2154 "?string=%3B%27%5B%5D&integer=42&array=null%7Cfoo%7Cbar",
2155 "?string=%3B%27%5B%5D&integer=42&array=null&array=foo&array=bar");
2156 Req2.testHeader(6, "x-string",";'[]", "x-integer","42", "x-array","null,foo,bar",
2157 "x-map-stuff-1","stuffy-value-1",
2158 "x-map-stuff-2","stuffy-value-2",
2159 "x-map-2222","33");
2160 }
2161}
2162
2163
2164class TestResponse : public RTCRestClientResponseBase
2165{
2166public:
2167 RTCRestArray<RTCRestString> *m_pArray;
2168 RTCRestStringMap<RTCRestString> *m_pMap;
2169 RTCRestInt64 *m_pInteger;
2170 RTCRestString *m_pStrContentType;
2171
2172 TestResponse() : m_pArray(NULL), m_pMap(NULL), m_pInteger(NULL), m_pStrContentType(NULL)
2173 { }
2174
2175 ~TestResponse()
2176 {
2177 if (m_pStrContentType)
2178 delete m_pStrContentType;
2179 if (m_pInteger)
2180 delete m_pInteger;
2181 if (m_pMap)
2182 delete m_pMap;
2183 if (m_pArray)
2184 delete m_pArray;
2185 }
2186
2187 const char *getOperationName() const RT_NOEXCEPT RT_OVERRIDE
2188 {
2189 return "Test";
2190 }
2191
2192protected:
2193 virtual int consumeHeader(uint32_t a_uMatchWord, const char *a_pchField, size_t a_cchField,
2194 const char *a_pchValue, size_t a_cchValue) RT_NOEXCEPT RT_OVERRIDE
2195 {
2196 int rc = RTCRestClientResponseBase::consumeHeader(a_uMatchWord, a_pchField, a_cchField, a_pchValue, a_cchValue);
2197 AssertRCReturn(rc, rc);
2198
2199#define MATCH_FIELD(a_sz) (sizeof(a_sz) - 1 == a_cchField && RTStrNICmpAscii(a_pchField, RT_STR_TUPLE(a_sz)) == 0)
2200 if (MATCH_FIELD("x-array"))
2201 {
2202 if (!m_pArray)
2203 {
2204 m_pArray = new (std::nothrow) RTCRestArray<RTCRestString>();
2205 AssertReturn(m_pArray, VERR_NO_MEMORY);
2206 return deserializeHeader(m_pArray, a_pchValue, a_cchValue, RTCRestObjectBase::kCollectionFormat_csv, "x-array");
2207 }
2208 }
2209 else if (a_cchField >= sizeof("x-map-") - 1 && RTStrNICmpAscii(a_pchField, RT_STR_TUPLE("x-map-")) == 0)
2210 {
2211 if (!m_pMap)
2212 {
2213 m_pMap = new (std::nothrow) RTCRestStringMap<RTCRestString>();
2214 AssertReturn(m_pMap, VERR_NO_MEMORY);
2215 }
2216 return deserializeHeaderIntoMap(m_pMap, a_pchField + 6, a_cchField - 6, a_pchValue, a_cchValue, 0, "x-map-");
2217 }
2218 else if (MATCH_FIELD("x-integer"))
2219 {
2220 if (!m_pInteger)
2221 {
2222 m_pInteger = new (std::nothrow) RTCRestInt64();
2223 AssertReturn(m_pInteger, VERR_NO_MEMORY);
2224 return deserializeHeader(m_pInteger, a_pchValue, a_cchValue, 0, "x-integer");
2225 }
2226 }
2227 else if (MATCH_FIELD("content-type"))
2228 {
2229 if (!m_pStrContentType)
2230 {
2231 m_pStrContentType = new (std::nothrow) RTCRestString();
2232 AssertReturn(m_pStrContentType, VERR_NO_MEMORY);
2233 return deserializeHeader(m_pStrContentType, a_pchValue, a_cchValue, 0, "content-type");
2234 }
2235 }
2236 else
2237 return VWRN_NOT_FOUND;
2238 RT_NOREF(a_uMatchWord);
2239 return addError(VERR_ALREADY_EXISTS, "Already have field '%.*s'!", a_cchField, a_pchField);
2240 }
2241
2242public:
2243 int pushHeader(const char *pszField, const char *pszValue)
2244 {
2245 size_t const cchField = strlen(pszField);
2246 void *pvFieldCopy = RTTestGuardedAllocTail(g_hTest, cchField);
2247 RTTESTI_CHECK_RET(pvFieldCopy, VERR_NO_MEMORY);
2248 memcpy(pvFieldCopy, pszField, cchField);
2249
2250 size_t const cchValue = strlen(pszValue);
2251 void *pvValueCopy = RTTestGuardedAllocTail(g_hTest, cchValue);
2252 RTTESTI_CHECK_RET(pvValueCopy, VERR_NO_MEMORY);
2253 memcpy(pvValueCopy, pszValue, cchValue);
2254
2255 uint32_t uWord = RTHTTP_MAKE_HDR_MATCH_WORD(cchField,
2256 cchField >= 1 ? RT_C_TO_LOWER(pszField[0]) : 0,
2257 cchField >= 2 ? RT_C_TO_LOWER(pszField[1]) : 0,
2258 cchField >= 3 ? RT_C_TO_LOWER(pszField[2]) : 0);
2259 int rc = consumeHeader(uWord, (const char *)pvFieldCopy, cchField, (const char *)pvValueCopy, cchValue);
2260 RTTestGuardedFree(g_hTest, pvValueCopy);
2261 RTTestGuardedFree(g_hTest, pvFieldCopy);
2262 return rc;
2263 }
2264};
2265
2266
2267void testClientResponseBase()
2268{
2269 RTTestSub(g_hTest, "RTCRestClientResponseBase");
2270 {
2271 TestResponse Resp1;
2272 RTTESTI_CHECK_RC(Resp1.pushHeader("content-type", "application/json; charset=utf-8"), VINF_SUCCESS);
2273 RTTESTI_CHECK(Resp1.getContentType().equals("application/json; charset=utf-8"));
2274 RTTESTI_CHECK(Resp1.m_pStrContentType && Resp1.m_pStrContentType->equals("application/json; charset=utf-8"));
2275
2276 RTTESTI_CHECK_RC(Resp1.pushHeader("content-typ2", "oopsy daisy"), VWRN_NOT_FOUND);
2277 RTTESTI_CHECK_RC(Resp1.pushHeader("content-type2", "oopsy daisy"), VWRN_NOT_FOUND);
2278 RTTESTI_CHECK(Resp1.getContentType().equals("application/json; charset=utf-8"));
2279 RTTESTI_CHECK(Resp1.m_pStrContentType && Resp1.m_pStrContentType->equals("application/json; charset=utf-8"));
2280
2281 RTTESTI_CHECK_RC(Resp1.pushHeader("x-integer", "398679406"), VINF_SUCCESS);
2282 RTTESTI_CHECK(Resp1.m_pInteger && Resp1.m_pInteger->m_iValue == 398679406);
2283
2284 RTTESTI_CHECK_RC(Resp1.pushHeader("x-array", "zero,one,two,three"), VINF_SUCCESS);
2285 RTTESTI_CHECK(Resp1.m_pArray && Resp1.m_pArray->size() == 4);
2286
2287 RTTESTI_CHECK_RC(Resp1.pushHeader("x-map-", "empty-key"), VINF_SUCCESS);
2288 RTTESTI_CHECK(Resp1.m_pMap && Resp1.m_pMap->size() == 1 && Resp1.m_pMap->get("") != NULL && Resp1.m_pMap->get("")->equals("empty-key"));
2289
2290 RTTESTI_CHECK_RC(Resp1.pushHeader("x-map-42", "key-is-42"), VINF_SUCCESS);
2291 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"));
2292 }
2293}
2294
2295
2296int main()
2297{
2298 RTEXITCODE rcExit = RTTestInitAndCreate("tstRTCRest-1", &g_hTest);
2299 if (rcExit == RTEXITCODE_SUCCESS )
2300 {
2301 testBool();
2302 testInteger<RTCRestInt64, int64_t, Int64Constants>();
2303 testInteger<RTCRestInt32, int32_t, Int32Constants>();
2304 testInteger<RTCRestInt16, int16_t, Int16Constants>();
2305 testDouble();
2306 testString("dummy", 1, 2);
2307 testDate();
2308 testArray();
2309 testStringMap();
2310 testClientRequestBase();
2311 testClientResponseBase();
2312
2313 rcExit = RTTestSummaryAndDestroy(g_hTest);
2314 }
2315 return rcExit;
2316}
2317
Note: See TracBrowser for help on using the repository browser.

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