tstRTCRest-1.cpp@ 92124

Last change on this file since 92124 was 86681, checked in by vboxsync, 4 years ago
IPRT/rest: bugref:9167 - Add release logging for REST operations. Request are logged at level 5, and responses at level 7, so they are not on by default. The format is a bit ad-hoc, but all the essential information should be there. It's mostly done in base classes except for request bodies (it can probably be done in the base class too, but would require more runtime logic, while here we can only generate them as needed).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 102.4 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: