tstIprtMiniString.cpp@ 77923

Last change on this file since 77923 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 21.6 KB

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

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

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

Download in other formats: