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

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

游戏引擎

开发平台：

C++ Builder

llstreamtools_tut.cpp：源码内容
  1. /**
  2.  * @file llstreamtools_tut.cpp
  3.  * @author Adroit
  4.  * @date February 2007
  5.  * @brief llstreamtools test cases.
  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.  */
  34.  
  35. #include <tut/tut.hpp>
  37. #include "linden_common.h"
  38. #include "llstreamtools.h"
  39. #include "lltut.h"
  42. namespace tut
  43. {
  44. struct streamtools_data
  45. {
  46. };
  47. typedef test_group<streamtools_data> streamtools_test;
  48. typedef streamtools_test::object streamtools_object;
  49. tut::streamtools_test streamtools_testcase("streamtools");
  51. //test cases for skip_whitespace()
  52. template<> template<>
  53. void streamtools_object::test<1>()
  54. {
  55. char arr[255];
  56. std::string str;
  57. std::string expected_result;
  58. std::string actual_result;
  59. std::istringstream is;
  61. is.str(str = "");
  62. ensure("skip_whitespace: empty string", (false == skip_whitespace(is)));
  64. is.clear();
  65. is.str(str = " SecondLife is a 3D World");
  66. skip_whitespace(is);
  67. is.get(arr, 255, '');
  68. expected_result = "SecondLife is a 3D World";
  69. ensure_equals("skip_whitespace: space", arr, expected_result);
  71. is.clear();
  72. is.str(str = "t          tSecondLife is a 3D World");
  73. skip_whitespace(is);
  74. is.get(arr, 255, '');
  75. expected_result = "SecondLife is a 3D World";
  76. ensure_equals("skip_whitespace: space and tabs", arr, expected_result);
  78. is.clear();
  79. is.str(str = "t          tSecondLife is a 3D World       ");
  80. skip_whitespace(is);
  81. is.get(arr, 255, '');
  82. expected_result = "SecondLife is a 3D World       ";
  83. ensure_equals("skip_whitespace: space at end", arr, expected_result);
  85. is.clear();
  86. is.str(str = "t rnSecondLife is a 3D World");
  87. skip_whitespace(is);
  88. is.get(arr, 255, '');
  89. expected_result = "rnSecondLife is a 3D World";
  90. ensure_equals("skip_whitespace: space at end", arr, expected_result);
  91. }
  93. //testcases for skip_emptyspaces()
  94. template<> template<>
  95. void streamtools_object::test<2>()
  96. {
  97. char arr[255];
  98. std::string str;
  99. std::string expected_result;
  100. std::string actual_result;
  101. std::istringstream is;
  102. bool ret;
  104. is.clear();
  105. is.str(str = "  tSecondLife is a 3D World.n");
  106. skip_emptyspace(is);
  107. is.get(arr, 255, '');
  108. expected_result = "SecondLife is a 3D World.n";
  109. ensure_equals("skip_emptyspace: space and tabs", arr, expected_result);
  111. is.clear();
  112. is.str(str = "  trn    r    SecondLife is a 3D World.n");
  113. skip_emptyspace(is);
  114. is.get(arr, 255, '');
  115. expected_result = "SecondLife is a 3D World.n";
  116. ensure_equals("skip_emptyspace: space, tabs, carriage return, newline", arr, expected_result);
  118. is.clear();
  119. is.str(str = "");
  120. ret = skip_emptyspace(is);
  121. is.get(arr, 255, '');
  122. ensure("skip_emptyspace: empty string", ret == false);
  124. is.clear();
  125. is.str(str = "  rn  t ");
  126. ret = skip_emptyspace(is);
  127. is.get(arr, 255, '');
  128. ensure("skip_emptyspace: space newline empty", ret == false);
  129. }
  131. //testcases for skip_comments_and_emptyspace()
  132. template<> template<>
  133. void streamtools_object::test<3>()
  134. {
  135. char arr[255];
  136. std::string str;
  137. std::string expected_result;
  138. std::string actual_result;
  139. std::istringstream is;
  140. bool ret;
  142. is.clear();
  143. is.str(str = "  trn    r    SecondLife is a 3D World.n");
  144. skip_comments_and_emptyspace(is);
  145. is.get(arr, 255, '');
  146. expected_result = "SecondLife is a 3D World.n";
  147. ensure_equals("skip_comments_and_emptyspace: space, tabs, carriage return, newline", arr, expected_result);
  149. is.clear();
  150. is.str(str = "#    rn    SecondLife is a 3D World.");
  151. skip_comments_and_emptyspace(is);
  152. is.get(arr, 255, '');
  153. expected_result = "SecondLife is a 3D World.";
  154. ensure_equals("skip_comments_and_emptyspace: skip comment - 1", arr, expected_result);
  156. is.clear();
  157. is.str(str = "#    rn  #  SecondLife is a 3D World. ##");
  158. skip_comments_and_emptyspace(is);
  159. is.get(arr, 255, '');
  160. expected_result = "";
  161. ensure_equals("skip_comments_and_emptyspace: skip comment - 2", arr, expected_result);
  163. is.clear();
  164. is.str(str = " rn  SecondLife is a 3D World. ##");
  165. skip_comments_and_emptyspace(is);
  166. is.get(arr, 255, '');
  167. expected_result = "SecondLife is a 3D World. ##";
  168. ensure_equals("skip_comments_and_emptyspace: skip comment - 3", arr, expected_result);
  170. is.clear();
  171. is.str(str = "");
  172. ret = skip_comments_and_emptyspace(is);
  173. is.get(arr, 255, '');
  174. ensure("skip_comments_and_emptyspace: empty string", ret == false);
  176. is.clear();
  177. is.str(str = "  rn  t # SecondLife is a 3D World");
  178. ret = skip_comments_and_emptyspace(is);
  179. is.get(arr, 255, '');
  180. ensure("skip_comments_and_emptyspace: space newline comment empty", ret == false);
  181. }
  183. //testcases for skip_line()
  184. template<> template<>
  185. void streamtools_object::test<4>()
  186. {
  187. char arr[255];
  188. std::string str;
  189. std::string expected_result;
  190. std::string actual_result;
  191. std::istringstream is;
  192. bool ret;
  194. is.clear();
  195. is.str(str = "SecondLife is a 3D World.nn It provides an opportunity to the site nuser to perform real life activities in virtual world.");
  196. skip_line(is);
  197. is.get(arr, 255, '');
  198. expected_result = "n It provides an opportunity to the site nuser to perform real life activities in virtual world.";
  199. ensure_equals("skip_line: 1 newline", arr, expected_result);
  201. is.clear();
  202. is.str(expected_result);
  203. skip_line(is);
  204. is.get(arr, 255, '');
  205. expected_result = " It provides an opportunity to the site nuser to perform real life activities in virtual world.";
  206. ensure_equals("skip_line: 2 newline", arr, expected_result);
  208. is.clear();
  209. is.str(expected_result);
  210. skip_line(is);
  211. is.get(arr, 255, '');
  212. expected_result = "user to perform real life activities in virtual world.";
  213. ensure_equals("skip_line: 3 newline", arr, expected_result);
  215. is.clear();
  216. is.str(str = "");
  217. ret = skip_line(is);
  218. ensure("skip_line: empty string", ret == false);
  219. }
  222. // testcases for skip_to_next_word()
  223. template<> template<>
  224. void streamtools_object::test<5>()
  225. {
  226. char arr[255];
  227. std::string str;
  228. std::string expected_result;
  229. std::string actual_result;
  230. std::istringstream is;
  231. bool ret;
  233. is.clear();
  234. is.str(str = "SecondLife is a 3D_World.nn It-provides an opportunity to the site nuser to perform real life activities in virtual world.");
  235. skip_to_next_word(is); // get past SecondLife
  236. is.get(arr, 255, '');
  237. expected_result = "is a 3D_World.nn It-provides an opportunity to the site nuser to perform real life activities in virtual world.";
  238. ensure_equals("skip_to_next_word: 1", arr, expected_result);
  240. is.clear();
  241. is.str(expected_result);
  242. skip_to_next_word(is); // get past is
  243. skip_to_next_word(is); // get past a
  244. skip_to_next_word(is); // get past 3D_World.nn 
  245. is.get(arr, 255, '');
  246. expected_result = "It-provides an opportunity to the site nuser to perform real life activities in virtual world.";
  247. ensure_equals("skip_to_next_word: get past .nn 2", arr, expected_result);
  249. is.clear();
  250. is.str(expected_result);
  251. skip_to_next_word(is); // get past It- 
  252. expected_result = "provides an opportunity to the site nuser to perform real life activities in virtual world.";
  253. is.get(arr, 255, '');
  254. ensure_equals("skip_to_next_word: get past -", arr, expected_result);
  256. is.clear();
  257. is.str(str = "");
  258. ret = skip_to_next_word(is);
  259. ensure("skip_line: empty string", ret == false);
  261. is.clear();
  262. is.str(str = "                   rnrn");
  263. ret = skip_to_next_word(is);
  264. ensure("skip_line: space new lines", ret == false);
  265. }
  268. //testcases for skip_to_end_of_next_keyword()
  269. template<> template<>
  270. void streamtools_object::test<6>()
  271. {
  272. char arr[255];
  273. std::string str;
  274. std::string expected_result;
  275. std::string actual_result;
  276. std::istringstream is;
  277. bool ret;
  279. is.clear();
  280. is.str(str = "FIRSTKEY followed by second delimiternSECONDKEYt SecondValue followed by third delimiter   nSECONDKEYnFOURTHKEY FOURTHVALUEis a 3DWorld.");
  281. ret = skip_to_end_of_next_keyword("FIRSTKEY", is); 
  282. is.get(arr, 255, '');
  283. expected_result = " followed by second delimiternSECONDKEYt SecondValue followed by third delimiter   nSECONDKEYnFOURTHKEY FOURTHVALUEis a 3DWorld.";
  284. ensure_equals("skip_to_end_of_next_keyword: 1", arr, expected_result);
  286. is.clear();
  287. is.str(expected_result);
  288. ret = skip_to_end_of_next_keyword("SECONDKEY", is); 
  289. is.get(arr, 255, '');
  290. expected_result = "t SecondValue followed by third delimiter   nSECONDKEYnFOURTHKEY FOURTHVALUEis a 3DWorld.";
  291. ensure_equals("skip_to_end_of_next_keyword: 2", arr, expected_result);
  293. is.clear();
  294. is.str(expected_result);
  295. ret = skip_to_end_of_next_keyword("SECONDKEY", is); 
  296. is.get(arr, 255, '');
  297. expected_result = "nFOURTHKEY FOURTHVALUEis a 3DWorld.";
  298. ensure_equals("skip_to_end_of_next_keyword: 3", arr, expected_result);
  300. is.clear();
  301. is.str(expected_result);
  302. ret = skip_to_end_of_next_keyword("FOURTHKEY", is); 
  303. is.get(arr, 255, '');
  304. expected_result = " FOURTHVALUEis a 3DWorld.";
  305. ensure_equals("skip_to_end_of_next_keyword: 4", arr, expected_result);
  307. is.clear();
  308. is.str(str = "{should be skipped as newline/space/tab does not follow but this one should be pickedn { Does it?n");
  309. ret = skip_to_end_of_next_keyword("{", is); 
  310. is.get(arr, 255, '');
  311. expected_result = " Does it?n";
  312. ensure_equals("skip_to_end_of_next_keyword: multiple delim matches on same line", arr, expected_result);
  314. is.clear();
  315. is.str(str = "Delim { could not be found at start");
  316. ret = skip_to_end_of_next_keyword("{", is); 
  317. ensure("skip_to_end_of_next_keyword: delim should not be present", ret == false);
  319. is.clear();
  320. is.str(str = "Empty Delim");
  321. ret = skip_to_end_of_next_keyword("", is); 
  322. ensure("skip_to_end_of_next_keyword: empty delim should not be valid", ret == false);
  324. is.clear();
  325. is.str(str = "");
  326. ret = skip_to_end_of_next_keyword("}", is); 
  327. ensure("skip_to_end_of_next_keyword: empty string", ret == false);
  328. }
  330. //testcases for get_word(std::string& output_string, std::istream& input_stream)
  331. template<> template<>
  332. void streamtools_object::test<7>()
  333. {
  334. std::string str;
  335. std::string expected_result;
  336. std::string actual_result;
  337. std::istringstream is;
  338. bool ret;
  340. is.clear();
  341. is.str(str = "  First Second t r  n Third  Fourth-ShouldThisBePartOfFourth  Fifthn");
  342. actual_result = "";
  343. ret = get_word(actual_result, is); 
  344. expected_result = "First";
  345. ensure_equals("get_word: 1", actual_result, expected_result);
  347. actual_result = "";
  348. ret = get_word(actual_result, is); 
  349. expected_result = "Second";
  350. ensure_equals("get_word: 2", actual_result, expected_result);
  352. actual_result = "";
  353. ret = get_word(actual_result, is); 
  354. expected_result = "Third";
  355. ensure_equals("get_word: 3", actual_result, expected_result);
  357. // the current implementation of get_word seems inconsistent with
  358. // skip_to_next_word. skip_to_next_word treats any character other
  359. // than alhpa-numeric and '_' as a delimter, while get_word()
  360. // treats only isspace() (i.e. space,  form-feed('f'),  newline  ('n'),  
  361. // carriage  return ('r'), horizontal tab ('t'), and vertical tab ('v')
  362. // as delimiters 
  363. actual_result = "";
  364. ret = get_word(actual_result, is); // will copy Fourth-ShouldThisBePartOfFourth
  365. expected_result = "Fourth-ShouldThisBePartOfFourth"; // as per current impl.
  366. ensure_equals("get_word: 4", actual_result, expected_result);
  368. actual_result = "";
  369. ret = get_word(actual_result, is); // will copy Fifth
  370. expected_result = "Fifth"; // as per current impl.
  371. ensure_equals("get_word: 5", actual_result, expected_result);
  373. is.clear();
  374. is.str(str = "  t r  n ");
  375. actual_result = "";
  376. ret = get_word(actual_result, is); 
  377. ensure("get_word: empty all spaces, newline tabs", ret == false);
  379. is.clear();
  380. is.str(str = "");
  381. actual_result = "";
  382. ret = get_word(actual_result, is); 
  383. ensure("get_word: empty string", ret == false);
  384. }
  386. // testcase for get_word and skip_to_next_word compatibility
  387. template<> template<>
  388. void streamtools_object::test<8>()
  389. {
  390. std::string str;
  391. std::string expected_result;
  392. std::string actual_result;
  393. std::istringstream is;
  394. bool ret;
  396. is.clear();
  397. is.str(str = "  First Second t r  n Third  Fourth-ShouldThisBePartOfFourth  Fifthn");
  398. actual_result = "";
  399. ret = get_word(actual_result, is); // First
  400. actual_result = "";
  401. ret = get_word(actual_result, is); // Second
  402. actual_result = "";
  403. ret = get_word(actual_result, is); // Third
  405. // the current implementation of get_word seems inconsistent with
  406. // skip_to_next_word. skip_to_next_word treats any character other
  407. // than alhpa-numeric and '_' as a delimter, while get_word()
  408. // treats only isspace() (i.e. space,  form-feed('f'),  newline  ('n'),  
  409. // carriage  return ('r'), horizontal tab ('t'), and vertical tab ('v')
  410. // as delimiters 
  411. actual_result = "";
  412. ret = get_word(actual_result, is); // will copy Fourth-ShouldThisBePartOfFourth
  414. actual_result = "";
  415. ret = get_word(actual_result, is); // will copy Fifth
  417. is.clear();
  418. is.str(str = "  First Second t r  n Third  Fourth_ShouldThisBePartOfFourth Fifthn");
  419. ret = skip_to_next_word(is);  // should now point to First
  420. ret = skip_to_next_word(is);  // should now point to Second
  421. ret = skip_to_next_word(is);  // should now point to Third
  422. ret = skip_to_next_word(is);  // should now point to Fourth
  423. ret = skip_to_next_word(is);  // should now point to ShouldThisBePartOfFourth
  424. expected_result = "";
  425. // will copy ShouldThisBePartOfFourth, the fifth word, 
  426. // while using get_word above five times result in getting "Fifth"
  427. ret = get_word(expected_result, is); 
  428. ensure_equals("get_word: skip_to_next_word compatibility", actual_result, expected_result);
  429. }
  431. //testcases for get_word(std::string& output_string, std::istream& input_stream, int n)
  432. template<> template<>
  433. void streamtools_object::test<9>()
  434. {
  435. std::string str;
  436. std::string expected_result;
  437. std::string actual_result;
  438. std::istringstream is;
  439. bool ret;
  441. is.clear();
  442. is.str(str = "  First Second t r  n Third  Fourth-ShouldThisBePartOfFourth  Fifthn");
  443. actual_result = "";
  444. ret = get_word(actual_result, is, 255);
  445. expected_result = "First";
  446. ensure_equals("get_word: 1", actual_result, expected_result);
  448. actual_result = "";
  449. ret = get_word(actual_result, is, 4); 
  450. expected_result = "Seco"; // should be cut short
  451. ensure_equals("get_word: 2", actual_result, expected_result);
  453. actual_result = "";
  454. ret = get_word(actual_result, is, 255); 
  455. expected_result = "nd"; // get remainder of Second
  456. ensure_equals("get_word: 3", actual_result, expected_result);
  458. actual_result = "";
  459. ret = get_word(actual_result, is, 0); // 0 size string 
  460. expected_result = ""; // get remainder of Second
  461. ensure_equals("get_word: 0 sized output", actual_result, expected_result);
  463. actual_result = "";
  464. ret = get_word(actual_result, is, 255); 
  465. expected_result = "Third"; 
  466. ensure_equals("get_word: 4", actual_result, expected_result);
  468. is.clear();
  469. is.str(str = "  t r  n ");
  470. actual_result = "";
  471. ret = get_word(actual_result, is, 255); 
  472. ensure("get_word: empty all spaces, newline tabs", ret == false);
  474. is.clear();
  475. is.str(str = "");
  476. actual_result = "";
  477. ret = get_word(actual_result, is, 255); 
  478. ensure("get_word: empty string", ret == false);
  479. }
  481. //test cases for get_line(std::string& output_string, std::istream& input_stream)
  482. template<> template<>
  483. void streamtools_object::test<10>()
  484. {
  485. std::string str;
  486. std::string expected_result;
  487. std::string actual_result;
  488. std::istringstream is;
  489. bool ret;
  491. is.clear();
  492. is.str(str = "First Second t rn Third  Fourth-ShouldThisBePartOfFourth  IsThisFifthn");
  493. actual_result = "";
  494. ret = get_line(actual_result, is);
  495. expected_result = "First Second t rn";
  496. ensure_equals("get_line: 1", actual_result, expected_result);
  498. actual_result = "";
  499. ret = get_line(actual_result, is);
  500. expected_result = " Third  Fourth-ShouldThisBePartOfFourth  IsThisFifthn";
  501. ensure_equals("get_line: 2", actual_result, expected_result);
  503. is.clear();
  504. is.str(str = "nFirst Line.nnSecond Line.n");
  505. actual_result = "";
  506. ret = get_line(actual_result, is);
  507. expected_result = "n";
  508. ensure_equals("get_line: First char as newline", actual_result, expected_result);
  510. actual_result = "";
  511. ret = get_line(actual_result, is);
  512. expected_result = "First Line.n";
  513. ensure_equals("get_line: 3", actual_result, expected_result);
  515. actual_result = "";
  516. ret = get_line(actual_result, is);
  517. expected_result = "n";
  518. ensure_equals("get_line: 4", actual_result, expected_result);
  520. actual_result = "";
  521. ret = get_line(actual_result, is);
  522. expected_result = "Second Line.n";
  523. ensure_equals("get_line: 5", actual_result, expected_result);
  524. }
  526. //test cases for get_line(std::string& output_string, std::istream& input_stream)
  527. template<> template<>
  528. void streamtools_object::test<11>()
  529. {
  530. std::string str;
  531. std::string expected_result;
  532. std::string actual_result;
  533. std::istringstream is;
  534. bool ret;
  536. is.clear();
  537. is.str(str = "One Line only with no newline");
  538. actual_result = "";
  539. ret = get_line(actual_result, is);
  540. expected_result = "One Line only with no newline";
  541. ensure_equals("get_line: No newline", actual_result, expected_result);
  542. ensure_equals("return value is good state of stream", ret, is.good());
  543. }
  545. //test cases for get_line(std::string& output_string, std::istream& input_stream)
  546. template<> template<>
  547. void streamtools_object::test<12>()
  548. {
  549. std::string str;
  550. std::string expected_result;
  551. std::string actual_result;
  552. std::istringstream is;
  553. bool ret;
  555. // need to be check if this test case is wrong or the implementation is wrong.
  556. is.clear();
  557. is.str(str = "Should not skip lone r.rn");
  558. actual_result = "";
  559. ret = get_line(actual_result, is);
  560. expected_result = "Should not skip lone r.rn";
  561. ensure_equals("get_line: carriage return skipped even though not followed by newline", actual_result, expected_result);
  562. }
  564. //test cases for get_line(std::string& output_string, std::istream& input_stream)
  565. template<> template<>
  566. void streamtools_object::test<13>()
  567. {
  568. std::string str;
  569. std::string expected_result;
  570. std::string actual_result;
  571. std::istringstream is;
  572. bool ret;
  574. is.clear();
  575. is.str(str = "n");
  576. actual_result = "";
  577. ret = get_line(actual_result, is);
  578. expected_result = "n";
  579. ensure_equals("get_line: Just newline", actual_result, expected_result);
  580. }
  583. //testcases for get_line(std::string& output_string, std::istream& input_stream, int n)
  584. template<> template<>
  585. void streamtools_object::test<14>()
  586. {
  587. std::string str;
  588. std::string expected_result;
  589. std::string actual_result;
  590. std::istringstream is;
  591. bool ret;
  593. is.clear();
  594. is.str(str = "First Line.nSecond Line.n");
  595. actual_result = "";
  596. ret = get_line(actual_result, is, 255);
  597. expected_result = "First Line.n";
  598. ensure_equals("get_line: Basic Operation", actual_result, expected_result);
  600. actual_result = "";
  601. ret = get_line(actual_result, is, sizeof("Second")-1);
  602. expected_result = "Secondn";
  603. ensure_equals("get_line: Insufficient length 1", actual_result, expected_result);
  605. actual_result = "";
  606. ret = get_line(actual_result, is, 255);
  607. expected_result = " Line.n";
  608. ensure_equals("get_line: Remainder after earlier insufficient length", actual_result, expected_result);
  610. is.clear();
  611. is.str(str = "One Line only with no newline with limited length");
  612. actual_result = "";
  613. ret = get_line(actual_result, is, sizeof("One Line only with no newline with limited length")-1);
  614. expected_result = "One Line only with no newline with limited lengthn";
  615. ensure_equals("get_line: No newline with limited length", actual_result, expected_result);
  617. is.clear();
  618. is.str(str = "One Line only with no newline");
  619. actual_result = "";
  620. ret = get_line(actual_result, is, 255);
  621. expected_result = "One Line only with no newline";
  622. ensure_equals("get_line: No newline", actual_result, expected_result);
  623. }
  625. //testcases for get_line(std::string& output_string, std::istream& input_stream, int n)
  626. template<> template<>
  627. void streamtools_object::test<15>()
  628. {
  629. std::string str;
  630. std::string expected_result;
  631. std::string actual_result;
  632. std::istringstream is;
  633. bool ret;
  635. is.clear();
  636. is.str(str = "One Line only with no newline");
  637. actual_result = "";
  638. ret = get_line(actual_result, is, 255);
  639. expected_result = "One Line only with no newline";
  640. ensure_equals("get_line: No newline", actual_result, expected_result);
  641. ensure_equals("return value is good state of stream", ret, is.good());
  642. }
  644. //testcases for remove_last_char()
  645. template<> template<>
  646. void streamtools_object::test<16>()
  647. {
  648. std::string str;
  649. std::string expected_result;
  650. bool ret;
  652. str = "SecondLife is a 3D World";
  654. ret = remove_last_char('d',str);
  655. expected_result = "SecondLife is a 3D Worl";
  656. ensure_equals("remove_last_char: should remove last char", str, expected_result);
  658. str = "SecondLife is a 3D World";
  659. ret = remove_last_char('W',str);
  660. expected_result = "SecondLife is a 3D World";
  661. ensure_equals("remove_last_char: should not remove as it is not last char", str, expected_result);
  662. ensure("remove_last_char: should return false", ret == false);
  664. str = "SecondLife is a 3D Worldn";
  665. ret = remove_last_char('n',str);
  666. expected_result = "SecondLife is a 3D World";
  667. ensure_equals("remove_last_char: should remove last newline", str, expected_result);
  668. ensure("remove_last_char: should remove newline and return true", ret == true);
  669. }
  672. //testcases for unescaped_string()
  673. template<> template<>
  674. void streamtools_object::test<17>()
  675. {
  676. std::string str;
  677. std::string expected_result;
  679. str = "SecondLife is a 3D world \n";
  680. unescape_string(str);
  681. expected_result = "SecondLife is a 3D world n";
  682. ensure_equals("unescape_string: newline", str, expected_result);
  684. str = "SecondLife is a 3D world \\t \n";
  685. unescape_string(str);
  686. expected_result = "SecondLife is a 3D world \t n";
  687. ensure_equals("unescape_string: backslash and newline", str, expected_result);
  689. str = "SecondLife is a 3D world \ ";
  690. unescape_string(str);
  691. expected_result = "SecondLife is a 3D world \ ";
  692. ensure_equals("unescape_string: insufficient to unescape", str, expected_result);
  694. str = "SecondLife is a 3D world \n \n \n \\\n";
  695. unescape_string(str);
  696. expected_result = "SecondLife is a 3D world n n n \n";
  697. ensure_equals("unescape_string: multipel newline and backslash", str, expected_result);
  699. str = "SecondLife is a 3D world \t";
  700. unescape_string(str);
  701. expected_result = "SecondLife is a 3D world \t";
  702. ensure_equals("unescape_string: leaves tab as is", str, expected_result);
  704. str = "\n";
  705. unescape_string(str);
  706. expected_result = "n";
  707. ensure_equals("unescape_string: only a newline", str, expected_result);
  708. }
  710. //testcases for escape_string()
  711. template<> template<>
  712. void streamtools_object::test<18>()
  713. {
  714. std::string str;
  715. std::string expected_result;
  717. str = "SecondLife is a 3D world n";
  718. escape_string(str);
  719. expected_result = "SecondLife is a 3D world \n";
  720. ensure_equals("escape_string: newline", str, expected_result);
  722. str = "SecondLife is a 3D world \t n";
  723. escape_string(str);
  724. expected_result = "SecondLife is a 3D world \\t \n";
  725. ensure_equals("escape_string: backslash and newline", str, expected_result);
  727. str = "SecondLife is a 3D world n n n \n";
  728. escape_string(str);
  729. expected_result = "SecondLife is a 3D world \n \n \n \\\n";
  730. ensure_equals("escape_string: multipel newline and backslash", str, expected_result);
  732. str = "SecondLife is a 3D world t";
  733. escape_string(str);
  734. expected_result = "SecondLife is a 3D world t";
  735. ensure_equals("unescape_string: leaves tab as is", str, expected_result);
  737. str = "n";
  738. escape_string(str);
  739. expected_result = "\n";
  740. ensure_equals("unescape_string: only a newline", str, expected_result);
  742. // serialization/deserialization escape->unescape
  743. str = "SecondLife is a 3D world n n n \n";
  744. escape_string(str);
  745. unescape_string(str);
  746. expected_result = "SecondLife is a 3D world n n n \n";
  747. ensure_equals("escape_string: should preserve with escape/unescape", str, expected_result);
  749. // serialization/deserialization  unescape->escape
  750. str = "SecondLife is a 3D world \n \n \n \\";
  751. unescape_string(str);
  752. escape_string(str);
  753. expected_result = "SecondLife is a 3D world \n \n \n \\";
  754. ensure_equals("escape_string: should preserve with unescape/escape", str, expected_result);
  755. }
  757. // testcases for replace_newlines_with_whitespace()
  758. template<> template<>
  759. void streamtools_object::test<19>()
  760. {
  761. std::string str;
  762. std::string expected_result;
  764. str = "SecondLife is a 3D nnworldn";
  765. replace_newlines_with_whitespace(str);
  766. expected_result = "SecondLife is a 3D   world ";
  767. ensure_equals("replace_newlines_with_whitespace: replace all newline", str, expected_result);
  769. str = "nSecondLife is a 3D worldn";
  770. replace_newlines_with_whitespace(str);
  771. expected_result = " SecondLife is a 3D world ";
  772. ensure_equals("replace_newlines_with_whitespace: begin and newline", str, expected_result);
  774. str = "SecondLife is a 3D worldrt";
  775. replace_newlines_with_whitespace(str);
  776. expected_result = "SecondLife is a 3D worldrt";
  777. ensure_equals("replace_newlines_with_whitespace: should only replace newline", str, expected_result);
  779. str = "";
  780. replace_newlines_with_whitespace(str);
  781. expected_result = "";
  782. ensure_equals("replace_newlines_with_whitespace: empty string", str, expected_result);
  783. }
  785. //testcases for remove_double_quotes()
  786. template<> template<>
  787. void streamtools_object::test<20>()
  788. {
  789. std::string str;
  790. std::string expected_result;
  792. str = "SecondLife is a ""3D world";
  793. remove_double_quotes(str);
  794. expected_result = "SecondLife is a 3D world";
  795. ensure_equals("remove_double_quotes: replace empty doube quotes", str, expected_result);
  797. str = "SecondLife is a "3D world";
  798. remove_double_quotes(str);
  799. expected_result = "SecondLife is a 3D world";
  800. ensure_equals("remove_double_quotes: keep as is it matching quote not found", str, expected_result);
  801. }
  803. // testcases for get_brace_count()
  804. template<> template<>
  805. void streamtools_object::test<21>()
  806. {
  807. }
  809. //testcases for get_keyword_and_value()
  810. template<> template<>
  811. void streamtools_object::test<22>()
  812. {
  813. std::string s = "SecondLife is a 3D World";
  814. std::string keyword;
  815. std::string value;
  816. get_keyword_and_value(keyword, value, s);
  817. ensure("get_keyword_and_value: Unable to get Keyword and Value", ((keyword == "SecondLife") && (value == "is a 3D World")));
  819. s = "SecondLife";
  820. get_keyword_and_value(keyword, value, s);
  821. ensure("get_keyword_and_value: value should be empty", ((keyword == "SecondLife") && (value == "")));
  823. s = "SecondLife t  is cool!     n";
  824. get_keyword_and_value(keyword, value, s);
  825. ensure("get_keyword_and_value: remove space before value but not after", ((keyword == "SecondLife") && (value == "is cool!     ")));
  826. }
  828. //testcases for get_keyword_and_value()
  829. template<> template<>
  830. void streamtools_object::test<23>()
  831. {
  832. std::string s;
  833. std::string keyword = "SOME PRIOR KEYWORD";
  834. std::string value = "SOME PRIOR VALUE";
  836. s = "SecondLifen";
  837. get_keyword_and_value(keyword, value, s);
  838. ensure("get_keyword_and_value: terminated with newline. value should be empty", ((keyword == "SecondLife") && (value == "")));
  839. }
  841. //testcases for get_keyword_and_value()
  842. template<> template<>
  843. void streamtools_object::test<24>()
  844. {
  845. std::string s;
  846. std::string keyword = "SOME PRIOR KEYWORD";
  847. std::string value = "SOME PRIOR VALUE";
  849. s = "";
  850. get_keyword_and_value(keyword, value, s);
  851. ensure("get_keyword_and_value: empty string. keyword value should empty", ((keyword == "") && (value == "")));
  852. }
  854. //testcase for fullread()
  855. template<> template<>
  856. void streamtools_object::test<25>()
  857. {
  858. std::string str = "First Line.nSecond Linen";
  859. std::istringstream is(str);
  860. char buf[255] = {0};
  862. fullread(is, buf, 255);
  863. ensure_memory_matches("fullread: read with newlines", (void*) buf,  str.size()-1, (void*) str.c_str(), str.size()-1);
  865. is.clear();
  866. is.str(str = "First Line.nSecond Linen");
  867. memset(buf, 0, 255);
  869. char expected_string[] = "First Line.nSecond";
  870. int len = sizeof(expected_string)-1;
  871. fullread(is, buf, len);
  872. ensure_memory_matches("fullread: read with newlines", (void*) buf, len, (void*) &expected_string, len);
  873. }
  876. //   testcases for operator >>
  878. template<> template<>
  879. void streamtools_object::test<26>()
  880. {
  881. char arr[255];
  882. std::string str;
  883. std::string toCheck = "SecondLife" ;
  884. std::string expected_result;
  885. std::istringstream stream("SecondLife is a 3D World");
  886. stream >> toCheck.c_str();
  887. stream.get(arr, 255, '');
  888. expected_result = " is a 3D World"; 
  889. ensure_equals("istream << operator", arr, expected_result);
  891. stream.clear();
  892. stream.str(str = "SecondLife is a 3D World");
  893. toCheck = "is";
  894. stream >> toCheck.c_str();
  895. ensure("istream << operator should have failed", stream.good() == false);
  896. }
  897. }