VirtualBox

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

Last change on this file since 75050 was 75037, checked in by vboxsync, 6 years ago

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

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