tests/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 <string>
  27 #include <dpl/test/test_runner.h>
  28 #include <dpl/string.h>
  29 #include <dpl/sstream.h>
  30
  31 RUNNER_TEST_GROUP_INIT(DPL)
  32
  33 unsigned char GetBaseCode(int index);
  34 unsigned char GetBaseCode(int index)
  35 {
  36     /* aaaack but it's fast and const should make it shared text page. */
  37     static const unsigned char pr2six[256] = {
  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 /* Function adapted from APR library (http://apr.apache.org/) */
  60 int wbxml_base64_decode(const char *buffer, char **result);
  61 int wbxml_base64_decode(const char *buffer, char **result)
  62 {
  63     int nbytesdecoded = 0, nprbytes = 0;
  64     const char *bufin = NULL;
  65     char *bufout = NULL;
  66
  67     if ((buffer == NULL) || (result == NULL)) {
  68         return 0;
  69     }
  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     }
  84     memset(*result, 0, nbytesdecoded + 1);
  85
  86     bufout = *result;
  87     bufin = buffer;
  88
  89     while (nprbytes > 4) {
  90         *(bufout++) =
  91             (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
  92         *(bufout++) =
  93             (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
  94         *(bufout++) = (char)(GetBaseCode(bufin[2]) << 6 | GetBaseCode(bufin[3]));
  95         bufin += 4;
  96         nprbytes -= 4;
  97     }
  98
  99     /* Note: (nprbytes == 1) would be an error, so just ingore that case */
 100     if (nprbytes > 1) {
 101         *(bufout++) =
 102             (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
 103     }
 104     if (nprbytes > 2) {
 105         *(bufout++) =
 106             (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
 107     }
 108     if (nprbytes > 3) {
 109         *(bufout++) = (char)(GetBaseCode(bufin[2]) << 6 | GetBaseCode(bufin[3]));
 110     }
 111
 112     nbytesdecoded -= (4 - nprbytes) & 3;
 113
 114     return nbytesdecoded;
 115 }
 116
 117 //#define TEST_CONVERSION(in_string, out_string, buffer_type, function
 118
 119 const char utf32Encoded[] =
 120     "RDAAAI0wAABvMAAAazAAAHswAAB4MAAAaDAAAAAwAABhMAAAijAAAGwwAACLMAAAkjAAAAAwAACP\
 121 MAAASzAAAIgwAABfMAAAjDAAAF0wAAAAMAAAZDAAAG0wAABqMAAAiTAAAIAwAAAAMAAARjAAAJAw\
 122 AABuMAAASjAAAE8wAACEMAAAfjAAAAAwAABRMAAAdTAAAFMwAABIMAAAZjAAAAAwAABCMAAAVTAA\
 123 AE0wAACGMAAAgTAAAH8wAABXMAAAADAAAJEwAAByMAAAgjAAAFswAABZMAAACgAAANsFAADaBQAA\
 124 IAAAANQFAADqBQAA6AUAAOEFAADnBQAAIAAAAOAFAADkBQAA5QUAACAAAADiBQAA3AUAACAAAADS\
 125 BQAA1QUAANYFAADcBQAAIAAAAOcFAADYBQAA3wUAACwAAAAgAAAA6QUAANMFAADXBQAA4wUAACAA\
 126 AADQBQAA6gUAACAAAADmBQAA0QUAANkFAAAgAAAA3AUAAN4FAADZBQAA3QUAAAoAAACk0AAApMIA\
 127 AFjHAAAgAAAA4KwAACDHAABwyAAAdKwAAEDHAAAgAAAAhccAACDCAAB8sAAArLkAACAAAADMuQAA\
 128 mLAAAHzFAAAgAAAAWNUAAOCsAAAgAAAAudIAAMS8AABc1QAAIAAAADCuAAAgwgAAQMcAACAAAABE\
 129 1QAAlMYAAFjOAAAgAAAASsUAAOSyAAAKAAAAUAAAAGMAAABoAAAAbgAAAAUBAAAHAQAAIAAAAHcA\
 130 AAAgAAAAdAAAABkBAAAgAAAAQgEAAPMAAABkAAAAegEAACAAAABqAAAAZQAAAHwBAABhAAAAIAAA\
 131 AGwAAAB1AAAAYgAAACAAAABvAAAAWwEAAG0AAAAgAAAAcwAAAGsAAAByAAAAegAAAHkAAABEAQAA\
 132 IAAAAGYAAABpAAAAZwAAAC4AAAAKAAAAQgAAAGwAAABvAAAAdwAAAHoAAAB5AAAAIAAAAG4AAABp\
 133 AAAAZwAAAGgAAAB0AAAALQAAAGYAAAByAAAAdQAAAG0AAABwAAAAcwAAACAAAAB2AAAAZQAAAHgA\
 134 AAAnAAAAZAAAACAAAABKAAAAYQAAAGMAAABrAAAAIAAAAFEAAAAuAAAACgAAAEYGAAA1BgAAIAAA\
 135 AC0GAABDBgAASgYAAEUGAAAgAAAARAYAAEcGAAAgAAAAMwYAADEGAAAgAAAAQgYAACcGAAA3BgAA\
 136 OQYAACAAAABIBgAAMAYAAEgGAAAgAAAANAYAACMGAABGBgAAIAAAADkGAAA4BgAASgYAAEUGAAAg\
 137 AAAARQYAAEMGAAAqBgAASAYAACgGAAAgAAAAOQYAAEQGAABJBgAAIAAAACsGAABIBgAAKAYAACAA\
 138 AAAjBgAALgYAADYGAAAxBgAAIAAAAEgGAABFBgAAOgYAAEQGAABBBgAAIAAAACgGAAAsBgAARAYA\
 139 AC8GAAAgAAAAIwYAADIGAAAxBgAAQgYAACAAAAAKAAAAEgQAACAAAABHBAAAMAQAAEkEAAAwBAAA\
 140 RQQAACAAAABOBAAAMwQAADAEAAAgAAAANgQAADgEAAA7BAAAIAAAADEEAABLBAAAIAAAAEYEAAA4\
 141 BAAAQgQAAEAEAABDBAAAQQQAAD8AAAAgAAAAFAQAADAEAAAsAAAAIAAAAD0EAAA+BAAAIAAAAEQE\
 142 AAAwBAAAOwQAAEwEAABIBAAAOAQAADIEAABLBAAAOQQAACAAAABNBAAAOgQAADcEAAA1BAAAPAQA\
 143 AD8EAAA7BAAATwQAAEAEAAAhAAAACgAAAKQDAACsAwAAxwMAALkDAADDAwAAxAMAALcDAAAgAAAA\
 144 sQMAALsDAADOAwAAwAMAALcDAAC+AwAAIAAAALIDAACxAwAAxgMAAK4DAADCAwAAIAAAAMgDAAC3\
 145 AwAAvAMAAK0DAAC9AwAAtwMAACAAAACzAwAAtwMAACwAAAAgAAAAtAMAAMEDAACxAwAAwwMAALoD\
 146 AAC1AwAAuwMAAK8DAAC2AwAAtQMAALkDAAAgAAAAxQMAAMADAACtAwAAwQMAACAAAAC9AwAAyQMA\
 147 ALgDAADBAwAAvwMAAM0DAAAgAAAAugMAAMUDAAC9AwAAzAMAAMIDAAAKAAAAVgAAAGkAAABjAAAA\
 148 dAAAAG8AAAByAAAAIAAAAGoAAABhAAAAZwAAAHQAAAAgAAAAegAAAHcAAAD2AAAAbAAAAGYAAAAg\
 149 AAAAQgAAAG8AAAB4AAAAawAAAOQAAABtAAAAcAAAAGYAAABlAAAAcgAAACAAAABxAAAAdQAAAGUA\
 150 AAByAAAAIAAAAPwAAABiAAAAZQAAAHIAAAAgAAAAZAAAAGUAAABuAAAAIAAAAGcAAAByAAAAbwAA\
 151 AN8AAABlAAAAbgAAACAAAABTAAAAeQAAAGwAAAB0AAAAZQAAAHIAAAAgAAAARAAAAGUAAABpAAAA\
 152 YwAAAGgAAAAKAAAAlokAAM6RAAAhcQAAUJYAAONeAAAM/wAAl3oAABZZAAAJZwAAzYUAAClZAAAK\
 153 AAAACgAAAAAAAAA=";
 154
 155 const char utf8Encoded[] =
 156     "44GE44KN44Gv44Gr44G744G444Go44CA44Gh44KK44Gs44KL44KS44CA44KP44GL44KI44Gf44KM\
 157 44Gd44CA44Gk44Gt44Gq44KJ44KA44CA44GG44KQ44Gu44GK44GP44KE44G+44CA44GR44G144GT\
 158 44GI44Gm44CA44GC44GV44GN44KG44KB44G/44GX44CA44KR44Gy44KC44Gb44GZCteb15og15TX\
 159 qteo16HXpyDXoNek16Ug16LXnCDXkteV15bXnCDXp9eY158sINep15PXl9ejINeQ16og16bXkdeZ\
 160 INec157XmdedCu2CpOyKpOydmCDqs6DsnKDsobDqsbTsnYAg7J6F7Iig64G866asIOunjOuCmOyV\
 161 vCDtlZjqs6Ag7Yq567OE7ZWcIOq4sOyIoOydgCDtlYTsmpTsuZgg7JWK64ukClBjaG7EhcSHIHcg\
 162 dMSZIMWCw7NkxbogamXFvGEgbHViIG/Fm20gc2tyennFhCBmaWcuCkJsb3d6eSBuaWdodC1mcnVt\
 163 cHMgdmV4J2QgSmFjayBRLgrZhti1INit2YPZitmFINmE2Ycg2LPYsSDZgtin2LfYuSDZiNiw2Ygg\
 164 2LTYo9mGINi52LjZitmFINmF2YPYqtmI2Kgg2LnZhNmJINir2YjYqCDYo9iu2LbYsSDZiNmF2LrZ\
 165 hNmBINio2KzZhNivINij2LLYsdmCIArQkiDRh9Cw0YnQsNGFINGO0LPQsCDQttC40Lsg0LHRiyDR\
 166 htC40YLRgNGD0YE/INCU0LAsINC90L4g0YTQsNC70YzRiNC40LLRi9C5INGN0LrQt9C10LzQv9C7\
 167 0Y/RgCEKzqTOrM+HzrnPg8+EzrcgzrHOu8+Oz4DOt86+IM6yzrHPhs6uz4Igz4jOt868zq3Ovc63\
 168 IM6zzrcsIM60z4HOsc+DzrrOtc67zq/Ots61zrkgz4XPgM6tz4Egzr3Pic64z4HOv8+NIM66z4XO\
 169 vc+Mz4IKVmljdG9yIGphZ3QgenfDtmxmIEJveGvDpG1wZmVyIHF1ZXIgw7xiZXIgZGVuIGdyb8Of\
 170 ZW4gU3lsdGVyIERlaWNoCuimlumHjueEoemZkOW7o++8jOeql+WkluacieiXjeWkqQoKAA==";
 171
 172 const char asciiEncodedIso1[] =
 173     "ISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZ\
 174 WltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fgA=";
 175
 176 const char asciiEncodedUtf32[] =
 177     "IQAAACIAAAAjAAAAJAAAACUAAAAmAAAAJwAAACgAAAApAAAAKgAAACsAAAAsAAAALQAAAC4AAAAv\
 178 AAAAMAAAADEAAAAyAAAAMwAAADQAAAA1AAAANgAAADcAAAA4AAAAOQAAADoAAAA7AAAAPAAAAD0A\
 179 AAA+AAAAPwAAAEAAAABBAAAAQgAAAEMAAABEAAAARQAAAEYAAABHAAAASAAAAEkAAABKAAAASwAA\
 180 AEwAAABNAAAATgAAAE8AAABQAAAAUQAAAFIAAABTAAAAVAAAAFUAAABWAAAAVwAAAFgAAABZAAAA\
 181 WgAAAFsAAABcAAAAXQAAAF4AAABfAAAAYAAAAGEAAABiAAAAYwAAAGQAAABlAAAAZgAAAGcAAABo\
 182 AAAAaQAAAGoAAABrAAAAbAAAAG0AAABuAAAAbwAAAHAAAABxAAAAcgAAAHMAAAB0AAAAdQAAAHYA\
 183 AAB3AAAAeAAAAHkAAAB6AAAAewAAAHwAAAB9AAAAfgAAAAAAAAA=";
 184
 185 /*
 186 Name: String_ConverterFromASCII
 187 Description: tests construction of string from ascii data
 188 Expected: data stored in buffer should match expected
 189 */
 190 RUNNER_TEST(String_ConverterFromASCII)
 191 {
 192     char* inStr = NULL;
 193     int inSize = wbxml_base64_decode(asciiEncodedIso1, &inStr);
 194     RUNNER_ASSERT(inSize > 0);
 195     RUNNER_ASSERT(NULL != inStr);
 196     inStr[inSize] = '\0';
 197     {
 198         DPL::String asciiString = DPL::FromASCIIString(inStr);
 199
 200         std::string result = DPL::ToUTF8String(asciiString);
 201
 202         RUNNER_ASSERT(strlen(inStr) == result.size());
 203
 204         RUNNER_ASSERT(0 == memcmp(inStr, result.c_str(), result.size()));
 205     }
 206
 207     free(inStr);
 208 }
 209
 210 /*
 211 Name: String_ConverterFromUTF8
 212 Description: tests construction of string from UTF-8 data
 213 Expected: data stored in buffer should match expected
 214 */
 215 RUNNER_TEST(String_ConverterFromUTF8)
 216 {
 217     char* inStr = NULL;
 218     int inSize = wbxml_base64_decode(asciiEncodedIso1, &inStr);
 219     RUNNER_ASSERT(inSize > 0);
 220     RUNNER_ASSERT(NULL != inStr);
 221     {
 222         DPL::String asciiString = DPL::FromUTF8String(inStr);
 223
 224         std::string result = DPL::ToUTF8String(asciiString);
 225
 226         RUNNER_ASSERT(strlen(inStr) == result.size());
 227
 228         RUNNER_ASSERT(0 == memcmp(inStr, result.c_str(), result.size()));
 229     }
 230
 231     free(inStr);
 232 }
 233
 234 /*
 235 Name: String_ConverterFromUTF32
 236 Description: tests construction of string from UTF-32 data
 237 Expected: data stored in buffer should match expected
 238 */
 239 RUNNER_TEST(String_ConverterFromUTF32)
 240 {
 241     wchar_t* inStr = NULL;
 242     int inSize =
 243         wbxml_base64_decode(utf32Encoded, reinterpret_cast<char**>(&inStr));
 244     RUNNER_ASSERT(inSize > 0);
 245     RUNNER_ASSERT(NULL != inStr);
 246     char* outStr = NULL;
 247     int outSize = wbxml_base64_decode(utf8Encoded, &outStr);
 248     RUNNER_ASSERT(outSize > 0);
 249     RUNNER_ASSERT(NULL != outStr);
 250     outStr[outSize] = '\0';
 251     {
 252         DPL::String utfString = DPL::FromUTF32String(inStr);
 253         std::string result = DPL::ToUTF8String(utfString);
 254
 255         RUNNER_ASSERT(strlen(outStr) == result.size());
 256         RUNNER_ASSERT(0 == memcmp(outStr, result.c_str(), result.size()));
 257
 258         RUNNER_ASSERT(inSize / sizeof(wchar_t) - 1 == utfString.size());
 259         RUNNER_ASSERT(0 ==
 260                       memcmp(inStr, &(utfString[0]), utfString.size() *
 261                              sizeof(wchar_t)));
 262     }
 263
 264     free(inStr);
 265 }
 266
 267 template<typename DelimiterType>
 268 void String_TokenizeReal(const DelimiterType& delimiter)
 269 {
 270     DPL::String str(L".##..abc.#.");
 271     std::vector<DPL::String> tokens;
 272     DPL::Tokenize(str, delimiter, std::back_inserter(tokens));
 273
 274     std::vector<DPL::String> expectedTokens;
 275     for (int i = 0; i < 5; i++) {
 276         expectedTokens.push_back(L"");
 277     }
 278     expectedTokens.push_back(L"abc");
 279     for (int i = 0; i < 3; i++) {
 280         expectedTokens.push_back(L"");
 281     }
 282
 283     RUNNER_ASSERT(expectedTokens == tokens);
 284     tokens.clear();
 285     expectedTokens.clear();
 286
 287     DPL::Tokenize(str, delimiter, std::back_inserter(tokens), true);
 288     expectedTokens.push_back(L"abc");
 289     RUNNER_ASSERT(expectedTokens == tokens);
 290 }
 291
 292 /*
 293 Name: String_Tokenize
 294 Description: tests of string splitting
 295 Expected: returned substring should match expected values
 296 */
 297 RUNNER_TEST(String_Tokenize)
 298 {
 299     String_TokenizeReal(L"#.");
 300     String_TokenizeReal(L".#");
 301     String_TokenizeReal(L".....####.###..");
 302     String_TokenizeReal(DPL::String(L".#"));
 303
 304     std::vector<std::string> tokens;
 305     DPL::Tokenize(std::string("abc.def"), '.', std::back_inserter(tokens));
 306     std::vector<std::string> expectedTokens;
 307     expectedTokens.push_back("abc");
 308     expectedTokens.push_back("def");
 309
 310     RUNNER_ASSERT(tokens == expectedTokens);
 311 }
 312
 313 template <typename TemplateArgumentCharTraits>
 314 void TestInStreams(
 315     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 316                       TemplateArgumentCharTraits> argumentInString,
 317     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 318                       TemplateArgumentCharTraits> argumentResultString)
 319 {
 320     typedef std::basic_string<typename TemplateArgumentCharTraits::char_type,
 321                               TemplateArgumentCharTraits>
 322     String;
 323     std::basic_istringstream<typename TemplateArgumentCharTraits::char_type,
 324                              TemplateArgumentCharTraits>
 325     istream(argumentInString);
 326     int intValue = 0;
 327     double doubleValue = 0.0;
 328     float floatValue = 0.0;
 329     String stringValue;
 330
 331     istream >> intValue;
 332     RUNNER_ASSERT(!istream.fail());
 333     istream >> doubleValue;
 334     RUNNER_ASSERT(!istream.fail());
 335     istream >> floatValue;
 336     RUNNER_ASSERT(!istream.fail());
 337     istream >> stringValue;
 338     RUNNER_ASSERT(!istream.fail());
 339
 340     RUNNER_ASSERT(1 == intValue);
 341     RUNNER_ASSERT(fabs(1.1f - doubleValue) < 0.00001);
 342     RUNNER_ASSERT(fabs(1.1f - floatValue) < 0.00001);
 343     RUNNER_ASSERT(argumentResultString == stringValue);
 344 }
 345
 346 template <typename TemplateArgumentCharTraits>
 347 void TestOutStreams(
 348     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 349                       TemplateArgumentCharTraits> argumentInString,
 350     std::basic_string<typename TemplateArgumentCharTraits::char_type,
 351                       TemplateArgumentCharTraits> argumentResultString)
 352 {
 353     typedef std::basic_string<typename TemplateArgumentCharTraits::char_type,
 354                               TemplateArgumentCharTraits>
 355     String;
 356
 357     std::basic_ostringstream<typename TemplateArgumentCharTraits::char_type,
 358                              TemplateArgumentCharTraits>
 359     ostream;
 360
 361     int intValue = 1;
 362     double doubleValue = 1.1;
 363     float floatValue = 1.1f;
 364     String stringValue = argumentInString;
 365
 366     ostream << intValue;
 367     RUNNER_ASSERT(!ostream.fail());
 368     ostream << doubleValue;
 369     RUNNER_ASSERT(!ostream.fail());
 370     ostream << floatValue;
 371     RUNNER_ASSERT(!ostream.fail());
 372     ostream << stringValue;
 373     RUNNER_ASSERT(!ostream.fail());
 374
 375     RUNNER_ASSERT(ostream.str() == argumentResultString);
 376 }
 377
 378 /*
 379 Name: String_Streams
 380 Description: tests of input/output stream
 381 Expected: returned substrign should match expected values
 382 */
 383 RUNNER_TEST(String_Streams)
 384 {
 385     TestInStreams<std::char_traits<char> >("1 1.1 1.1 test", "test");
 386     TestInStreams<std::char_traits<wchar_t> >(L"1 1.1 1.1 test", L"test");
 387     TestInStreams<DPL::CharTraits>(L"1 1.1 1.1 test", L"test");
 388     TestOutStreams<std::char_traits<char> >("test", "11.11.1test");
 389     TestOutStreams<std::char_traits<wchar_t> >(L"test", L"11.11.1test");
 390     TestOutStreams<DPL::CharTraits>(L"test", L"11.11.1test");
 391 }
 392
 393 /*
 394 Name: String_CompareCaseSensitive
 395 Description: tests case sensitive comparision
 396 Expected: strings should be equal
 397 */
 398 RUNNER_TEST(String_CompareCaseSensitive)
 399 {
 400     RUNNER_ASSERT(
 401         DPL::StringCompare(
 402             DPL::FromUTF32String(L"Ala Makota ma żołądkówkę"),
 403             DPL::FromUTF32String(L"Ala Makota ma żołądkówkę")) == 0);
 404 }
 405
 406 /*
 407 Name: String_CompareCaseInsensitive
 408 Description: tests case insensitive comparision
 409 Expected: strings should be equal
 410 */
 411 RUNNER_TEST(String_CompareCaseInsensitive)
 412 {
 413     RUNNER_ASSERT(
 414         DPL::StringCompare(
 415             DPL::FromUTF32String(L"Ala Makota ma żołądkówkę"),
 416             DPL::FromUTF32String(L"AlA MakOTA ma ŻoŁąDKÓwkę"),
 417             true) == 0);
 418 }
 419
 420 /*
 421 Name: String_Join
 422 Description: tests joining strings algorithm
 423 Expected: join should take place correctly
 424 */
 425 RUNNER_TEST(String_Join)
 426 {
 427     std::vector<std::string> strings;
 428     RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "/") == "");
 429     strings.push_back("one");
 430     RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "/") == "one");
 431     strings.push_back("two");
 432     RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "/") == "one/two");
 433     strings.push_back("three");
 434     RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "/") == "one/two/three");
 435     strings.push_back("four");
 436     RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "/") == "one/two/three/four");
 437     RUNNER_ASSERT(DPL::Join(++strings.begin(), --strings.end(), "/") == "two/three");
 438
 439     RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "+") == "one+two+three+four");
 440     RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "delim") == "onedelimtwodelimthreedelimfour");
 441 }
 442