VirtualBox

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

Last change on this file since 81106 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
40static 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
54static 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
371static 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 */
397static 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
406static 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
605int 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.

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