开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llstring_test.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：26k
源码类别：

游戏引擎

开发平台：

C++ Builder

llstring_test.cpp：源码内容
  1. /** 
  2.  * @file llstring_test.cpp
  3.  * @author Adroit, Steve Linden, Tofu Linden
  4.  * @date 2006-12-24
  5.  * @brief Test cases of llstring.cpp
  6.  *
  7.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2007-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  35. #include "linden_common.h"
  36. #include "../test/lltut.h"
  38. #include "../llstring.h"
  40. namespace tut
  41. {
  42. struct string_index
  43. {
  44. };
  45. typedef test_group<string_index> string_index_t;
  46. typedef string_index_t::object string_index_object_t;
  47. tut::string_index_t tut_string_index("string_test");
  49. template<> template<>
  50. void string_index_object_t::test<1>()
  51. {
  52. std::string llstr1;
  53. ensure("Empty std::string", (llstr1.size() == 0) && llstr1.empty());
  55. std::string llstr2("Hello");
  56. ensure("std::string = Hello", (!strcmp(llstr2.c_str(), "Hello")) && (llstr2.size() == 5) && !llstr2.empty());
  58. std::string llstr3(llstr2);
  59. ensure("std::string = std::string(std::string)", (!strcmp(llstr3.c_str(), "Hello")) && (llstr3.size() == 5) && !llstr3.empty());
  61. std::string str("Hello World");
  62. std::string llstr4(str, 6);
  63. ensure("std::string = std::string(s, size_type pos, size_type n = npos)", (!strcmp(llstr4.c_str(), "World")) && (llstr4.size() == 5) && !llstr4.empty());
  65. std::string llstr5(str, str.size());
  66. ensure("std::string = std::string(s, size_type pos, size_type n = npos)", (llstr5.size() == 0) && llstr5.empty());
  68. std::string llstr6(5, 'A');
  69. ensure("std::string = std::string(count, c)", (!strcmp(llstr6.c_str(), "AAAAA")) && (llstr6.size() == 5) && !llstr6.empty());
  71. std::string llstr7("Hello World", 5);
  72. ensure("std::string(s, n)", (!strcmp(llstr7.c_str(), "Hello")) && (llstr7.size() == 5) && !llstr7.empty());
  74. std::string llstr8("Hello World", 6, 5);
  75. ensure("std::string(s, n, count)", (!strcmp(llstr8.c_str(), "World")) && (llstr8.size() == 5) && !llstr8.empty());
  77. std::string llstr9("Hello World", sizeof("Hello World")-1, 5); // go past end
  78. ensure("std::string(s, n, count) goes past end", (llstr9.size() == 0) && llstr9.empty());
  79. }
  81. template<> template<>
  82. void string_index_object_t::test<3>()
  83. {
  84. std::string str("Len=5");
  85. ensure("isValidIndex failed", LLStringUtil::isValidIndex(str, 0) == TRUE &&
  86.   LLStringUtil::isValidIndex(str, 5) == TRUE &&
  87.   LLStringUtil::isValidIndex(str, 6) == FALSE);
  89. std::string str1;
  90. ensure("isValidIndex failed fo rempty string", LLStringUtil::isValidIndex(str1, 0) == FALSE);
  91. }
  93. template<> template<>
  94. void string_index_object_t::test<4>()
  95. {
  96. std::string str_val("               Testing the extra whitespaces   ");
  97. LLStringUtil::trimHead(str_val);
  98. ensure_equals("1: trimHead failed", str_val, "Testing the extra whitespaces   ");
  100. std::string str_val1("ntrn  Testing the extra whitespaces   ");
  101. LLStringUtil::trimHead(str_val1);
  102. ensure_equals("2: trimHead failed", str_val1, "Testing the extra whitespaces   ");
  103. }
  105. template<> template<>
  106. void string_index_object_t::test<5>()
  107. {
  108. std::string str_val("  Testing the   extra     whitespaces         ");
  109. LLStringUtil::trimTail(str_val);
  110. ensure_equals("1: trimTail failed", str_val, "  Testing the   extra     whitespaces");
  112. std::string str_val1("n  Testing the extra whitespaces  ntrn   ");
  113. LLStringUtil::trimTail(str_val1);
  114. ensure_equals("2: trimTail failed", str_val1, "n  Testing the extra whitespaces");
  115. }
  118. template<> template<>
  119. void string_index_object_t::test<6>()
  120. {
  121. std::string str_val("  t r Testing the   extra     rn whitespaces     n t    ");
  122. LLStringUtil::trim(str_val);
  123. ensure_equals("1: trim failed", str_val, "Testing the   extra     rn whitespaces");
  124. }
  126. template<> template<>
  127. void string_index_object_t::test<7>()
  128. {
  129. std::string str("Second LindenLabs");
  130. LLStringUtil::truncate(str, 6);
  131. ensure_equals("1: truncate", str, "Second");
  133. // further truncate more than the length
  134. LLStringUtil::truncate(str, 0);
  135. ensure_equals("2: truncate", str, "");
  136. }
  138. template<> template<>
  139. void string_index_object_t::test<8>()
  140. {
  141. std::string str_val("SecondLife Source");
  142. LLStringUtil::toUpper(str_val);
  143. ensure_equals("toUpper failed", str_val, "SECONDLIFE SOURCE");
  144. }
  146. template<> template<>
  147. void string_index_object_t::test<9>()
  148. {
  149. std::string str_val("SecondLife Source");
  150. LLStringUtil::toLower(str_val);
  151. ensure_equals("toLower failed", str_val, "secondlife source");
  152. }
  154. template<> template<>
  155. void string_index_object_t::test<10>()
  156. {
  157. std::string str_val("Second");
  158. ensure("1. isHead failed", LLStringUtil::isHead(str_val, "SecondLife Source") == TRUE);
  159. ensure("2. isHead failed", LLStringUtil::isHead(str_val, " SecondLife Source") == FALSE);
  160. std::string str_val2("");
  161. ensure("3. isHead failed", LLStringUtil::isHead(str_val2, "") == FALSE);
  162. }
  164. template<> template<>
  165. void string_index_object_t::test<11>()
  166. {
  167. std::string str_val("Hello.nn Lindenlabs. n This is na simple test.n");
  168. std::string orig_str_val(str_val);
  169. LLStringUtil::addCRLF(str_val);
  170. ensure_equals("addCRLF failed", str_val, "Hello.rnrn Lindenlabs. rn This is rna simple test.rn");
  171. LLStringUtil::removeCRLF(str_val);
  172. ensure_equals("removeCRLF failed", str_val, orig_str_val);
  173. }
  175. template<> template<>
  176. void string_index_object_t::test<12>()
  177. {
  178. std::string str_val("Hello.nnt t Lindenlabs. tt");
  179. std::string orig_str_val(str_val);
  180. LLStringUtil::replaceTabsWithSpaces(str_val, 1);
  181. ensure_equals("replaceTabsWithSpaces failed", str_val, "Hello.nn    Lindenlabs.   ");
  182. LLStringUtil::replaceTabsWithSpaces(orig_str_val, 0);
  183. ensure_equals("replaceTabsWithSpaces failed for 0", orig_str_val, "Hello.nn  Lindenlabs. ");
  185. str_val = "tttt";
  186. LLStringUtil::replaceTabsWithSpaces(str_val, 0);
  187. ensure_equals("replaceTabsWithSpaces failed for all tabs", str_val, "");
  188. }
  190. template<> template<>
  191. void string_index_object_t::test<13>()
  192. {
  193. std::string str_val("Hello.nnttrnLindenlabsX.");
  194. LLStringUtil::replaceNonstandardASCII(str_val, 'X');
  195. ensure_equals("replaceNonstandardASCII failed", str_val, "Hello.nnXXXnLindenlabsX.");
  196. }
  198. template<> template<>
  199. void string_index_object_t::test<14>()
  200. {
  201. std::string str_val("Hello.ntrnABCDEFGHIABABAB");
  202. LLStringUtil::replaceChar(str_val, 'A', 'X');
  203. ensure_equals("1: replaceChar failed", str_val, "Hello.ntrnXBCDEFGHIXBXBXB");
  204. std::string str_val1("Hello.ntrnABCDEFGHIABABAB");
  205. }
  207. template<> template<>
  208. void string_index_object_t::test<15>()
  209. {
  210. std::string str_val("Hello.nrt");
  211. ensure("containsNonprintable failed", LLStringUtil::containsNonprintable(str_val) == TRUE);
  213. str_val = "ABC ";
  214. ensure("containsNonprintable failed", LLStringUtil::containsNonprintable(str_val) == FALSE);
  215. }
  217. template<> template<>
  218. void string_index_object_t::test<16>()
  219. {
  220. std::string str_val("Hello.nrt Again!");
  221. LLStringUtil::stripNonprintable(str_val);
  222. ensure_equals("stripNonprintable failed", str_val, "Hello. Again!");
  224. str_val = "rntt";
  225. LLStringUtil::stripNonprintable(str_val);
  226. ensure_equals("stripNonprintable resulting in empty string failed", str_val, "");
  228. str_val = "";
  229. LLStringUtil::stripNonprintable(str_val);
  230. ensure_equals("stripNonprintable of empty string resulting in empty string failed", str_val, "");
  231. }
  233. template<> template<>
  234. void string_index_object_t::test<17>()
  235. {
  236. BOOL value;
  237. std::string str_val("1");
  238. ensure("convertToBOOL 1 failed", LLStringUtil::convertToBOOL(str_val, value) && value);
  239. str_val = "T";
  240. ensure("convertToBOOL T failed", LLStringUtil::convertToBOOL(str_val, value) && value);
  241. str_val = "t";
  242. ensure("convertToBOOL t failed", LLStringUtil::convertToBOOL(str_val, value) && value);
  243. str_val = "TRUE";
  244. ensure("convertToBOOL TRUE failed", LLStringUtil::convertToBOOL(str_val, value) && value);
  245. str_val = "True";
  246. ensure("convertToBOOL True failed", LLStringUtil::convertToBOOL(str_val, value) && value);
  247. str_val = "true";
  248. ensure("convertToBOOL true failed", LLStringUtil::convertToBOOL(str_val, value) && value);
  250. str_val = "0";
  251. ensure("convertToBOOL 0 failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
  252. str_val = "F";
  253. ensure("convertToBOOL F failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
  254. str_val = "f";
  255. ensure("convertToBOOL f failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
  256. str_val = "FALSE";
  257. ensure("convertToBOOL FASLE failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
  258. str_val = "False";
  259. ensure("convertToBOOL False failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
  260. str_val = "false";
  261. ensure("convertToBOOL false failed", LLStringUtil::convertToBOOL(str_val, value) && !value);
  263. str_val = "Tblah";
  264. ensure("convertToBOOL false failed", !LLStringUtil::convertToBOOL(str_val, value));
  265. }
  267. template<> template<>
  268. void string_index_object_t::test<18>()
  269. {
  270. U8 value;
  271. std::string str_val("255");
  272. ensure("1: convertToU8 failed", LLStringUtil::convertToU8(str_val, value) && value == 255);
  274. str_val = "0";
  275. ensure("2: convertToU8 failed", LLStringUtil::convertToU8(str_val, value) && value == 0);
  277. str_val = "-1";
  278. ensure("3: convertToU8 failed", !LLStringUtil::convertToU8(str_val, value));
  280. str_val = "256"; // bigger than MAX_U8
  281. ensure("4: convertToU8 failed", !LLStringUtil::convertToU8(str_val, value));
  282. }
  284. template<> template<>
  285. void string_index_object_t::test<19>()
  286. {
  287. S8 value;
  288. std::string str_val("127");
  289. ensure("1: convertToS8 failed", LLStringUtil::convertToS8(str_val, value) && value == 127);
  291. str_val = "0";
  292. ensure("2: convertToS8 failed", LLStringUtil::convertToS8(str_val, value) && value == 0);
  294. str_val = "-128";
  295. ensure("3: convertToS8 failed", LLStringUtil::convertToS8(str_val, value) && value == -128);
  297. str_val = "128"; // bigger than MAX_S8
  298. ensure("4: convertToS8 failed", !LLStringUtil::convertToS8(str_val, value));
  300. str_val = "-129"; 
  301. ensure("5: convertToS8 failed", !LLStringUtil::convertToS8(str_val, value));
  302. }
  304. template<> template<>
  305. void string_index_object_t::test<20>()
  306. {
  307. S16 value;
  308. std::string str_val("32767"); 
  309. ensure("1: convertToS16 failed", LLStringUtil::convertToS16(str_val, value) && value == 32767);
  311. str_val = "0";
  312. ensure("2: convertToS16 failed", LLStringUtil::convertToS16(str_val, value) && value == 0);
  314. str_val = "-32768";
  315. ensure("3: convertToS16 failed", LLStringUtil::convertToS16(str_val, value) && value == -32768);
  317. str_val = "32768"; 
  318. ensure("4: convertToS16 failed", !LLStringUtil::convertToS16(str_val, value));
  320. str_val = "-32769";
  321. ensure("5: convertToS16 failed", !LLStringUtil::convertToS16(str_val, value));
  322. }
  324. template<> template<>
  325. void string_index_object_t::test<21>()
  326. {
  327. U16 value;
  328. std::string str_val("65535"); //0xFFFF
  329. ensure("1: convertToU16 failed", LLStringUtil::convertToU16(str_val, value) && value == 65535);
  331. str_val = "0";
  332. ensure("2: convertToU16 failed", LLStringUtil::convertToU16(str_val, value) && value == 0);
  334. str_val = "-1"; 
  335. ensure("3: convertToU16 failed", !LLStringUtil::convertToU16(str_val, value));
  337. str_val = "65536"; 
  338. ensure("4: convertToU16 failed", !LLStringUtil::convertToU16(str_val, value));
  339. }
  341. template<> template<>
  342. void string_index_object_t::test<22>()
  343. {
  344. U32 value;
  345. std::string str_val("4294967295"); //0xFFFFFFFF
  346. ensure("1: convertToU32 failed", LLStringUtil::convertToU32(str_val, value) && value == 4294967295UL);
  348. str_val = "0";
  349. ensure("2: convertToU32 failed", LLStringUtil::convertToU32(str_val, value) && value == 0);
  351. str_val = "4294967296"; 
  352. ensure("3: convertToU32 failed", !LLStringUtil::convertToU32(str_val, value));
  353. }
  355. template<> template<>
  356. void string_index_object_t::test<23>()
  357. {
  358. S32 value;
  359. std::string str_val("2147483647"); //0x7FFFFFFF
  360. ensure("1: convertToS32 failed", LLStringUtil::convertToS32(str_val, value) && value == 2147483647);
  362. str_val = "0";
  363. ensure("2: convertToS32 failed", LLStringUtil::convertToS32(str_val, value) && value == 0);
  365. // Avoid "unary minus operator applied to unsigned type" warning on VC++. JC
  366. S32 min_val = -2147483647 - 1;
  367. str_val = "-2147483648"; 
  368. ensure("3: convertToS32 failed", LLStringUtil::convertToS32(str_val, value)  && value == min_val);
  370. str_val = "2147483648"; 
  371. ensure("4: convertToS32 failed", !LLStringUtil::convertToS32(str_val, value));
  373. str_val = "-2147483649"; 
  374. ensure("5: convertToS32 failed", !LLStringUtil::convertToS32(str_val, value));
  375. }
  377. template<> template<>
  378. void string_index_object_t::test<24>()
  379. {
  380. F32 value;
  381. std::string str_val("2147483647"); //0x7FFFFFFF
  382. ensure("1: convertToF32 failed", LLStringUtil::convertToF32(str_val, value) && value == 2147483647);
  384. str_val = "0";
  385. ensure("2: convertToF32 failed", LLStringUtil::convertToF32(str_val, value) && value == 0);
  387. /* Need to find max/min F32 values
  388. str_val = "-2147483648"; 
  389. ensure("3: convertToF32 failed", LLStringUtil::convertToF32(str_val, value)  && value == -2147483648);
  391. str_val = "2147483648"; 
  392. ensure("4: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
  394. str_val = "-2147483649"; 
  395. ensure("5: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
  396. */
  397. }
  399. template<> template<>
  400. void string_index_object_t::test<25>()
  401. {
  402. F64 value;
  403. std::string str_val("9223372036854775807"); //0x7FFFFFFFFFFFFFFF
  404. ensure("1: convertToF64 failed", LLStringUtil::convertToF64(str_val, value) && value == 9223372036854775807LL);
  406. str_val = "0";
  407. ensure("2: convertToF64 failed", LLStringUtil::convertToF64(str_val, value) && value == 0.0F);
  409. /* Need to find max/min F64 values
  410. str_val = "-2147483648"; 
  411. ensure("3: convertToF32 failed", LLStringUtil::convertToF32(str_val, value)  && value == -2147483648);
  413. str_val = "2147483648"; 
  414. ensure("4: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
  416. str_val = "-2147483649"; 
  417. ensure("5: convertToF32 failed", !LLStringUtil::convertToF32(str_val, value));
  418. */
  419. }
  421. template<> template<>
  422. void string_index_object_t::test<26>()
  423. {
  424. const char* str1 = NULL;
  425. const char* str2 = NULL;
  427. ensure("1: compareStrings failed", LLStringUtil::compareStrings(str1, str2) == 0);
  428. str2 = "A";
  429. ensure("2: compareStrings failed", LLStringUtil::compareStrings(str1, str2) > 0);
  430. ensure("3: compareStrings failed", LLStringUtil::compareStrings(str2, str1) < 0);
  432. str1 = "A is smaller than B";
  433. str2 = "B is greater than A";
  434. ensure("4: compareStrings failed", LLStringUtil::compareStrings(str1, str2) < 0);
  436. str2 = "A is smaller than B";
  437. ensure("5: compareStrings failed", LLStringUtil::compareStrings(str1, str2) == 0);
  438. }
  440. template<> template<>
  441. void string_index_object_t::test<27>()
  442. {
  443. const char* str1 = NULL;
  444. const char* str2 = NULL;
  446. ensure("1: compareInsensitive failed", LLStringUtil::compareInsensitive(str1, str2) == 0);
  447. str2 = "A";
  448. ensure("2: compareInsensitive failed", LLStringUtil::compareInsensitive(str1, str2) > 0);
  449. ensure("3: compareInsensitive failed", LLStringUtil::compareInsensitive(str2, str1) < 0);
  451. str1 = "A is equal to a";
  452. str2 = "a is EQUAL to A";
  453. ensure("4: compareInsensitive failed", LLStringUtil::compareInsensitive(str1, str2) == 0);
  454. }
  456. template<> template<>
  457. void string_index_object_t::test<28>()
  458. {
  459. std::string lhs_str("PROgraM12files");
  460. std::string rhs_str("PROgram12Files");
  461. ensure("compareDict 1 failed", LLStringUtil::compareDict(lhs_str, rhs_str) < 0);
  462. ensure("precedesDict 1 failed", LLStringUtil::precedesDict(lhs_str, rhs_str) == TRUE);
  464. lhs_str = "PROgram12Files";
  465. rhs_str = "PROgram12Files";
  466. ensure("compareDict 2 failed", LLStringUtil::compareDict(lhs_str, rhs_str) == 0);
  467. ensure("precedesDict 2 failed", LLStringUtil::precedesDict(lhs_str, rhs_str) == FALSE);
  469. lhs_str = "PROgram12Files";
  470. rhs_str = "PROgRAM12FILES";
  471. ensure("compareDict 3 failed", LLStringUtil::compareDict(lhs_str, rhs_str) > 0);
  472. ensure("precedesDict 3 failed", LLStringUtil::precedesDict(lhs_str, rhs_str) == FALSE);
  473. }
  475. template<> template<>
  476. void string_index_object_t::test<29>()
  477. {
  478. char str1[] = "First String...";
  479. char str2[100];
  481. LLStringUtil::copy(str2, str1, 100);
  482. ensure("LLStringUtil::copy with enough dest length failed", strcmp(str2, str1) == 0);
  483. LLStringUtil::copy(str2, str1, sizeof("First"));
  484. ensure("LLStringUtil::copy with less dest length failed", strcmp(str2, "First") == 0);
  485. }
  487. template<> template<>
  488. void string_index_object_t::test<30>()
  489. {
  490. std::string str1 = "This is the sentence...";
  491. std::string str2 = "This is the ";
  492. std::string str3 = "first ";
  493. std::string str4 = "This is the first sentence...";
  494. std::string str5 = "This is the sentence...first ";
  495. std::string dest;
  497. dest = str1;
  498. LLStringUtil::copyInto(dest, str3, str2.length());
  499. ensure("LLStringUtil::copyInto insert failed", dest == str4);
  501. dest = str1;
  502. LLStringUtil::copyInto(dest, str3, dest.length());
  503. ensure("LLStringUtil::copyInto append failed", dest == str5);
  504. }
  506. template<> template<>
  507. void string_index_object_t::test<31>()
  508. {
  509. std::string stripped;
  511. // Plain US ASCII text, including spaces and punctuation,
  512. // should not be altered.
  513. std::string simple_text = "Hello, world!";
  514. stripped = LLStringFn::strip_invalid_xml(simple_text);
  515. ensure("Simple text passed unchanged", stripped == simple_text);
  517. // Control characters should be removed
  518. // except for 0x09, 0x0a, 0x0d
  519. std::string control_chars;
  520. for (char c = 0x01; c < 0x20; c++)
  521. {
  522. control_chars.push_back(c);
  523. }
  524. std::string allowed_control_chars;
  525. allowed_control_chars.push_back( (char)0x09 );
  526. allowed_control_chars.push_back( (char)0x0a );
  527. allowed_control_chars.push_back( (char)0x0d );
  529. stripped = LLStringFn::strip_invalid_xml(control_chars);
  530. ensure("Only tab, LF, CR control characters allowed",
  531. stripped == allowed_control_chars);
  533. // UTF-8 should be passed intact, including high byte
  534. // characters.  Try Francais (with C squiggle cedilla)
  535. std::string french = "Fran";
  536. french.push_back( (char)0xC3 );
  537. french.push_back( (char)0xA7 );
  538. french += "ais";
  539. stripped = LLStringFn::strip_invalid_xml( french );
  540. ensure("UTF-8 high byte text is allowed", french == stripped );
  541. }
  543. template<> template<>
  544. void string_index_object_t::test<32>()
  545. {
  546. // Test LLStringUtil::format() string interpolation
  547. LLStringUtil::format_map_t fmt_map;
  548. std::string s;
  549. int subcount;
  551. fmt_map["[TRICK1]"] = "[A]";
  552. fmt_map["[A]"] = "a";
  553. fmt_map["[B]"] = "b";
  554. fmt_map["[AAA]"] = "aaa";
  555. fmt_map["[BBB]"] = "bbb";
  556. fmt_map["[TRICK2]"] = "[A]";
  557. fmt_map["[EXPLOIT]"] = "!!!!!!!!!!!![EXPLOIT]!!!!!!!!!!!!";
  558. fmt_map["[KEYLONGER]"] = "short";
  559. fmt_map["[KEYSHORTER]"] = "Am I not a long string?";
  560. fmt_map["?"] = "?";
  561. fmt_map["[DELETE]"] = "";
  562. fmt_map["[]"] = "[]"; // doesn't do a substitution, but shouldn't crash either
  564. for (LLStringUtil::format_map_t::const_iterator iter = fmt_map.begin(); iter != fmt_map.end(); ++iter)
  565. {
  566. // Test when source string is entirely one key
  567. std::string s1 = (std::string)iter->first;
  568. std::string s2 = (std::string)iter->second;
  569. subcount = LLStringUtil::format(s1, fmt_map);
  570. ensure_equals("LLStringUtil::format: Raw interpolation result", s1, s2);
  571. if (s1 == "?" || s1 == "[]") // no interp expected
  572. {
  573. ensure_equals("LLStringUtil::format: Raw interpolation result count", 0, subcount);
  574. }
  575. else
  576. {
  577. ensure_equals("LLStringUtil::format: Raw interpolation result count", 1, subcount);
  578. }
  579. }
  581. for (LLStringUtil::format_map_t::const_iterator iter = fmt_map.begin(); iter != fmt_map.end(); ++iter)
  582. {
  583. // Test when source string is one key, duplicated
  584. std::string s1 = (std::string)iter->first;
  585. std::string s2 = (std::string)iter->second;
  586. s = s1 + s1 + s1 + s1;
  587. subcount = LLStringUtil::format(s, fmt_map);
  588. ensure_equals("LLStringUtil::format: Rawx4 interpolation result", s, s2 + s2 + s2 + s2);
  589. if (s1 == "?" || s1 == "[]") // no interp expected
  590. {
  591. ensure_equals("LLStringUtil::format: Rawx4 interpolation result count", 0, subcount);
  592. }
  593. else
  594. {
  595. ensure_equals("LLStringUtil::format: Rawx4 interpolation result count", 4, subcount);
  596. }
  597. }
  599. // Test when source string has no keys
  600. std::string srcs = "!!!!!!!!!!!!!!!!";
  601. s = srcs;
  602. subcount = LLStringUtil::format(s, fmt_map);
  603. ensure_equals("LLStringUtil::format: No key test result", s, srcs);
  604. ensure_equals("LLStringUtil::format: No key test result count", 0, subcount);
  606. // Test when source string has no keys and is empty
  607. std::string srcs3;
  608. s = srcs3;
  609. subcount = LLStringUtil::format(s, fmt_map);
  610. ensure("LLStringUtil::format: No key test3 result", s.empty());
  611. ensure_equals("LLStringUtil::format: No key test3 result count", 0, subcount);
  613. // Test a substitution where a key is substituted with blankness
  614. std::string srcs2 = "[DELETE]";
  615. s = srcs2;
  616. subcount = LLStringUtil::format(s, fmt_map);
  617. ensure("LLStringUtil::format: Delete key test2 result", s.empty());
  618. ensure_equals("LLStringUtil::format: Delete key test2 result count", 1, subcount);
  620. // Test an assorted substitution
  621. std::string srcs4 = "[TRICK1][A][B][AAA][BBB][TRICK2][KEYLONGER][KEYSHORTER]?[DELETE]";
  622. s = srcs4;
  623. subcount = LLStringUtil::format(s, fmt_map);
  624. ensure_equals("LLStringUtil::format: Assorted Test1 result", s, "[A]abaaabbb[A]shortAm I not a long string??");
  625. ensure_equals("LLStringUtil::format: Assorted Test1 result count", 9, subcount);
  627. // Test an assorted substitution
  628. std::string srcs5 = "[DELETE]?[KEYSHORTER][KEYLONGER][TRICK2][BBB][AAA][B][A][TRICK1]";
  629. s = srcs5;
  630. subcount = LLStringUtil::format(s, fmt_map);
  631. ensure_equals("LLStringUtil::format: Assorted Test2 result", s, "?Am I not a long string?short[A]bbbaaaba[A]");
  632. ensure_equals("LLStringUtil::format: Assorted Test2 result count", 9, subcount);
  634. // Test an assorted substitution
  635. std::string srcs8 = "foo[DELETE]bar?";
  636. s = srcs8;
  637. subcount = LLStringUtil::format(s, fmt_map);
  638. ensure_equals("LLStringUtil::format: Assorted Test3 result", s, "foobar?");
  639. ensure_equals("LLStringUtil::format: Assorted Test3 result count", 1, subcount);
  640. }
  642. template<> template<>
  643. void string_index_object_t::test<33>()
  644. {
  645. // Test LLStringUtil::format() string interpolation
  646. LLStringUtil::format_map_t blank_fmt_map;
  647. std::string s;
  648. int subcount;
  650. // Test substituting out of a blank format_map
  651. std::string srcs6 = "12345";
  652. s = srcs6;
  653. subcount = LLStringUtil::format(s, blank_fmt_map);
  654. ensure_equals("LLStringUtil::format: Blankfmt Test1 result", s, "12345");
  655. ensure_equals("LLStringUtil::format: Blankfmt Test1 result count", 0, subcount);
  657. // Test substituting a blank string out of a blank format_map
  658. std::string srcs7;
  659. s = srcs7;
  660. subcount = LLStringUtil::format(s, blank_fmt_map);
  661. ensure("LLStringUtil::format: Blankfmt Test2 result", s.empty());
  662. ensure_equals("LLStringUtil::format: Blankfmt Test2 result count", 0, subcount);
  663. }
  665. template<> template<>
  666. void string_index_object_t::test<34>()
  667. {
  668. // Test that incorrect LLStringUtil::format() use does not explode.
  669. LLStringUtil::format_map_t nasty_fmt_map;
  670. std::string s;
  671. int subcount;
  673. nasty_fmt_map[""] = "never used"; // see, this is nasty.
  675. // Test substituting out of a nasty format_map
  676. std::string srcs6 = "12345";
  677. s = srcs6;
  678. subcount = LLStringUtil::format(s, nasty_fmt_map);
  679. ensure_equals("LLStringUtil::format: Nastyfmt Test1 result", s, "12345");
  680. ensure_equals("LLStringUtil::format: Nastyfmt Test1 result count", 0, subcount);
  682. // Test substituting a blank string out of a nasty format_map
  683. std::string srcs7;
  684. s = srcs7;
  685. subcount = LLStringUtil::format(s, nasty_fmt_map);
  686. ensure("LLStringUtil::format: Nastyfmt Test2 result", s.empty());
  687. ensure_equals("LLStringUtil::format: Nastyfmt Test2 result count", 0, subcount);
  688. }
  690. template<> template<>
  691. void string_index_object_t::test<35>()
  692. {
  693. // Make sure startsWith works
  694. std::string string("anybody in there?");
  695. std::string substr("anybody");
  696. ensure("startsWith works.", LLStringUtil::startsWith(string, substr));
  697. }
  699. template<> template<>
  700. void string_index_object_t::test<36>()
  701. {
  702. // Make sure startsWith correctly fails
  703. std::string string("anybody in there?");
  704. std::string substr("there");
  705. ensure("startsWith fails.", !LLStringUtil::startsWith(string, substr));
  706. }
  708. template<> template<>
  709. void string_index_object_t::test<37>()
  710. {
  711. // startsWith fails on empty strings
  712. std::string value("anybody in there?");
  713. std::string empty;
  714. ensure("empty string.", !LLStringUtil::startsWith(value, empty));
  715. ensure("empty substr.", !LLStringUtil::startsWith(empty, value));
  716. ensure("empty everything.", !LLStringUtil::startsWith(empty, empty));
  717. }
  719. template<> template<>
  720. void string_index_object_t::test<38>()
  721. {
  722. // Make sure endsWith works correctly
  723. std::string string("anybody in there?");
  724. std::string substr("there?");
  725. ensure("endsWith works.", LLStringUtil::endsWith(string, substr));
  726. }
  728. template<> template<>
  729. void string_index_object_t::test<39>()
  730. {
  731. // Make sure endsWith correctly fails
  732. std::string string("anybody in there?");
  733. std::string substr("anybody");
  734. ensure("endsWith fails.", !LLStringUtil::endsWith(string, substr));
  735. substr = "there";
  736. ensure("endsWith fails.", !LLStringUtil::endsWith(string, substr));
  737. substr = "ther?";
  738. ensure("endsWith fails.", !LLStringUtil::endsWith(string, substr));
  739. }
  741. template<> template<>
  742. void string_index_object_t::test<40>()
  743. {
  744. // endsWith fails on empty strings
  745. std::string value("anybody in there?");
  746. std::string empty;
  747. ensure("empty string.", !LLStringUtil::endsWith(value, empty));
  748. ensure("empty substr.", !LLStringUtil::endsWith(empty, value));
  749. ensure("empty everything.", !LLStringUtil::endsWith(empty, empty));
  750. }
  751. }