tests/dpl/core/test_string.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /*
  17  * @file        test_string.cpp
  18  * @author      Piotr Marcinkiewicz (p.marcinkiew@samsung.com)
  19  * @version     1.0
  20  * @brief       This file is the implementation file of string tests
  21  */
  22 #include <stdlib.h>
  23 #include <cmath>
  24 #include <cstring>
  25 #include <vector>
  26 #include <dpl/test/test_runner.h>
  27 #include <dpl/string.h>
  28 #include <dpl/sstream.h>
  29
  30 RUNNER_TEST_GROUP_INIT(DPL)
  31
  32 unsigned char GetBaseCode(int index);
  33 unsigned char GetBaseCode(int index)
  34 {
  35     /* aaaack but it's fast and const should make it shared text page. */
  36     static const unsigned char pr2six[256] =
  37     {
  38         /* ASCII table */
  39         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  40         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  41         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63,
  42         52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
  43         64,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
  44         15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64,
  45         64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
  46         41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
  47         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  48         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  49         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  50         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  51         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  52         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  53         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  54         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
  55     };
  56     return pr2six[index];
  57 }
  58
  59
  60 /* Function adapted from APR library (http://apr.apache.org/) */
  61 int wbxml_base64_decode(const char *buffer, char **result);
  62 int wbxml_base64_decode(const char *buffer, char **result)
  63 {
  64     int nbytesdecoded = 0, nprbytes = 0;
  65     const char *bufin = NULL;
  66     char *bufout = NULL;
  67
  68     if ((buffer == NULL) || (result == NULL))
  69         return 0;
  70
  71     /* Initialize output buffer */
  72     *result = NULL;
  73
  74     bufin = buffer;
  75     while (GetBaseCode(*(bufin++)) <= 63) {}
  76
  77     nprbytes = (bufin - buffer) - 1;
  78     nbytesdecoded = ((nprbytes + 3) / 4) * 3;
  79
  80     /* Malloc result buffer */
  81     if ((*result = (char*) malloc(nbytesdecoded + 1)) == NULL)
  82         return 0;
  83     memset(*result, nbytesdecoded + 1, 0);
  84
  85     bufout = *result;
  86     bufin = buffer;
  87
  88     while (nprbytes > 4)
  89     {
  90         *(bufout++) = (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
  91         *(bufout++) = (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
  92         *(bufout++) = (char)(GetBaseCode(bufin[2]) << 6 | GetBaseCode(bufin[3]));
  93         bufin += 4;
  94         nprbytes -= 4;
  95     }
  96
  97     /* Note: (nprbytes == 1) would be an error, so just ingore that case */
  98     if (nprbytes > 1)
  99     {
 100         *(bufout++) = (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
 101     }
 102     if (nprbytes > 2)
 103     {
 104         *(bufout++) = (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
 105     }
 106     if (nprbytes > 3)
 107     {
 108         *(bufout++) = (char)(GetBaseCode(bufin[2]) << 6 | GetBaseCode(bufin[3]));
 109     }
 110
 111     nbytesdecoded -= (4 - nprbytes) & 3;
 112
 113     return nbytesdecoded;
 114 }
 115
 116 //#define TEST_CONVERSION(in_string, out_string, buffer_type, function
 117
 118 const char utf32Encoded[] =
 119 "RDAAAI0wAABvMAAAazAAAHswAAB4MAAAaDAAAAAwAABhMAAAijAAAGwwAACLMAAAkjAAAAAwAACP\
 120 MAAASzAAAIgwAABfMAAAjDAAAF0wAAAAMAAAZDAAAG0wAABqMAAAiTAAAIAwAAAAMAAARjAAAJAw\
 121 AABuMAAASjAAAE8wAACEMAAAfjAAAAAwAABRMAAAdTAAAFMwAABIMAAAZjAAAAAwAABCMAAAVTAA\
 122 AE0wAACGMAAAgTAAAH8wAABXMAAAADAAAJEwAAByMAAAgjAAAFswAABZMAAACgAAANsFAADaBQAA\
 123 IAAAANQFAADqBQAA6AUAAOEFAADnBQAAIAAAAOAFAADkBQAA5QUAACAAAADiBQAA3AUAACAAAADS\
 124 BQAA1QUAANYFAADcBQAAIAAAAOcFAADYBQAA3wUAACwAAAAgAAAA6QUAANMFAADXBQAA4wUAACAA\
 125 AADQBQAA6gUAACAAAADmBQAA0QUAANkFAAAgAAAA3AUAAN4FAADZBQAA3QUAAAoAAACk0AAApMIA\
 126 AFjHAAAgAAAA4KwAACDHAABwyAAAdKwAAEDHAAAgAAAAhccAACDCAAB8sAAArLkAACAAAADMuQAA\
 127 mLAAAHzFAAAgAAAAWNUAAOCsAAAgAAAAudIAAMS8AABc1QAAIAAAADCuAAAgwgAAQMcAACAAAABE\
 128 1QAAlMYAAFjOAAAgAAAASsUAAOSyAAAKAAAAUAAAAGMAAABoAAAAbgAAAAUBAAAHAQAAIAAAAHcA\
 129 AAAgAAAAdAAAABkBAAAgAAAAQgEAAPMAAABkAAAAegEAACAAAABqAAAAZQAAAHwBAABhAAAAIAAA\
 130 AGwAAAB1AAAAYgAAACAAAABvAAAAWwEAAG0AAAAgAAAAcwAAAGsAAAByAAAAegAAAHkAAABEAQAA\
 131 IAAAAGYAAABpAAAAZwAAAC4AAAAKAAAAQgAAAGwAAABvAAAAdwAAAHoAAAB5AAAAIAAAAG4AAABp\
 132 AAAAZwAAAGgAAAB0AAAALQAAAGYAAAByAAAAdQAAAG0AAABwAAAAcwAAACAAAAB2AAAAZQAAAHgA\
 133 AAAnAAAAZAAAACAAAABKAAAAYQAAAGMAAABrAAAAIAAAAFEAAAAuAAAACgAAAEYGAAA1BgAAIAAA\
 134 AC0GAABDBgAASgYAAEUGAAAgAAAARAYAAEcGAAAgAAAAMwYAADEGAAAgAAAAQgYAACcGAAA3BgAA\
 135 OQYAACAAAABIBgAAMAYAAEgGAAAgAAAANAYAACMGAABGBgAAIAAAADkGAAA4BgAASgYAAEUGAAAg\
 136 AAAARQYAAEMGAAAqBgAASAYAACgGAAAgAAAAOQYAAEQGAABJBgAAIAAAACsGAABIBgAAKAYAACAA\
 137 AAAjBgAALgYAADYGAAAxBgAAIAAAAEgGAABFBgAAOgYAAEQGAABBBgAAIAAAACgGAAAsBgAARAYA\
 138 AC8GAAAgAAAAIwYAADIGAAAxBgAAQgYAACAAAAAKAAAAEgQAACAAAABHBAAAMAQAAEkEAAAwBAAA\
 139 RQQAACAAAABOBAAAMwQAADAEAAAgAAAANgQAADgEAAA7BAAAIAAAADEEAABLBAAAIAAAAEYEAAA4\
 140 BAAAQgQAAEAEAABDBAAAQQQAAD8AAAAgAAAAFAQAADAEAAAsAAAAIAAAAD0EAAA+BAAAIAAAAEQE\
 141 AAAwBAAAOwQAAEwEAABIBAAAOAQAADIEAABLBAAAOQQAACAAAABNBAAAOgQAADcEAAA1BAAAPAQA\
 142 AD8EAAA7BAAATwQAAEAEAAAhAAAACgAAAKQDAACsAwAAxwMAALkDAADDAwAAxAMAALcDAAAgAAAA\
 143 sQMAALsDAADOAwAAwAMAALcDAAC+AwAAIAAAALIDAACxAwAAxgMAAK4DAADCAwAAIAAAAMgDAAC3\
 144 AwAAvAMAAK0DAAC9AwAAtwMAACAAAACzAwAAtwMAACwAAAAgAAAAtAMAAMEDAACxAwAAwwMAALoD\
 145 AAC1AwAAuwMAAK8DAAC2AwAAtQMAALkDAAAgAAAAxQMAAMADAACtAwAAwQMAACAAAAC9AwAAyQMA\
 146 ALgDAADBAwAAvwMAAM0DAAAgAAAAugMAAMUDAAC9AwAAzAMAAMIDAAAKAAAAVgAAAGkAAABjAAAA\
 147 dAAAAG8AAAByAAAAIAAAAGoAAABhAAAAZwAAAHQAAAAgAAAAegAAAHcAAAD2AAAAbAAAAGYAAAAg\
 148 AAAAQgAAAG8AAAB4AAAAawAAAOQAAABtAAAAcAAAAGYAAABlAAAAcgAAACAAAABxAAAAdQAAAGUA\
 149 AAByAAAAIAAAAPwAAABiAAAAZQAAAHIAAAAgAAAAZAAAAGUAAABuAAAAIAAAAGcAAAByAAAAbwAA\
 150 AN8AAABlAAAAbgAAACAAAABTAAAAeQAAAGwAAAB0AAAAZQAAAHIAAAAgAAAARAAAAGUAAABpAAAA\
 151 YwAAAGgAAAAKAAAAlokAAM6RAAAhcQAAUJYAAONeAAAM/wAAl3oAABZZAAAJZwAAzYUAAClZAAAK\
 152 AAAACgAAAAAAAAA=";
 153
 154 const char utf8Encoded[] =
 155 "44GE44KN44Gv44Gr44G744G444Go44CA44Gh44KK44Gs44KL44KS44CA44KP44GL44KI44Gf44KM\
 156 44Gd44CA44Gk44Gt44Gq44KJ44KA44CA44GG44KQ44Gu44GK44GP44KE44G+44CA44GR44G144GT\
 157 44GI44Gm44CA44GC44GV44GN44KG44KB44G/44GX44CA44KR44Gy44KC44Gb44GZCteb15og15TX\
 158 qteo16HXpyDXoNek16Ug16LXnCDXkteV15bXnCDXp9eY158sINep15PXl9ejINeQ16og16bXkdeZ\
 159 INec157XmdedCu2CpOyKpOydmCDqs6DsnKDsobDqsbTsnYAg7J6F7Iig64G866asIOunjOuCmOyV\
 160 vCDtlZjqs6Ag7Yq567OE7ZWcIOq4sOyIoOydgCDtlYTsmpTsuZgg7JWK64ukClBjaG7EhcSHIHcg\
 161 dMSZIMWCw7NkxbogamXFvGEgbHViIG/Fm20gc2tyennFhCBmaWcuCkJsb3d6eSBuaWdodC1mcnVt\
 162 cHMgdmV4J2QgSmFjayBRLgrZhti1INit2YPZitmFINmE2Ycg2LPYsSDZgtin2LfYuSDZiNiw2Ygg\
 163 2LTYo9mGINi52LjZitmFINmF2YPYqtmI2Kgg2LnZhNmJINir2YjYqCDYo9iu2LbYsSDZiNmF2LrZ\
 164 hNmBINio2KzZhNivINij2LLYsdmCIArQkiDRh9Cw0YnQsNGFINGO0LPQsCDQttC40Lsg0LHRiyDR\
 165 htC40YLRgNGD0YE/INCU0LAsINC90L4g0YTQsNC70YzRiNC40LLRi9C5INGN0LrQt9C10LzQv9C7\
 166 0Y/RgCEKzqTOrM+HzrnPg8+EzrcgzrHOu8+Oz4DOt86+IM6yzrHPhs6uz4Igz4jOt868zq3Ovc63\
 167 IM6zzrcsIM60z4HOsc+DzrrOtc67zq/Ots61zrkgz4XPgM6tz4Egzr3Pic64z4HOv8+NIM66z4XO\
 168 vc+Mz4IKVmljdG9yIGphZ3QgenfDtmxmIEJveGvDpG1wZmVyIHF1ZXIgw7xiZXIgZGVuIGdyb8Of\
 169 ZW4gU3lsdGVyIERlaWNoCuimlumHjueEoemZkOW7o++8jOeql+WkluacieiXjeWkqQoKAA==";
 170
 171
 172
 173
 174 const char asciiEncodedIso1[] =
 175 "ISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZ\
 176 WltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fgA=";
 177
 178 const char asciiEncodedUtf32[] =
 179 "IQAAACIAAAAjAAAAJAAAACUAAAAmAAAAJwAAACgAAAApAAAAKgAAACsAAAAsAAAALQAAAC4AAAAv\
 180 AAAAMAAAADEAAAAyAAAAMwAAADQAAAA1AAAANgAAADcAAAA4AAAAOQAAADoAAAA7AAAAPAAAAD0A\
 181 AAA+AAAAPwAAAEAAAABBAAAAQgAAAEMAAABEAAAARQAAAEYAAABHAAAASAAAAEkAAABKAAAASwAA\
 182 AEwAAABNAAAATgAAAE8AAABQAAAAUQAAAFIAAABTAAAAVAAAAFUAAABWAAAAVwAAAFgAAABZAAAA\
 183 WgAAAFsAAABcAAAAXQAAAF4AAABfAAAAYAAAAGEAAABiAAAAYwAAAGQAAABlAAAAZgAAAGcAAABo\
 184 AAAAaQAAAGoAAABrAAAAbAAAAG0AAABuAAAAbwAAAHAAAABxAAAAcgAAAHMAAAB0AAAAdQAAAHYA\
 185 AAB3AAAAeAAAAHkAAAB6AAAAewAAAHwAAAB9AAAAfgAAAAAAAAA=";
 186
 187
 188 RUNNER_TEST(String_ConverterFromASCII)
 189 {
 190     char* inStr = NULL;
 191     int inSize = wbxml_base64_decode(asciiEncodedIso1, &inStr);
 192     RUNNER_ASSERT(inSize > 0);
 193     RUNNER_ASSERT(NULL != inStr);
 194     inStr[inSize] = '\0';
 195     {
 196         DPL::String asciiString = DPL::FromASCIIString(inStr);
 197
 198         std::string result = DPL::ToUTF8String(asciiString);
 199
 200         RUNNER_ASSERT(strlen(inStr) == result.size());
 201
 202         RUNNER_ASSERT(0 == memcmp(inStr, result.c_str(), result.size()));
 203     }
 204
 205     free(inStr);
 206 }
 207
 208 RUNNER_TEST(String_ConverterFromUTF8)
 209 {
 210     char* inStr = NULL;
 211     int inSize = wbxml_base64_decode(asciiEncodedIso1, &inStr);
 212     RUNNER_ASSERT(inSize > 0);
 213     RUNNER_ASSERT(NULL != inStr);
 214     {
 215         DPL::String asciiString = DPL::FromUTF8String(inStr);
 216
 217         std::string result = DPL::ToUTF8String(asciiString);
 218
 219         RUNNER_ASSERT(strlen(inStr) == result.size());
 220
 221         RUNNER_ASSERT(0 == memcmp(inStr, result.c_str(), result.size()));
 222     }
 223
 224     free(inStr);
 225 }
 226
 227 RUNNER_TEST(String_ConverterFromUTF32)
 228 {
 229     wchar_t* inStr = NULL;
 230     int inSize = wbxml_base64_decode(utf32Encoded, reinterpret_cast<char**>(&inStr));
 231     RUNNER_ASSERT(inSize > 0);
 232     RUNNER_ASSERT(NULL != inStr);
 233     char* outStr = NULL;
 234     int outSize = wbxml_base64_decode(utf8Encoded, &outStr);
 235     RUNNER_ASSERT(outSize > 0);
 236     RUNNER_ASSERT(NULL != outStr);
 237     outStr[outSize] = '\0';
 238     {
 239         DPL::String utfString = DPL::FromUTF32String(inStr);
 240         std::string result = DPL::ToUTF8String(utfString);
 241
 242         RUNNER_ASSERT(strlen(outStr) == result.size());
 243         RUNNER_ASSERT(0 == memcmp(outStr, result.c_str(), result.size()));
 244
 245
 246         RUNNER_ASSERT(inSize / sizeof(wchar_t) - 1 == utfString.size());
 247         RUNNER_ASSERT(0 == memcmp(inStr, &(utfString[0]), utfString.size() * sizeof(wchar_t)));
 248
 249     }
 250
 251     free(inStr);
 252 }
 253
 254 template<typename DelimiterType>
 255 void String_TokenizeReal(const DelimiterType& delimiter)
 256 {
 257     DPL::String str(L".##..abc.#.");
 258     std::vector<DPL::String> tokens;
 259     DPL::Tokenize(str, delimiter, std::back_inserter(tokens));
 260
 261     std::vector<DPL::String> expectedTokens;
 262     for ( int i = 0 ; i < 5 ; i++ )
 263         expectedTokens.push_back(L"");
 264     expectedTokens.push_back(L"abc");
 265     for ( int i = 0 ; i < 3 ; i++ )
 266         expectedTokens.push_back(L"");
 267
 268     RUNNER_ASSERT(expectedTokens == tokens);
 269     tokens.clear();
 270     expectedTokens.clear();
 271
 272     DPL::Tokenize(str, delimiter, std::back_inserter(tokens), true);
 273     expectedTokens.push_back(L"abc");
 274     RUNNER_ASSERT(expectedTokens == tokens);
 275 }
 276
 277 RUNNER_TEST(String_Tokenize)
 278 {
 279     String_TokenizeReal(L"#.");
 280     String_TokenizeReal(L".#");
 281     String_TokenizeReal(L".....####.###..");
 282     String_TokenizeReal(DPL::String(L".#"));
 283
 284     std::vector<std::string> tokens;
 285     DPL::Tokenize(std::string("abc.def"), '.', std::back_inserter(tokens));
 286     std::vector<std::string> expectedTokens;
 287     expectedTokens.push_back("abc");
 288     expectedTokens.push_back("def");
 289
 290     RUNNER_ASSERT(tokens == expectedTokens);
 291 }
 292
 293 template <typename TemplateArgumentCharTraits>
 294 void TestInStreams(
 295     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 296                       TemplateArgumentCharTraits> argumentInString,
 297     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 298                       TemplateArgumentCharTraits> argumentResultString)
 299 {
 300     typedef std::basic_string<typename TemplateArgumentCharTraits::char_type,
 301                               TemplateArgumentCharTraits>
 302                                 String;
 303     std::basic_istringstream<typename TemplateArgumentCharTraits::char_type,
 304                              TemplateArgumentCharTraits>
 305                                 istream(argumentInString);
 306     int intValue = 0;
 307     double doubleValue = 0.0;
 308     float floatValue = 0.0;
 309     String stringValue;
 310
 311     istream >> intValue;
 312     RUNNER_ASSERT(!istream.fail());
 313     istream >> doubleValue;
 314     RUNNER_ASSERT(!istream.fail());
 315     istream >> floatValue;
 316     RUNNER_ASSERT(!istream.fail());
 317     istream >> stringValue;
 318     RUNNER_ASSERT(!istream.fail());
 319
 320     RUNNER_ASSERT(1 == intValue);
 321     RUNNER_ASSERT(fabs(1.1f - doubleValue) < 0.00001);
 322     RUNNER_ASSERT(fabs(1.1f - floatValue) < 0.00001);
 323     RUNNER_ASSERT(argumentResultString == stringValue);
 324 }
 325
 326 template <typename TemplateArgumentCharTraits>
 327 void TestOutStreams(
 328     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 329                       TemplateArgumentCharTraits> argumentInString,
 330     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 331                       TemplateArgumentCharTraits> argumentResultString)
 332 {
 333     typedef std::basic_string<typename TemplateArgumentCharTraits::char_type,
 334                               TemplateArgumentCharTraits>
 335                                 String;
 336
 337     std::basic_ostringstream<typename TemplateArgumentCharTraits::char_type,
 338                              TemplateArgumentCharTraits>
 339                                 ostream;
 340
 341     int intValue = 1;
 342     double doubleValue = 1.1;
 343     float floatValue = 1.1f;
 344     String stringValue = argumentInString;
 345
 346     ostream << intValue;
 347     RUNNER_ASSERT(!ostream.fail());
 348     ostream << doubleValue;
 349     RUNNER_ASSERT(!ostream.fail());
 350     ostream << floatValue;
 351     RUNNER_ASSERT(!ostream.fail());
 352     ostream << stringValue;
 353     RUNNER_ASSERT(!ostream.fail());
 354
 355     RUNNER_ASSERT(ostream.str() == argumentResultString);
 356 }
 357
 358 RUNNER_TEST(String_Streams)
 359 {
 360     TestInStreams<std::char_traits<char> >("1 1.1 1.1 test", "test");
 361     TestInStreams<std::char_traits<wchar_t> >(L"1 1.1 1.1 test", L"test");
 362     TestInStreams<DPL::CharTraits>(L"1 1.1 1.1 test", L"test");
 363     TestOutStreams<std::char_traits<char> >("test",  "11.11.1test");
 364     TestOutStreams<std::char_traits<wchar_t> >(L"test",  L"11.11.1test");
 365     TestOutStreams<DPL::CharTraits>(L"test",  L"11.11.1test");
 366 }
 367
 368 RUNNER_TEST(String_CompareCaseSensitive)
 369 {
 370     RUNNER_ASSERT(
 371         DPL::StringCompare(
 372             DPL::FromUTF32String(L"Ala Makota ma żołądkówkę"),
 373             DPL::FromUTF32String(L"Ala Makota ma żołądkówkę")) == 0);
 374 }
 375
 376 RUNNER_TEST(String_CompareCaseInsensitive)
 377 {
 378     RUNNER_ASSERT(
 379         DPL::StringCompare(
 380             DPL::FromUTF32String(L"Ala Makota ma żołądkówkę"),
 381             DPL::FromUTF32String(L"AlA MakOTA ma ŻoŁąDKÓwkę"),
 382             true) == 0);
 383 }
 384