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

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

游戏引擎

开发平台：

C++ Builder

commonmisc_test.cpp：源码内容
  1. /** 
  2.  * @file common.cpp
  3.  * @author Phoenix
  4.  * @date 2005-10-12
  5.  * @brief Common templates for test framework
  6.  *
  7.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2005-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. /** 
  36.  * 
  37.  * THOROUGH_DESCRIPTION of common.cpp
  38.  *
  39.  */
  41. #include <algorithm>
  42. #include <iomanip>
  43. #include <iterator>
  45. #include "linden_common.h"
  47. #include "../llmemorystream.h"
  48. #include "../llsd.h"
  49. #include "../llsdserialize.h"
  50. #include "../u64.h"
  51. #include "../llhash.h"
  53. #include "../test/lltut.h"
  56. #if LL_WINDOWS
  57. // disable overflow warnings
  58. #pragma warning(disable: 4307)
  59. #endif
  61. namespace tut
  62. {
  63. struct sd_data
  64. {
  65. };
  66. typedef test_group<sd_data> sd_test;
  67. typedef sd_test::object sd_object;
  68. tut::sd_test sd("llsd");
  70. template<> template<>
  71. void sd_object::test<1>()
  72. {
  73. std::ostringstream resp;
  74. resp << "{'connect':true,  'position':[r128,r128,r128], 'look_at':[r0,r1,r0], 'agent_access':'M', 'region_x':i8192, 'region_y':i8192}";
  75. std::string str = resp.str();
  76. LLMemoryStream mstr((U8*)str.c_str(), str.size());
  77. LLSD response;
  78. S32 count = LLSDSerialize::fromNotation(response, mstr, str.size());
  79. ensure("stream parsed", response.isDefined());
  80. ensure_equals("stream parse count", count, 13);
  81. ensure_equals("sd type", response.type(), LLSD::TypeMap);
  82. ensure_equals("map element count", response.size(), 6);
  83. ensure_equals("value connect", response["connect"].asBoolean(), true);
  84. ensure_equals("value region_x", response["region_x"].asInteger(),8192);
  85. ensure_equals("value region_y", response["region_y"].asInteger(),8192);
  86. }
  88. template<> template<>
  89. void sd_object::test<2>()
  90. {
  91. const std::string decoded("random");
  92. //const std::string encoded("cmFuZG9tn");
  93. const std::string streamed("b(6)"random"");
  94. typedef std::vector<U8> buf_t;
  95. buf_t buf;
  96. std::copy(
  97. decoded.begin(),
  98. decoded.end(),
  99. std::back_insert_iterator<buf_t>(buf));
  100. LLSD sd;
  101. sd = buf;
  102. std::stringstream str;
  103. S32 count = LLSDSerialize::toNotation(sd, str);
  104. ensure_equals("output count", count, 1);
  105. std::string actual(str.str());
  106. ensure_equals("formatted binary encoding", actual, streamed);
  107. sd.clear();
  108. LLSDSerialize::fromNotation(sd, str, str.str().size());
  109. std::vector<U8> after;
  110. after = sd.asBinary();
  111. ensure_equals("binary decoded size", after.size(), decoded.size());
  112. ensure("binary decoding", (0 == memcmp(
  113.    &after[0],
  114.    decoded.c_str(),
  115.    decoded.size())));
  116. }
  118. template<> template<>
  119. void sd_object::test<3>()
  120. {
  121. for(S32 i = 0; i < 100; ++i)
  122. {
  123. // gen up a starting point
  124. typedef std::vector<U8> buf_t;
  125. buf_t source;
  126. srand(i); /* Flawfinder: ignore */
  127. S32 size = rand() % 1000 + 10;
  128. std::generate_n(
  129. std::back_insert_iterator<buf_t>(source),
  130. size,
  131. rand);
  132. LLSD sd(source);
  133. std::stringstream str;
  134. S32 count = LLSDSerialize::toNotation(sd, str);
  135. sd.clear();
  136. ensure_equals("format count", count, 1);
  137. LLSD sd2;
  138. count = LLSDSerialize::fromNotation(sd2, str, str.str().size());
  139. ensure_equals("parse count", count, 1);
  140. buf_t dest = sd2.asBinary();
  141. str.str("");
  142. str << "binary encoding size " << i;
  143. ensure_equals(str.str().c_str(), dest.size(), source.size());
  144. str.str("");
  145. str << "binary encoding " << i;
  146. ensure(str.str().c_str(), (source == dest));
  147. }
  148. }
  150. template<> template<>
  151. void sd_object::test<4>()
  152. {
  153. std::ostringstream ostr;
  154. ostr << "{'task_id':u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}n"
  155.  << "{ntnametObject|n}n";
  156. std::string expected = ostr.str();
  157. std::stringstream serialized;
  158. serialized << "'" << LLSDNotationFormatter::escapeString(expected)
  159.    << "'";
  160. LLSD sd;
  161. S32 count = LLSDSerialize::fromNotation(
  162. sd,
  163. serialized,
  164. serialized.str().size());
  165. ensure_equals("parse count", count, 1);
  166. ensure_equals("String streaming", sd.asString(), expected);
  167. }
  169. template<> template<>
  170. void sd_object::test<5>()
  171. {
  172. for(S32 i = 0; i < 100; ++i)
  173. {
  174. // gen up a starting point
  175. typedef std::vector<U8> buf_t;
  176. buf_t source;
  177. srand(666 + i); /* Flawfinder: ignore */
  178. S32 size = rand() % 1000 + 10;
  179. std::generate_n(
  180. std::back_insert_iterator<buf_t>(source),
  181. size,
  182. rand);
  183. std::stringstream str;
  184. str << "b(" << size << ")"";
  185. str.write((const char*)&source[0], size);
  186. str << """;
  187. LLSD sd;
  188. S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
  189. ensure_equals("binary parse", count, 1);
  190. buf_t actual = sd.asBinary();
  191. ensure_equals("binary size", actual.size(), (size_t)size);
  192. ensure("binary data", (0 == memcmp(&source[0], &actual[0], size)));
  193. }
  194. }
  196. template<> template<>
  197. void sd_object::test<6>()
  198. {
  199. std::string expected("'{"task_id":u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}'tntt");
  200. std::stringstream str;
  201. str << "s(" << expected.size() << ")'";
  202. str.write(expected.c_str(), expected.size());
  203. str << "'";
  204. LLSD sd;
  205. S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
  206. ensure_equals("parse count", count, 1);
  207. std::string actual = sd.asString();
  208. ensure_equals("string sizes", actual.size(), expected.size());
  209. ensure_equals("string content", actual, expected);
  210. }
  212. template<> template<>
  213. void sd_object::test<7>()
  214. {
  215. std::string msg("come on in");
  216. std::stringstream stream;
  217. stream << "{'connect':1, 'message':'" << msg << "',"
  218.    << " 'position':[r45.65,r100.1,r25.5],"
  219.    << " 'look_at':[r0,r1,r0],"
  220.    << " 'agent_access':'PG'}";
  221. LLSD sd;
  222. S32 count = LLSDSerialize::fromNotation(
  223. sd,
  224. stream,
  225. stream.str().size());
  226. ensure_equals("parse count", count, 12);
  227. ensure_equals("bool value", sd["connect"].asBoolean(), true);
  228. ensure_equals("message value", sd["message"].asString(), msg);
  229. ensure_equals("pos x", sd["position"][0].asReal(), 45.65);
  230. ensure_equals("pos y", sd["position"][1].asReal(), 100.1);
  231. ensure_equals("pos z", sd["position"][2].asReal(), 25.5);
  232. ensure_equals("look x", sd["look_at"][0].asReal(), 0.0);
  233. ensure_equals("look y", sd["look_at"][1].asReal(), 1.0);
  234. ensure_equals("look z", sd["look_at"][2].asReal(), 0.0);
  235. }
  237. template<> template<>
  238. void sd_object::test<8>()
  239. {
  240. std::stringstream resp;
  241. resp << "{'label':'short string test', 'singlechar':'a', 'empty':'', 'endoftest':'end' }";
  242. LLSD response;
  243. S32 count = LLSDSerialize::fromNotation(
  244. response,
  245. resp,
  246. resp.str().size());
  247. ensure_equals("parse count", count, 5);
  248. ensure_equals("sd type", response.type(), LLSD::TypeMap);
  249. ensure_equals("map element count", response.size(), 4);
  250. ensure_equals("singlechar", response["singlechar"].asString(), "a");
  251. ensure_equals("empty", response["empty"].asString(), "");
  252. }
  254. template<> template<>
  255. void sd_object::test<9>()
  256. {
  257. std::ostringstream resp;
  258. resp << "{'label':'short binary test', 'singlebinary':b(1)"A", 'singlerawstring':s(1)"A", 'endoftest':'end' }";
  259. std::string str = resp.str();
  260. LLSD sd;
  261. LLMemoryStream mstr((U8*)str.c_str(), str.size());
  262. S32 count = LLSDSerialize::fromNotation(sd, mstr, str.size());
  263. ensure_equals("parse count", count, 5);
  264. ensure("sd created", sd.isDefined());
  265. ensure_equals("sd type", sd.type(), LLSD::TypeMap);
  266. ensure_equals("map element count", sd.size(), 4);
  267. ensure_equals(
  268. "label",
  269. sd["label"].asString(),
  270. "short binary test");
  271. std::vector<U8> bin =  sd["singlebinary"].asBinary();
  272. std::vector<U8> expected;
  273. expected.resize(1);
  274. expected[0] = 'A';
  275. ensure("single binary", (0 == memcmp(&bin[0], &expected[0], 1)));
  276. ensure_equals(
  277. "single string",
  278. sd["singlerawstring"].asString(),
  279. std::string("A"));
  280. ensure_equals("end", sd["endoftest"].asString(), "end");
  281. }
  283. template<> template<>
  284. void sd_object::test<10>()
  285. {
  287. std::string message("parcel '' is naughty.");
  288. std::stringstream str;
  289. str << "{'message':'" << LLSDNotationFormatter::escapeString(message)
  290. << "'}";
  291. std::string expected_str("{'message':'parcel \'\' is naughty.'}");
  292. std::string actual_str = str.str();
  293. ensure_equals("stream contents", actual_str, expected_str);
  294. LLSD sd;
  295. S32 count = LLSDSerialize::fromNotation(sd, str, actual_str.size());
  296. ensure_equals("parse count", count, 2);
  297. ensure("valid parse", sd.isDefined());
  298. std::string actual = sd["message"].asString();
  299. ensure_equals("message contents", actual, message);
  300. }
  302. template<> template<>
  303. void sd_object::test<11>()
  304. {
  305. std::string expected("""""''''''"");
  306. std::stringstream str;
  307. str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
  308. LLSD sd;
  309. S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
  310. ensure_equals("parse count", count, 1);
  311. ensure_equals("string value", sd.asString(), expected);
  312. }
  314. template<> template<>
  315. void sd_object::test<12>()
  316. {
  317. std::string expected("mytest\");
  318. std::stringstream str;
  319. str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
  320. LLSD sd;
  321. S32 count = LLSDSerialize::fromNotation(sd, str, str.str().size());
  322. ensure_equals("parse count", count, 1);
  323. ensure_equals("string value", sd.asString(), expected);
  324. }
  326. template<> template<>
  327. void sd_object::test<13>()
  328. {
  329. for(S32 i = 0; i < 1000; ++i)
  330. {
  331. // gen up a starting point
  332. std::string expected;
  333. srand(1337 + i); /* Flawfinder: ignore */
  334. S32 size = rand() % 30 + 5;
  335. std::generate_n(
  336. std::back_insert_iterator<std::string>(expected),
  337. size,
  338. rand);
  339. std::stringstream str;
  340. str << "'" << LLSDNotationFormatter::escapeString(expected) << "'";
  341. LLSD sd;
  342. S32 count = LLSDSerialize::fromNotation(sd, str, expected.size());
  343. ensure_equals("parse count", count, 1);
  344. std::string actual = sd.asString();
  345. /*
  346. if(actual != expected)
  347. {
  348. llwarns << "iteration " << i << llendl;
  349. std::ostringstream e_str;
  350. std::string::iterator iter = expected.begin();
  351. std::string::iterator end = expected.end();
  352. for(; iter != end; ++iter)
  353. {
  354. e_str << (S32)((U8)(*iter)) << " ";
  355. }
  356. e_str << std::endl;
  357. llsd_serialize_string(e_str, expected);
  358. llwarns << "expected size: " << expected.size() << llendl;
  359. llwarns << "expected:      " << e_str.str() << llendl;
  361. std::ostringstream a_str;
  362. iter = actual.begin();
  363. end = actual.end();
  364. for(; iter != end; ++iter)
  365. {
  366. a_str << (S32)((U8)(*iter)) << " ";
  367. }
  368. a_str << std::endl;
  369. llsd_serialize_string(a_str, actual);
  370. llwarns << "actual size:   " << actual.size() << llendl;
  371. llwarns << "actual:      " << a_str.str() << llendl;
  372. }
  373. */
  374. ensure_equals("string value", actual, expected);
  375. }
  376. }
  378. template<> template<>
  379. void sd_object::test<14>()
  380. {
  381. //#if LL_WINDOWS && _MSC_VER >= 1400
  382. //        skip_fail("Fails on VS2005 due to broken LLSDSerialize::fromNotation() parser.");
  383. //#endif
  384. std::string param = "[{'version':i1},{'data':{'binary_bucket':b(0)""},'from_id':u3c115e51-04f4-523c-9fa6-98aff1034730,'from_name':'Phoenix Linden','id':u004e45e5-5576-277a-fba7-859d6a4cb5c8,'message':'hey','offline':i0,'timestamp':i0,'to_id':u3c5f1bb4-5182-7546-6401-1d329b4ff2f8,'type':i0},{'agent_id':u3c115e51-04f4-523c-9fa6-98aff1034730,'god_level':i0,'limited_to_estate':i1}]";
  385. std::istringstream istr;
  386. istr.str(param);
  387. LLSD param_sd;
  388. LLSDSerialize::fromNotation(param_sd, istr, param.size());
  389. ensure_equals("parsed type", param_sd.type(), LLSD::TypeArray);
  390. LLSD version_sd = param_sd[0];
  391. ensure_equals("version type", version_sd.type(), LLSD::TypeMap);
  392. ensure("has version", version_sd.has("version"));
  393. ensure_equals("version number", version_sd["version"].asInteger(), 1);
  394. LLSD src_sd = param_sd[1];
  395. ensure_equals("src type", src_sd.type(), LLSD::TypeMap);
  396. LLSD dst_sd = param_sd[2];
  397. ensure_equals("dst type", dst_sd.type(), LLSD::TypeMap);
  398. }
  400. template<> template<>
  401. void sd_object::test<15>()
  402. {
  403. std::string val = "[{'failures':!,'successfuls':[u3c115e51-04f4-523c-9fa6-98aff1034730]}]";
  404. std::istringstream istr;
  405. istr.str(val);
  406. LLSD sd;
  407. LLSDSerialize::fromNotation(sd, istr, val.size());
  408. ensure_equals("parsed type", sd.type(), LLSD::TypeArray);
  409. ensure_equals("parsed size", sd.size(), 1);
  410. LLSD failures = sd[0]["failures"];
  411. ensure("no failures.", failures.isUndefined());
  412. LLSD success = sd[0]["successfuls"];
  413. ensure_equals("success type", success.type(), LLSD::TypeArray);
  414. ensure_equals("success size", success.size(), 1);
  415. ensure_equals("success instance type", success[0].type(), LLSD::TypeUUID);
  416. }
  418. template<> template<>
  419. void sd_object::test<16>()
  420. {
  421. std::string val = "[f,t,0,1,{'foo':t,'bar':f}]";
  422. std::istringstream istr;
  423. istr.str(val);
  424. LLSD sd;
  425. LLSDSerialize::fromNotation(sd, istr, val.size());
  426. ensure_equals("parsed type", sd.type(), LLSD::TypeArray);
  427. ensure_equals("parsed size", sd.size(), 5);
  428. ensure_equals("element 0 false", sd[0].asBoolean(), false);
  429. ensure_equals("element 1 true", sd[1].asBoolean(), true);
  430. ensure_equals("element 2 false", sd[2].asBoolean(), false);
  431. ensure_equals("element 3 true", sd[3].asBoolean(), true);
  432. LLSD map = sd[4];
  433. ensure_equals("element 4 type", map.type(), LLSD::TypeMap);
  434. ensure_equals("map foo type", map["foo"].type(), LLSD::TypeBoolean);
  435. ensure_equals("map foo value", map["foo"].asBoolean(), true);
  436. ensure_equals("map bar type", map["bar"].type(), LLSD::TypeBoolean);
  437. ensure_equals("map bar value", map["bar"].asBoolean(), false);
  438. }
  440. /*
  441. template<> template<>
  442. void sd_object::test<16>()
  443. {
  444. }
  445. */
  446. }
  448. #if 0
  449. '{'task_id':u1fd77b79-a8e7-25a5-9454-02a4d948ba1c}n{ntnametObject|ntpermissions 0nt{nttbase_maskt7fffffffnttowner_maskt7fffffffnttgroup_maskt00000000ntteveryone_maskt00000000nttnext_owner_maskt00082000nttcreator_idt3c115e51-04f4-523c-9fa6-98aff1034730nttowner_idt3c115e51-04f4-523c-9fa6-98aff1034730nttlast_owner_idt00000000-0000-0000-0000-000000000000nttgroup_idt00000000-0000-0000-0000-000000000000nt}ntlocal_idt10284nttotal_crct35nttypet1nttask_validt2nttravel_accesst21ntdisplayoptst2ntdisplaytypetvntpost0t0t0ntoldpost0t0t0ntrotationt4.371139183945160766597837e-08t1t4.371139183945160766597837e-08t0ntvelocityt0t0t0ntangvelt0t0t0ntscalet0.2816932t0.2816932t0.2816932ntsit_offsett0t0t0ntcamera_eye_offsett0t0t0ntcamera_at_offsett0t0t0ntsit_quatt0t0t0t1ntsit_hintt0ntstatet80ntmaterialt3ntsoundidt00000000-0000-0000-0000-000000000000ntsoundgaint0ntsoundradiust0ntsoundflagst0nttextcolort0 0 0 1ntselectedt0ntselectort00000000-0000-0000-0000-000000000000ntusephysicst0ntrotate_xt1ntrotate_yt1ntrotate_zt1ntphantomt0ntremote_script_access_pint0ntvolume_detectt0ntblock_grabst0ntdie_at_edget0ntreturn_at_edget0nttemporaryt0ntsandboxt0ntsandboxhomet0t0t0ntshape 0nt{nttpath 0ntt{ntttcurvet16ntttbegint0ntttendt1ntttscale_xt1ntttscale_yt1ntttshear_xt0ntttshear_yt0nttttwistt0nttttwist_begint0ntttradius_offsett0nttttaper_xt0nttttaper_yt0ntttrevolutionst1ntttskewt0ntt}nttprofile 0ntt{ntttcurvet1ntttbegint0ntttendt1nttthollowt0ntt}nt}ntfacest6nt{nttimageidt89556747-24cb-43ed-920b-47caed15465fnttcolorst1 1 1 1nttscalest0.56nttscalett0.56nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidt89556747-24cb-43ed-920b-47caed15465fnttcolorst1 1 1 1nttscalest0.56nttscalett0.56nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidt89556747-24cb-43ed-920b-47caed15465fnttcolorst1 1 1 1nttscalest0.56nttscalett0.56nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidt89556747-24cb-43ed-920b-47caed15465fnttcolorst1 1 1 1nttscalest0.56nttscalett0.56nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidt89556747-24cb-43ed-920b-47caed15465fnttcolorst1 1 1 1nttscalest0.56nttscalett0.56nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}nt{nttimageidt89556747-24cb-43ed-920b-47caed15465fnttcolorst1 1 1 1nttscalest0.56nttscalett0.56nttoffsetst0nttoffsettt0nttimagerott0nttbumpt0nttfullbrightt0nttmedia_flagst0nt}ntps_next_crct1ntgpw_biast1ntipt0ntcompletetTRUEntdelayt50000ntnextstartt1132625972249870ntbirthtimet1132625953120694ntreztimet1132625953120694ntparceltimet1132625953120694nttax_ratet1.01615ntnamevaluetAttachmentOrientation VEC3 RW DS -3.141593, 0.000000, -3.141593ntnamevaluetAttachmentOffset VEC3 RW DS 0.000000, 0.000000, 0.000000ntnamevaluetAttachPt U32 RW S 5ntnamevaluetAttachItemID STRING RW SV 1f9975c0-2951-1b93-dd83-46e2b932fcc8ntscratchpadt0nt{ntnt}ntsale_infot0nt{nttsale_typetnotnttsale_pricet10nt}ntorig_asset_idt52019cdd-b464-ba19-e66d-3da751fef9dantorig_item_idt1f9975c0-2951-1b93-dd83-46e2b932fcc8ntcorrect_family_idt00000000-0000-0000-0000-000000000000nthas_rezzedt0ntpre_link_base_maskt7fffffffntdefault_pay_pricet-2t1t5t10t20n}n'
  450. #endif
  452. namespace tut
  453. {
  454. struct mem_data
  455. {
  456. };
  457. typedef test_group<mem_data> mem_test;
  458. typedef mem_test::object mem_object;
  459. tut::mem_test mem_stream("memory_stream");
  461. template<> template<>
  462. void mem_object::test<1>()
  463. {
  464. const char HELLO_WORLD[] = "hello world";
  465. LLMemoryStream mem((U8*)&HELLO_WORLD[0], strlen(HELLO_WORLD)); /* Flawfinder: ignore */
  466. std::string hello;
  467. std::string world;
  468. mem >> hello >> world;
  469. ensure_equals("first word", hello, std::string("hello"));
  470. ensure_equals("second word", world, std::string("world"));
  471. }
  472. }
  474. namespace tut
  475. {
  476. struct U64_data
  477. {
  478. };
  479. typedef test_group<U64_data> U64_test;
  480. typedef U64_test::object U64_object;
  481. tut::U64_test U64_testcase("U64_conversion");
  483. // U64_to_str
  484. template<> template<>
  485. void U64_object::test<1>()
  486. {
  487. U64 val;
  488. std::string val_str;
  489. char result[256];
  490. std::string result_str;
  492. val = U64L(18446744073709551610); // slightly less than MAX_U64
  493. val_str = "18446744073709551610";
  495. U64_to_str(val, result, sizeof(result));
  496. result_str = (const char*) result;
  497. ensure_equals("U64_to_str converted 1.1", val_str, result_str);
  499. val = 0;
  500. val_str = "0";
  501. U64_to_str(val, result, sizeof(result));
  502. result_str = (const char*) result;
  503. ensure_equals("U64_to_str converted 1.2", val_str, result_str);
  505. val = U64L(18446744073709551615); // 0xFFFFFFFFFFFFFFFF
  506. val_str = "18446744073709551615";
  507. U64_to_str(val, result, sizeof(result));
  508. result_str = (const char*) result;
  509. ensure_equals("U64_to_str converted 1.3", val_str, result_str);
  511. // overflow - will result in warning at compile time
  512. val = U64L(18446744073709551615) + 1; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
  513. val_str = "0";
  514. U64_to_str(val, result, sizeof(result));
  515. result_str = (const char*) result;
  516. ensure_equals("U64_to_str converted 1.4", val_str, result_str);
  518. val = U64L(-1); // 0xFFFFFFFFFFFFFFFF == 18446744073709551615
  519. val_str = "18446744073709551615";
  520. U64_to_str(val, result, sizeof(result));
  521. result_str = (const char*) result;
  522. ensure_equals("U64_to_str converted 1.5", val_str, result_str);
  524. val = U64L(10000000000000000000); // testing preserving of 0s
  525. val_str = "10000000000000000000";
  526. U64_to_str(val, result, sizeof(result));
  527. result_str = (const char*) result;
  528. ensure_equals("U64_to_str converted 1.6", val_str, result_str);
  530. val = 1; // testing no leading 0s
  531. val_str = "1";
  532. U64_to_str(val, result, sizeof(result));
  533. result_str = (const char*) result;
  534. ensure_equals("U64_to_str converted 1.7", val_str, result_str);
  536. val = U64L(18446744073709551615); // testing exact sized buffer for result
  537. val_str = "18446744073709551615";
  538. memset(result, 'A', sizeof(result)); // initialize buffer with all 'A'
  539. U64_to_str(val, result, sizeof("18446744073709551615")); //pass in the exact size
  540. result_str = (const char*) result;
  541. ensure_equals("U64_to_str converted 1.8", val_str, result_str);
  543. val = U64L(18446744073709551615); // testing smaller sized buffer for result
  544. val_str = "1844";
  545. memset(result, 'A', sizeof(result)); // initialize buffer with all 'A'
  546. U64_to_str(val, result, 5); //pass in a size of 5. should only copy first 4 integers and add a null terminator
  547. result_str = (const char*) result;
  548. ensure_equals("U64_to_str converted 1.9", val_str, result_str);
  549. }
  551. // str_to_U64
  552. template<> template<>
  553. void U64_object::test<2>()
  554. {
  555. U64 val;
  556. U64 result;
  558. val = U64L(18446744073709551610); // slightly less than MAX_U64
  559. result = str_to_U64("18446744073709551610");
  560. ensure_equals("str_to_U64 converted 2.1", val, result);
  562. val = U64L(0); // empty string
  563. result = str_to_U64(LLStringUtil::null);
  564. ensure_equals("str_to_U64 converted 2.2", val, result);
  566. val = U64L(0); // 0
  567. result = str_to_U64("0");
  568. ensure_equals("str_to_U64 converted 2.3", val, result);
  570. val = U64L(18446744073709551615); // 0xFFFFFFFFFFFFFFFF
  571. result = str_to_U64("18446744073709551615");
  572. ensure_equals("str_to_U64 converted 2.4", val, result);
  574. // overflow - will result in warning at compile time
  575. val = U64L(18446744073709551615) + 1; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
  576. result = str_to_U64("18446744073709551616");
  577. ensure_equals("str_to_U64 converted 2.5", val, result);
  579. val = U64L(1234); // process till first non-integral character
  580. result = str_to_U64("1234A5678");
  581. ensure_equals("str_to_U64 converted 2.6", val, result);
  583. val = U64L(5678); // skip all non-integral characters
  584. result = str_to_U64("ABCD5678");
  585. ensure_equals("str_to_U64 converted 2.7", val, result);
  587. // should it skip negative sign and process 
  588. // rest of string or return 0
  589. val = U64L(1234); // skip initial negative sign 
  590. result = str_to_U64("-1234");
  591. ensure_equals("str_to_U64 converted 2.8", val, result);
  593. val = U64L(5678); // stop at negative sign in the middle
  594. result = str_to_U64("5678-1234");
  595. ensure_equals("str_to_U64 converted 2.9", val, result);
  597. val = U64L(0); // no integers
  598. result = str_to_U64("AaCD");
  599. ensure_equals("str_to_U64 converted 2.10", val, result);
  600. }
  602. // U64_to_F64
  603. template<> template<>
  604. void U64_object::test<3>()
  605. {
  606. F64 val;
  607. F64 result;
  609. result = 18446744073709551610.0;
  610. val = U64_to_F64(U64L(18446744073709551610));
  611. ensure_equals("U64_to_F64 converted 3.1", val, result);
  613. result = 18446744073709551615.0; // 0xFFFFFFFFFFFFFFFF
  614. val = U64_to_F64(U64L(18446744073709551615));
  615. ensure_equals("U64_to_F64 converted 3.2", val, result);
  617. result = 0.0; // overflow 0xFFFFFFFFFFFFFFFF + 1 == 0
  618. // overflow - will result in warning at compile time
  619. val = U64_to_F64(U64L(18446744073709551615)+1);
  620. ensure_equals("U64_to_F64 converted 3.3", val, result);
  622. result = 0.0; // 0
  623. val = U64_to_F64(U64L(0));
  624. ensure_equals("U64_to_F64 converted 3.4", val, result);
  626. result = 1.0; // odd
  627. val = U64_to_F64(U64L(1));
  628. ensure_equals("U64_to_F64 converted 3.5", val, result);
  630. result = 2.0; // even
  631. val = U64_to_F64(U64L(2));
  632. ensure_equals("U64_to_F64 converted 3.6", val, result);
  634. result = U64L(0x7FFFFFFFFFFFFFFF) * 1.0L; // 0x7FFFFFFFFFFFFFFF
  635. val = U64_to_F64(U64L(0x7FFFFFFFFFFFFFFF));
  636. ensure_equals("U64_to_F64 converted 3.7", val, result);
  637. }
  639. // llstrtou64 
  640. // seems to be deprecated - could not find it being used 
  641. // anywhere in the tarball - skipping unit tests for now
  642. }
  645. namespace tut
  646. {
  647. struct hash_data
  648. {
  649. };
  650. typedef test_group<hash_data> hash_test;
  651. typedef hash_test::object hash_object;
  652. tut::hash_test hash_tester("hash_test");
  654. template<> template<>
  655. void hash_object::test<1>()
  656. {
  657. const char * str1 = "test string one";
  658. const char * same_as_str1 = "test string one";
  660. size_t hash1 = llhash(str1);
  661. size_t same_as_hash1 = llhash(same_as_str1);
  664. ensure("Hashes from identical strings should be equal", hash1 == same_as_hash1);
  666. char str[100];
  667. strcpy( str, "Another test" );
  669. size_t hash2 = llhash(str);
  671. strcpy( str, "Different string, same pointer" );
  673. size_t hash3 = llhash(str);
  675. ensure("Hashes from same pointer but different string should not be equal", hash2 != hash3);
  676. }
  677. }