tstIprtMiniString.cpp@ 39837

Last change on this file since 39837 was 36561, checked in by vboxsync, 14 years ago
RTCString::join: Optimization.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 18.5 KB

Line
1	/* $Id: tstIprtMiniString.cpp 36561 2011-04-05 13:42:59Z vboxsync $ */
2	/** @file
3	* IPRT Testcase - RTCString.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 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	* Header Files *
29	*******************************************************************************/
30	#include <iprt/cpp/ministring.h>
31
32	#include <iprt/err.h>
33	#include <iprt/mem.h>
34	#include <iprt/string.h>
35	#include <iprt/test.h>
36	#include <iprt/uni.h>
37
38
39	static void test1Hlp1(const char pszExpect, const char pszFormat, ...)
40	{
41	#if 0
42	va_list va;
43	va_start(va, pszFormat);
44	RTCString strTst(pszFormat, va);
45	va_end(va);
46	RTTESTI_CHECK_MSG(strTst.equals(pszExpect), ("strTst='%s' expected='%s'\n", strTst.c_str(), pszExpect));
47	#endif
48	}
49
50	static void test1(RTTEST hTest)
51	{
52	RTTestSub(hTest, "Basics");
53
54	#define CHECK(expr) RTTESTI_CHECK(expr)
55	#define CHECK_DUMP(expr, value) \
56	do { \
57	if (!(expr)) \
58	RTTestFailed(hTest, "%d: FAILED %s, got \"%s\"", __LINE__, #expr, value); \
59	} while (0)
60
61	#define CHECK_DUMP_I(expr) \
62	do { \
63	if (!(expr)) \
64	RTTestFailed(hTest, "%d: FAILED %s, got \"%d\"", __LINE__, #expr, expr); \
65	} while (0)
66	#define CHECK_EQUAL(Str, szExpect) \
67	do { \
68	if (!(Str).equals(szExpect)) \
69	RTTestIFailed("line %u: expected \"%s\" got \"%s\"", __LINE__, szExpect, (Str).c_str()); \
70	} while (0)
71
72	RTCString empty;
73	CHECK(empty.length() == 0);
74	CHECK(empty.capacity() == 0);
75
76	RTCString sixbytes("12345");
77	CHECK(sixbytes.length() == 5);
78	CHECK(sixbytes.capacity() == 6);
79
80	sixbytes.append(RTCString("678"));
81	CHECK(sixbytes.length() == 8);
82	CHECK(sixbytes.capacity() >= 9);
83
84	sixbytes.append("9a");
85	CHECK(sixbytes.length() == 10);
86	CHECK(sixbytes.capacity() >= 11);
87
88	char *psz = sixbytes.mutableRaw();
89	// 123456789a
90	// ^
91	// 0123456
92	psz[6] = '\0';
93	sixbytes.jolt();
94	CHECK(sixbytes.length() == 6);
95	CHECK(sixbytes.capacity() == 7);
96
97	RTCString morebytes("tobereplaced");
98	morebytes = "newstring ";
99	morebytes.append(sixbytes);
100
101	CHECK_DUMP(morebytes == "newstring 123456", morebytes.c_str());
102
103	RTCString third(morebytes);
104	third.reserve(100 * 1024); // 100 KB
105	CHECK_DUMP(third == "newstring 123456", morebytes.c_str() );
106	CHECK(third.capacity() == 100 * 1024);
107	CHECK(third.length() == morebytes.length()); // must not have changed
108
109	RTCString copy1(morebytes);
110	RTCString copy2 = morebytes;
111	CHECK(copy1 == copy2);
112
113	copy1 = NULL;
114	CHECK(copy1.length() == 0);
115
116	copy1 = "";
117	CHECK(copy1.length() == 0);
118
119	CHECK(RTCString("abc") < RTCString("def"));
120	CHECK(RTCString("") < RTCString("def"));
121	CHECK(RTCString("abc") > RTCString(""));
122	CHECK(RTCString("abc") != RTCString("def"));
123	CHECK_DUMP_I(RTCString("def") > RTCString("abc"));
124	CHECK(RTCString("abc") == RTCString("abc"));
125	CHECK(RTCString("").compare("") == 0);
126	CHECK(RTCString("").compare(NULL) == 0);
127	CHECK(RTCString("").compare("a") < 0);
128	CHECK(RTCString("a").compare("") > 0);
129	CHECK(RTCString("a").compare(NULL) > 0);
130
131	CHECK(RTCString("abc") < "def");
132	CHECK(RTCString("abc") != "def");
133	CHECK_DUMP_I(RTCString("def") > "abc");
134	CHECK(RTCString("abc") == "abc");
135
136	CHECK(RTCString("abc").equals("abc"));
137	CHECK(!RTCString("abc").equals("def"));
138	CHECK(RTCString("abc").equalsIgnoreCase("Abc"));
139	CHECK(RTCString("abc").equalsIgnoreCase("ABc"));
140	CHECK(RTCString("abc").equalsIgnoreCase("ABC"));
141	CHECK(!RTCString("abc").equalsIgnoreCase("dBC"));
142	CHECK(RTCString("").equals(""));
143	CHECK(RTCString("").equals(NULL));
144	CHECK(!RTCString("").equals("a"));
145	CHECK(!RTCString("a").equals(""));
146	CHECK(!RTCString("a").equals(NULL));
147	CHECK(RTCString("").equalsIgnoreCase(""));
148	CHECK(RTCString("").equalsIgnoreCase(NULL));
149	CHECK(!RTCString("").equalsIgnoreCase("a"));
150	CHECK(!RTCString("a").equalsIgnoreCase(""));
151
152	copy2.setNull();
153	for (int i = 0; i < 100; ++i)
154	{
155	copy2.reserve(50); // should be ignored after 50 loops
156	copy2.append("1");
157	}
158	CHECK(copy2.length() == 100);
159
160	copy2.setNull();
161	for (int i = 0; i < 100; ++i)
162	{
163	copy2.reserve(50); // should be ignored after 50 loops
164	copy2.append('1');
165	}
166	CHECK(copy2.length() == 100);
167
168	/* printf */
169	RTCString StrFmt;
170	CHECK(StrFmt.printf("%s-%s-%d", "abc", "def", 42).equals("abc-def-42"));
171	test1Hlp1("abc-42-def", "%s-%d-%s", "abc", 42, "def");
172	test1Hlp1("", "");
173	test1Hlp1("1", "1");
174	test1Hlp1("foobar", "%s", "foobar");
175
176	/* substring constructors */
177	RTCString SubStr1("", (size_t)0);
178	CHECK_EQUAL(SubStr1, "");
179
180	RTCString SubStr2("abcdef", 2);
181	CHECK_EQUAL(SubStr2, "ab");
182
183	RTCString SubStr3("abcdef", 1);
184	CHECK_EQUAL(SubStr3, "a");
185
186	RTCString SubStr4("abcdef", 6);
187	CHECK_EQUAL(SubStr4, "abcdef");
188
189	RTCString SubStr5("abcdef", 7);
190	CHECK_EQUAL(SubStr5, "abcdef");
191
192
193	RTCString SubStrBase("abcdef");
194
195	RTCString SubStr10(SubStrBase, 0);
196	CHECK_EQUAL(SubStr10, "abcdef");
197
198	RTCString SubStr11(SubStrBase, 1);
199	CHECK_EQUAL(SubStr11, "bcdef");
200
201	RTCString SubStr12(SubStrBase, 1, 1);
202	CHECK_EQUAL(SubStr12, "b");
203
204	RTCString SubStr13(SubStrBase, 2, 3);
205	CHECK_EQUAL(SubStr13, "cde");
206
207	RTCString SubStr14(SubStrBase, 2, 4);
208	CHECK_EQUAL(SubStr14, "cdef");
209
210	RTCString SubStr15(SubStrBase, 2, 5);
211	CHECK_EQUAL(SubStr15, "cdef");
212
213	/* substr() and substrCP() functions */
214	RTCString strTest("");
215	CHECK_EQUAL(strTest.substr(0), "");
216	CHECK_EQUAL(strTest.substrCP(0), "");
217	CHECK_EQUAL(strTest.substr(1), "");
218	CHECK_EQUAL(strTest.substrCP(1), "");
219
220	/* now let's have some non-ASCII to chew on */
221	strTest = "abcdefßäbcdef";
222	// 13 codepoints, but 15 bytes (excluding null terminator);
223	// "ß" and "ä" consume two bytes each
224	CHECK_EQUAL(strTest.substr(0), strTest.c_str());
225	CHECK_EQUAL(strTest.substrCP(0), strTest.c_str());
226
227	CHECK_EQUAL(strTest.substr(2), "cdefßäbcdef");
228	CHECK_EQUAL(strTest.substrCP(2), "cdefßäbcdef");
229
230	CHECK_EQUAL(strTest.substr(2, 2), "cd");
231	CHECK_EQUAL(strTest.substrCP(2, 2), "cd");
232
233	CHECK_EQUAL(strTest.substr(6), "ßäbcdef");
234	CHECK_EQUAL(strTest.substrCP(6), "ßäbcdef");
235
236	CHECK_EQUAL(strTest.substr(6, 2), "ß"); // UTF-8 "ß" consumes two bytes
237	CHECK_EQUAL(strTest.substrCP(6, 1), "ß");
238
239	CHECK_EQUAL(strTest.substr(8), "äbcdef"); // UTF-8 "ß" consumes two bytes
240	CHECK_EQUAL(strTest.substrCP(7), "äbcdef");
241
242	CHECK_EQUAL(strTest.substr(8, 3), "äb"); // UTF-8 "ä" consumes two bytes
243	CHECK_EQUAL(strTest.substrCP(7, 2), "äb");
244
245	CHECK_EQUAL(strTest.substr(14, 1), "f");
246	CHECK_EQUAL(strTest.substrCP(12, 1), "f");
247
248	CHECK_EQUAL(strTest.substr(15, 1), "");
249	CHECK_EQUAL(strTest.substrCP(13, 1), "");
250
251	CHECK_EQUAL(strTest.substr(16, 1), "");
252	CHECK_EQUAL(strTest.substrCP(15, 1), "");
253
254	/* and check cooperation with find() */
255	size_t pos = strTest.find("ß");
256	CHECK_EQUAL(strTest.substr(pos), "ßäbcdef");
257
258	/* split */
259	RTCList<RTCString> spList1 = RTCString("##abcdef##abcdef####abcdef##").split("##", RTCString::RemoveEmptyParts);
260	RTTESTI_CHECK(spList1.size() == 3);
261	for (size_t i = 0; i < spList1.size(); ++i)
262	RTTESTI_CHECK(spList1.at(i) == "abcdef");
263	RTCList<RTCString> spList2 = RTCString("##abcdef##abcdef####abcdef##").split("##", RTCString::KeepEmptyParts);
264	RTTESTI_CHECK_RETV(spList2.size() == 5);
265	RTTESTI_CHECK(spList2.at(0) == "");
266	RTTESTI_CHECK(spList2.at(1) == "abcdef");
267	RTTESTI_CHECK(spList2.at(2) == "abcdef");
268	RTTESTI_CHECK(spList2.at(3) == "");
269	RTTESTI_CHECK(spList2.at(4) == "abcdef");
270	RTCList<RTCString> spList3 = RTCString().split("##", RTCString::KeepEmptyParts);
271	RTTESTI_CHECK(spList3.size() == 0);
272	RTCList<RTCString> spList4 = RTCString().split("");
273	RTTESTI_CHECK(spList4.size() == 0);
274	RTCList<RTCString> spList5 = RTCString("abcdef").split("");
275	RTTESTI_CHECK_RETV(spList5.size() == 1);
276	RTTESTI_CHECK(spList5.at(0) == "abcdef");
277
278	/* join */
279	RTCList<RTCString> jnList;
280	strTest = RTCString::join(jnList);
281	RTTESTI_CHECK(strTest == "");
282	strTest = RTCString::join(jnList, "##");
283	RTTESTI_CHECK(strTest == "");
284
285	jnList.append("abcdef");
286	strTest = RTCString::join(jnList, "##");
287	RTTESTI_CHECK(strTest == "abcdef");
288
289	jnList.append("abcdef");
290	strTest = RTCString::join(jnList, ";");
291	RTTESTI_CHECK(strTest == "abcdef;abcdef");
292
293	for (size_t i = 0; i < 3; ++i)
294	jnList.append("abcdef");
295	strTest = RTCString::join(jnList);
296	RTTESTI_CHECK(strTest == "abcdefabcdefabcdefabcdefabcdef");
297	strTest = RTCString::join(jnList, "##");
298	RTTESTI_CHECK(strTest == "abcdef##abcdef##abcdef##abcdef##abcdef");
299
300	/* special constructor and assignment arguments */
301	RTCString StrCtor1("");
302	RTTESTI_CHECK(StrCtor1.isEmpty());
303	RTTESTI_CHECK(StrCtor1.length() == 0);
304
305	RTCString StrCtor2(NULL);
306	RTTESTI_CHECK(StrCtor2.isEmpty());
307	RTTESTI_CHECK(StrCtor2.length() == 0);
308
309	RTCString StrCtor1d(StrCtor1);
310	RTTESTI_CHECK(StrCtor1d.isEmpty());
311	RTTESTI_CHECK(StrCtor1d.length() == 0);
312
313	RTCString StrCtor2d(StrCtor2);
314	RTTESTI_CHECK(StrCtor2d.isEmpty());
315	RTTESTI_CHECK(StrCtor2d.length() == 0);
316
317	for (unsigned i = 0; i < 2; i++)
318	{
319	RTCString StrAssign;
320	if (i) StrAssign = "abcdef";
321	StrAssign = (char *)NULL;
322	RTTESTI_CHECK(StrAssign.isEmpty());
323	RTTESTI_CHECK(StrAssign.length() == 0);
324
325	if (i) StrAssign = "abcdef";
326	StrAssign = "";
327	RTTESTI_CHECK(StrAssign.isEmpty());
328	RTTESTI_CHECK(StrAssign.length() == 0);
329
330	if (i) StrAssign = "abcdef";
331	StrAssign = StrCtor1;
332	RTTESTI_CHECK(StrAssign.isEmpty());
333	RTTESTI_CHECK(StrAssign.length() == 0);
334
335	if (i) StrAssign = "abcdef";
336	StrAssign = StrCtor2;
337	RTTESTI_CHECK(StrAssign.isEmpty());
338	RTTESTI_CHECK(StrAssign.length() == 0);
339	}
340
341	#undef CHECK
342	#undef CHECK_DUMP
343	#undef CHECK_DUMP_I
344	#undef CHECK_EQUAL
345	}
346
347
348	static int mymemcmp(const char psz1, const char psz2, size_t cch)
349	{
350	for (size_t off = 0; off < cch; off++)
351	if (psz1[off] != psz2[off])
352	{
353	RTTestIFailed("off=%#x psz1=%.Rhxs psz2=%.Rhxs\n", off,
354	RT_MIN(cch - off, 8), &psz1[off],
355	RT_MIN(cch - off, 8), &psz2[off]);
356	return psz1[off] > psz2[off] ? 1 : -1;
357	}
358	return 0;
359	}
360
361	static void test2(RTTEST hTest)
362	{
363	RTTestSub(hTest, "UTF-8 upper/lower encoding assumption");
364
365	#define CHECK_EQUAL(str1, str2) \
366	do \
367	{ \
368	RTTESTI_CHECK(strlen((str1).c_str()) == (str1).length()); \
369	RTTESTI_CHECK((str1).length() == (str2).length()); \
370	RTTESTI_CHECK(mymemcmp((str1).c_str(), (str2).c_str(), (str2).length() + 1) == 0); \
371	} while (0)
372
373	RTCString strTmp;
374	char szDst[16];
375
376	/* Collect all upper and lower case code points. */
377	RTCString strLower("");
378	strLower.reserve(_4M);
379
380	RTCString strUpper("");
381	strUpper.reserve(_4M);
382
383	for (RTUNICP uc = 1; uc <= 0x10fffd; uc++)
384	{
385	if (RTUniCpIsLower(uc))
386	{
387	RTTESTI_CHECK_MSG(uc < 0xd800 \|\| (uc > 0xdfff && uc != 0xfffe && uc != 0xffff), ("%#x\n", uc));
388	strLower.appendCodePoint(uc);
389	}
390	if (RTUniCpIsUpper(uc))
391	{
392	RTTESTI_CHECK_MSG(uc < 0xd800 \|\| (uc > 0xdfff && uc != 0xfffe && uc != 0xffff), ("%#x\n", uc));
393	strUpper.appendCodePoint(uc);
394	}
395	}
396	RTTESTI_CHECK(strlen(strLower.c_str()) == strLower.length());
397	RTTESTI_CHECK(strlen(strUpper.c_str()) == strUpper.length());
398
399	/* Fold each code point in the lower case string and check that it encodes
400	into the same or less number of bytes. */
401	size_t cch = 0;
402	const char *pszCur = strLower.c_str();
403	RTCString strUpper2("");
404	strUpper2.reserve(strLower.length() + 64);
405	for (;;)
406	{
407	RTUNICP ucLower;
408	const char * const pszPrev = pszCur;
409	RTTESTI_CHECK_RC_BREAK(RTStrGetCpEx(&pszCur, &ucLower), VINF_SUCCESS);
410	size_t const cchSrc = pszCur - pszPrev;
411	if (!ucLower)
412	break;
413
414	RTUNICP const ucUpper = RTUniCpToUpper(ucLower);
415	const char *pszDstEnd = RTStrPutCp(szDst, ucUpper);
416	size_t const cchDst = pszDstEnd - &szDst[0];
417	RTTESTI_CHECK_MSG(cchSrc >= cchDst,
418	("ucLower=%#x %u bytes; ucUpper=%#x %u bytes\n",
419	ucLower, cchSrc, ucUpper, cchDst));
420	cch += cchDst;
421	strUpper2.appendCodePoint(ucUpper);
422
423	/* roundtrip stability */
424	RTUNICP const ucUpper2 = RTUniCpToUpper(ucUpper);
425	RTTESTI_CHECK_MSG(ucUpper2 == ucUpper, ("ucUpper2=%#x ucUpper=%#x\n", ucUpper2, ucUpper));
426
427	RTUNICP const ucLower2 = RTUniCpToLower(ucUpper);
428	RTUNICP const ucUpper3 = RTUniCpToUpper(ucLower2);
429	RTTESTI_CHECK_MSG(ucUpper3 == ucUpper, ("ucUpper3=%#x ucUpper=%#x\n", ucUpper3, ucUpper));
430
431	pszDstEnd = RTStrPutCp(szDst, ucLower2);
432	size_t const cchLower2 = pszDstEnd - &szDst[0];
433	RTTESTI_CHECK_MSG(cchDst == cchLower2,
434	("ucLower2=%#x %u bytes; ucUpper=%#x %u bytes\n",
435	ucLower2, cchLower2, ucUpper, cchDst));
436	}
437	RTTESTI_CHECK(strlen(strUpper2.c_str()) == strUpper2.length());
438	RTTESTI_CHECK_MSG(cch == strUpper2.length(), ("cch=%u length()=%u\n", cch, strUpper2.length()));
439
440	/* the toUpper method shall do the same thing. */
441	strTmp = strLower; CHECK_EQUAL(strTmp, strLower);
442	strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2);
443
444	/* Ditto for the upper case string. */
445	cch = 0;
446	pszCur = strUpper.c_str();
447	RTCString strLower2("");
448	strLower2.reserve(strUpper.length() + 64);
449	for (;;)
450	{
451	RTUNICP ucUpper;
452	const char * const pszPrev = pszCur;
453	RTTESTI_CHECK_RC_BREAK(RTStrGetCpEx(&pszCur, &ucUpper), VINF_SUCCESS);
454	size_t const cchSrc = pszCur - pszPrev;
455	if (!ucUpper)
456	break;
457
458	RTUNICP const ucLower = RTUniCpToLower(ucUpper);
459	const char *pszDstEnd = RTStrPutCp(szDst, ucLower);
460	size_t const cchDst = pszDstEnd - &szDst[0];
461	RTTESTI_CHECK_MSG(cchSrc >= cchDst,
462	("ucUpper=%#x %u bytes; ucLower=%#x %u bytes\n",
463	ucUpper, cchSrc, ucLower, cchDst));
464
465	cch += cchDst;
466	strLower2.appendCodePoint(ucLower);
467
468	/* roundtrip stability */
469	RTUNICP const ucLower2 = RTUniCpToLower(ucLower);
470	RTTESTI_CHECK_MSG(ucLower2 == ucLower, ("ucLower2=%#x ucLower=%#x\n", ucLower2, ucLower));
471
472	RTUNICP const ucUpper2 = RTUniCpToUpper(ucLower);
473	RTUNICP const ucLower3 = RTUniCpToLower(ucUpper2);
474	RTTESTI_CHECK_MSG(ucLower3 == ucLower, ("ucLower3=%#x ucLower=%#x\n", ucLower3, ucLower));
475
476	pszDstEnd = RTStrPutCp(szDst, ucUpper2);
477	size_t const cchUpper2 = pszDstEnd - &szDst[0];
478	RTTESTI_CHECK_MSG(cchDst == cchUpper2,
479	("ucUpper2=%#x %u bytes; ucLower=%#x %u bytes\n",
480	ucUpper2, cchUpper2, ucLower, cchDst));
481	}
482	RTTESTI_CHECK(strlen(strLower2.c_str()) == strLower2.length());
483	RTTESTI_CHECK_MSG(cch == strLower2.length(), ("cch=%u length()=%u\n", cch, strLower2.length()));
484
485	strTmp = strUpper; CHECK_EQUAL(strTmp, strUpper);
486	strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2);
487
488	/* Checks of folding stability when nothing shall change. */
489	strTmp = strUpper; CHECK_EQUAL(strTmp, strUpper);
490	strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper);
491	strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper);
492	strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper);
493
494	strTmp = strUpper2; CHECK_EQUAL(strTmp, strUpper2);
495	strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2);
496	strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2);
497	strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2);
498
499	strTmp = strLower; CHECK_EQUAL(strTmp, strLower);
500	strTmp.toLower(); CHECK_EQUAL(strTmp, strLower);
501	strTmp.toLower(); CHECK_EQUAL(strTmp, strLower);
502	strTmp.toLower(); CHECK_EQUAL(strTmp, strLower);
503
504	strTmp = strLower2; CHECK_EQUAL(strTmp, strLower2);
505	strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2);
506	strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2);
507	strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2);
508
509	/* Check folding stability for roundtrips. */
510	strTmp = strUpper; CHECK_EQUAL(strTmp, strUpper);
511	strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2);
512	strTmp.toUpper();
513	strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2);
514	strTmp.toUpper();
515	strTmp.toLower(); CHECK_EQUAL(strTmp, strLower2);
516
517	strTmp = strLower; CHECK_EQUAL(strTmp, strLower);
518	strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2);
519	strTmp.toLower();
520	strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2);
521	strTmp.toLower();
522	strTmp.toUpper(); CHECK_EQUAL(strTmp, strUpper2);
523	}
524
525
526	int main()
527	{
528	RTTEST hTest;
529	RTEXITCODE rcExit = RTTestInitAndCreate("tstIprtMiniString", &hTest);
530	if (rcExit == RTEXITCODE_SUCCESS)
531	{
532	RTTestBanner(hTest);
533
534	test1(hTest);
535	test2(hTest);
536
537	rcExit = RTTestSummaryAndDestroy(hTest);
538	}
539	return rcExit;
540	}
541

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

source: vbox/trunk/src/VBox/Runtime/testcase/tstIprtMiniString.cpp@ 39837

Download in other formats: