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         /* ASCII table */
  38         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  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, 62, 64, 64, 64, 63,
  41         52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
  42         64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
  43         15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64,
  44         64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
  45         41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
  46         64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 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     };
  55     return pr2six[index];
  56 }
  57
  58 /* Function adapted from APR library (http://apr.apache.org/) */
  59 int wbxml_base64_decode(const char *buffer, char **result);
  60 int wbxml_base64_decode(const char *buffer, char **result)
  61 {
  62     int nbytesdecoded = 0, nprbytes = 0;
  63     const char *bufin = NULL;
  64     char *bufout = NULL;
  65
  66     if ((buffer == NULL) || (result == NULL)) {
  67         return 0;
  68     }
  69
  70     /* Initialize output buffer */
  71     *result = NULL;
  72
  73     bufin = buffer;
  74     while (GetBaseCode(*(bufin++)) <= 63) {}
  75
  76     nprbytes = (bufin - buffer) - 1;
  77     nbytesdecoded = ((nprbytes + 3) / 4) * 3;
  78
  79     /* Malloc result buffer */
  80     if ((*result = (char*) malloc(nbytesdecoded + 1)) == NULL) {
  81         return 0;
  82     }
  83     memset(*result, 0, nbytesdecoded + 1);
  84
  85     bufout = *result;
  86     bufin = buffer;
  87
  88     while (nprbytes > 4) {
  89         *(bufout++) =
  90             (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
  91         *(bufout++) =
  92             (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
  93         *(bufout++) = (char)(GetBaseCode(bufin[2]) << 6 | GetBaseCode(bufin[3]));
  94         bufin += 4;
  95         nprbytes -= 4;
  96     }
  97
  98     /* Note: (nprbytes == 1) would be an error, so just ingore that case */
  99     if (nprbytes > 1) {
 100         *(bufout++) =
 101             (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
 102     }
 103     if (nprbytes > 2) {
 104         *(bufout++) =
 105             (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
 106     }
 107     if (nprbytes > 3) {
 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 const char asciiEncodedIso1[] =
 172     "ISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZ\
 173 WltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fgA=";
 174
 175 const char asciiEncodedUtf32[] =
 176     "IQAAACIAAAAjAAAAJAAAACUAAAAmAAAAJwAAACgAAAApAAAAKgAAACsAAAAsAAAALQAAAC4AAAAv\
 177 AAAAMAAAADEAAAAyAAAAMwAAADQAAAA1AAAANgAAADcAAAA4AAAAOQAAADoAAAA7AAAAPAAAAD0A\
 178 AAA+AAAAPwAAAEAAAABBAAAAQgAAAEMAAABEAAAARQAAAEYAAABHAAAASAAAAEkAAABKAAAASwAA\
 179 AEwAAABNAAAATgAAAE8AAABQAAAAUQAAAFIAAABTAAAAVAAAAFUAAABWAAAAVwAAAFgAAABZAAAA\
 180 WgAAAFsAAABcAAAAXQAAAF4AAABfAAAAYAAAAGEAAABiAAAAYwAAAGQAAABlAAAAZgAAAGcAAABo\
 181 AAAAaQAAAGoAAABrAAAAbAAAAG0AAABuAAAAbwAAAHAAAABxAAAAcgAAAHMAAAB0AAAAdQAAAHYA\
 182 AAB3AAAAeAAAAHkAAAB6AAAAewAAAHwAAAB9AAAAfgAAAAAAAAA=";
 183
 184 RUNNER_TEST(String_ConverterFromASCII)
 185 {
 186     char* inStr = NULL;
 187     int inSize = wbxml_base64_decode(asciiEncodedIso1, &inStr);
 188     RUNNER_ASSERT(inSize > 0);
 189     RUNNER_ASSERT(NULL != inStr);
 190     inStr[inSize] = '\0';
 191     {
 192         DPL::String asciiString = DPL::FromASCIIString(inStr);
 193
 194         std::string result = DPL::ToUTF8String(asciiString);
 195
 196         RUNNER_ASSERT(strlen(inStr) == result.size());
 197
 198         RUNNER_ASSERT(0 == memcmp(inStr, result.c_str(), result.size()));
 199     }
 200
 201     free(inStr);
 202 }
 203
 204 RUNNER_TEST(String_ConverterFromUTF8)
 205 {
 206     char* inStr = NULL;
 207     int inSize = wbxml_base64_decode(asciiEncodedIso1, &inStr);
 208     RUNNER_ASSERT(inSize > 0);
 209     RUNNER_ASSERT(NULL != inStr);
 210     {
 211         DPL::String asciiString = DPL::FromUTF8String(inStr);
 212
 213         std::string result = DPL::ToUTF8String(asciiString);
 214
 215         RUNNER_ASSERT(strlen(inStr) == result.size());
 216
 217         RUNNER_ASSERT(0 == memcmp(inStr, result.c_str(), result.size()));
 218     }
 219
 220     free(inStr);
 221 }
 222
 223 RUNNER_TEST(String_ConverterFromUTF32)
 224 {
 225     wchar_t* inStr = NULL;
 226     int inSize =
 227         wbxml_base64_decode(utf32Encoded, reinterpret_cast<char**>(&inStr));
 228     RUNNER_ASSERT(inSize > 0);
 229     RUNNER_ASSERT(NULL != inStr);
 230     char* outStr = NULL;
 231     int outSize = wbxml_base64_decode(utf8Encoded, &outStr);
 232     RUNNER_ASSERT(outSize > 0);
 233     RUNNER_ASSERT(NULL != outStr);
 234     outStr[outSize] = '\0';
 235     {
 236         DPL::String utfString = DPL::FromUTF32String(inStr);
 237         std::string result = DPL::ToUTF8String(utfString);
 238
 239         RUNNER_ASSERT(strlen(outStr) == result.size());
 240         RUNNER_ASSERT(0 == memcmp(outStr, result.c_str(), result.size()));
 241
 242         RUNNER_ASSERT(inSize / sizeof(wchar_t) - 1 == utfString.size());
 243         RUNNER_ASSERT(0 ==
 244                       memcmp(inStr, &(utfString[0]), utfString.size() *
 245                              sizeof(wchar_t)));
 246     }
 247
 248     free(inStr);
 249 }
 250
 251 template<typename DelimiterType>
 252 void String_TokenizeReal(const DelimiterType& delimiter)
 253 {
 254     DPL::String str(L".##..abc.#.");
 255     std::vector<DPL::String> tokens;
 256     DPL::Tokenize(str, delimiter, std::back_inserter(tokens));
 257
 258     std::vector<DPL::String> expectedTokens;
 259     for (int i = 0; i < 5; i++) {
 260         expectedTokens.push_back(L"");
 261     }
 262     expectedTokens.push_back(L"abc");
 263     for (int i = 0; i < 3; i++) {
 264         expectedTokens.push_back(L"");
 265     }
 266
 267     RUNNER_ASSERT(expectedTokens == tokens);
 268     tokens.clear();
 269     expectedTokens.clear();
 270
 271     DPL::Tokenize(str, delimiter, std::back_inserter(tokens), true);
 272     expectedTokens.push_back(L"abc");
 273     RUNNER_ASSERT(expectedTokens == tokens);
 274 }
 275
 276 RUNNER_TEST(String_Tokenize)
 277 {
 278     String_TokenizeReal(L"#.");
 279     String_TokenizeReal(L".#");
 280     String_TokenizeReal(L".....####.###..");
 281     String_TokenizeReal(DPL::String(L".#"));
 282
 283     std::vector<std::string> tokens;
 284     DPL::Tokenize(std::string("abc.def"), '.', std::back_inserter(tokens));
 285     std::vector<std::string> expectedTokens;
 286     expectedTokens.push_back("abc");
 287     expectedTokens.push_back("def");
 288
 289     RUNNER_ASSERT(tokens == expectedTokens);
 290 }
 291
 292 template <typename TemplateArgumentCharTraits>
 293 void TestInStreams(
 294     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 295                       TemplateArgumentCharTraits> argumentInString,
 296     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 297                       TemplateArgumentCharTraits> argumentResultString)
 298 {
 299     typedef std::basic_string<typename TemplateArgumentCharTraits::char_type,
 300                               TemplateArgumentCharTraits>
 301     String;
 302     std::basic_istringstream<typename TemplateArgumentCharTraits::char_type,
 303                              TemplateArgumentCharTraits>
 304     istream(argumentInString);
 305     int intValue = 0;
 306     double doubleValue = 0.0;
 307     float floatValue = 0.0;
 308     String stringValue;
 309
 310     istream >> intValue;
 311     RUNNER_ASSERT(!istream.fail());
 312     istream >> doubleValue;
 313     RUNNER_ASSERT(!istream.fail());
 314     istream >> floatValue;
 315     RUNNER_ASSERT(!istream.fail());
 316     istream >> stringValue;
 317     RUNNER_ASSERT(!istream.fail());
 318
 319     RUNNER_ASSERT(1 == intValue);
 320     RUNNER_ASSERT(fabs(1.1f - doubleValue) < 0.00001);
 321     RUNNER_ASSERT(fabs(1.1f - floatValue) < 0.00001);
 322     RUNNER_ASSERT(argumentResultString == stringValue);
 323 }
 324
 325 template <typename TemplateArgumentCharTraits>
 326 void TestOutStreams(
 327     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 328                       TemplateArgumentCharTraits> argumentInString,
 329     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 330                       TemplateArgumentCharTraits> argumentResultString)
 331 {
 332     typedef std::basic_string<typename TemplateArgumentCharTraits::char_type,
 333                               TemplateArgumentCharTraits>
 334     String;
 335
 336     std::basic_ostringstream<typename TemplateArgumentCharTraits::char_type,
 337                              TemplateArgumentCharTraits>
 338     ostream;
 339
 340     int intValue = 1;
 341     double doubleValue = 1.1;
 342     float floatValue = 1.1f;
 343     String stringValue = argumentInString;
 344
 345     ostream << intValue;
 346     RUNNER_ASSERT(!ostream.fail());
 347     ostream << doubleValue;
 348     RUNNER_ASSERT(!ostream.fail());
 349     ostream << floatValue;
 350     RUNNER_ASSERT(!ostream.fail());
 351     ostream << stringValue;
 352     RUNNER_ASSERT(!ostream.fail());
 353
 354     RUNNER_ASSERT(ostream.str() == argumentResultString);
 355 }
 356
 357 RUNNER_TEST(String_Streams)
 358 {
 359     TestInStreams<std::char_traits<char> >("1 1.1 1.1 test", "test");
 360     TestInStreams<std::char_traits<wchar_t> >(L"1 1.1 1.1 test", L"test");
 361     TestInStreams<DPL::CharTraits>(L"1 1.1 1.1 test", L"test");
 362     TestOutStreams<std::char_traits<char> >("test", "11.11.1test");
 363     TestOutStreams<std::char_traits<wchar_t> >(L"test", L"11.11.1test");
 364     TestOutStreams<DPL::CharTraits>(L"test", L"11.11.1test");
 365 }
 366
 367 RUNNER_TEST(String_CompareCaseSensitive)
 368 {
 369     RUNNER_ASSERT(
 370         DPL::StringCompare(
 371             DPL::FromUTF32String(L"Ala Makota ma żołądkówkę"),
 372             DPL::FromUTF32String(L"Ala Makota ma żołądkówkę")) == 0);
 373 }
 374
 375 RUNNER_TEST(String_CompareCaseInsensitive)
 376 {
 377     RUNNER_ASSERT(
 378         DPL::StringCompare(
 379             DPL::FromUTF32String(L"Ala Makota ma żołądkówkę"),
 380             DPL::FromUTF32String(L"AlA MakOTA ma ŻoŁąDKÓwkę"),
 381             true) == 0);
 382 }
 383