tstIprtMiniString.cpp@ 53401

Last change on this file since 53401 was 51796, checked in by vboxsync, 10 years ago
Added two missing roundtrip case folding tests.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 21.1 KB

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

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

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

Download in other formats: