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

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

游戏引擎

开发平台：

C++ Builder

llsdserialize_test.cpp：源码内容
  1. /** 
  2.  * @file llsdserialize_test.cpp
  3.  * @date 2006-04
  4.  * @brief LLSDSerialize unit tests
  5.  *
  6.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2006-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. #if !LL_WINDOWS
  35. #include <netinet/in.h>
  36. #endif
  38. #include "linden_common.h"
  39. #include "../llsd.h"
  40. #include "../llsdserialize.h"
  41. #include "../llformat.h"
  43. #include "../test/lltut.h"
  46. #if LL_WINDOWS
  47. #include <winsock2.h>
  48. typedef U32 uint32_t;
  49. #endif
  51. std::vector<U8> string_to_vector(std::string str)
  52. {
  53. // bc LLSD can't...
  54. size_t len = (size_t)str.length();
  55. std::vector<U8> v(len);
  56. for (size_t i = 0; i < len ; i++)
  57. {
  58. v[i] = str[i];
  59. }
  60. return v;
  61. }
  63. namespace tut
  64. {
  65. struct sd_xml_data
  66. {
  67. sd_xml_data()
  68. {
  69. mFormatter = new LLSDXMLFormatter;
  70. }
  71. LLSD mSD;
  72. LLPointer<LLSDXMLFormatter> mFormatter;
  73. void xml_test(const char* name, const std::string& expected)
  74. {
  75. std::ostringstream ostr;
  76. mFormatter->format(mSD, ostr);
  77. ensure_equals(name, ostr.str(), expected);
  78. }
  79. };
  81. typedef test_group<sd_xml_data> sd_xml_test;
  82. typedef sd_xml_test::object sd_xml_object;
  83. tut::sd_xml_test sd_xml_stream("sd_xml_serialization");
  85. template<> template<>
  86. void sd_xml_object::test<1>()
  87. {
  88. // random atomic tests
  89. std::string expected;
  91. expected = "<llsd><undef /></llsd>n";
  92. xml_test("undef", expected);
  94. mSD = 3463;
  95. expected = "<llsd><integer>3463</integer></llsd>n";
  96. xml_test("integer", expected);
  98. mSD = "";
  99. expected = "<llsd><string /></llsd>n";
  100. xml_test("empty string", expected);
  102. mSD = "foobar";
  103. expected = "<llsd><string>foobar</string></llsd>n";
  104. xml_test("string", expected);
  106. mSD = LLUUID::null;
  107. expected = "<llsd><uuid /></llsd>n";
  108. xml_test("null uuid", expected);
  110. mSD = LLUUID("c96f9b1e-f589-4100-9774-d98643ce0bed");
  111. expected = "<llsd><uuid>c96f9b1e-f589-4100-9774-d98643ce0bed</uuid></llsd>n";
  112. xml_test("uuid", expected);
  114. mSD = LLURI("https://secondlife.com/login");
  115. expected = "<llsd><uri>https://secondlife.com/login</uri></llsd>n";
  116. xml_test("uri", expected);
  118. mSD = LLDate("2006-04-24T16:11:33Z");
  119. expected = "<llsd><date>2006-04-24T16:11:33Z</date></llsd>n";
  120. xml_test("date", expected);
  122. // Generated by: echo -n 'hello' | openssl enc -e -base64
  123. std::vector<U8> hello;
  124. hello.push_back('h');
  125. hello.push_back('e');
  126. hello.push_back('l');
  127. hello.push_back('l');
  128. hello.push_back('o');
  129. mSD = hello;
  130. expected = "<llsd><binary encoding="base64">aGVsbG8=</binary></llsd>n";
  131. xml_test("binary", expected);
  132. }
  134. template<> template<>
  135. void sd_xml_object::test<2>()
  136. {
  137. // tests with boolean values.
  138. std::string expected;
  140. mFormatter->boolalpha(true);
  141. mSD = true;
  142. expected = "<llsd><boolean>true</boolean></llsd>n";
  143. xml_test("bool alpha true", expected);
  144. mSD = false;
  145. expected = "<llsd><boolean>false</boolean></llsd>n";
  146. xml_test("bool alpha false", expected);
  148. mFormatter->boolalpha(false);
  149. mSD = true;
  150. expected = "<llsd><boolean>1</boolean></llsd>n";
  151. xml_test("bool true", expected);
  152. mSD = false;
  153. expected = "<llsd><boolean>0</boolean></llsd>n";
  154. xml_test("bool false", expected);
  155. }
  158. template<> template<>
  159. void sd_xml_object::test<3>()
  160. {
  161. // tests with real values.
  162. std::string expected;
  164. mFormatter->realFormat("%.2f");
  165. mSD = 1.0;
  166. expected = "<llsd><real>1.00</real></llsd>n";
  167. xml_test("real 1", expected);
  169. mSD = -34379.0438;
  170. expected = "<llsd><real>-34379.04</real></llsd>n";
  171. xml_test("real reduced precision", expected);
  172. mFormatter->realFormat("%.4f");
  173. expected = "<llsd><real>-34379.0438</real></llsd>n";
  174. xml_test("higher precision", expected);
  176. mFormatter->realFormat("%.0f");
  177. mSD = 0.0;
  178. expected = "<llsd><real>0</real></llsd>n";
  179. xml_test("no decimal 0", expected);
  180. mSD = 3287.4387;
  181. expected = "<llsd><real>3287</real></llsd>n";
  182. xml_test("no decimal real number", expected);
  183. }
  185. template<> template<>
  186. void sd_xml_object::test<4>()
  187. {
  188. // tests with arrays
  189. std::string expected;
  191. mSD = LLSD::emptyArray();
  192. expected = "<llsd><array /></llsd>n";
  193. xml_test("empty array", expected);
  195. mSD.append(LLSD());
  196. expected = "<llsd><array><undef /></array></llsd>n";
  197. xml_test("1 element array", expected);
  199. mSD.append(1);
  200. expected = "<llsd><array><undef /><integer>1</integer></array></llsd>n";
  201. xml_test("2 element array", expected);
  202. }
  204. template<> template<>
  205. void sd_xml_object::test<5>()
  206. {
  207. // tests with arrays
  208. std::string expected;
  210. mSD = LLSD::emptyMap();
  211. expected = "<llsd><map /></llsd>n";
  212. xml_test("empty map", expected);
  214. mSD["foo"] = "bar";
  215. expected = "<llsd><map><key>foo</key><string>bar</string></map></llsd>n";
  216. xml_test("1 element map", expected);
  218. mSD["baz"] = LLSD();
  219. expected = "<llsd><map><key>baz</key><undef /><key>foo</key><string>bar</string></map></llsd>n";
  220. xml_test("2 element map", expected);
  221. }
  223. template<> template<>
  224. void sd_xml_object::test<6>()
  225. {
  226. // tests with binary
  227. std::string expected;
  229. // Generated by: echo -n 'hello' | openssl enc -e -base64
  230. mSD = string_to_vector("hello");
  231. expected = "<llsd><binary encoding="base64">aGVsbG8=</binary></llsd>n";
  232. xml_test("binary", expected);
  234. mSD = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
  235. expected = "<llsd><binary encoding="base64">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>n";
  236. xml_test("binary", expected);
  237. }
  239. class TestLLSDSerializeData
  240. {
  241. public:
  242. TestLLSDSerializeData();
  243. ~TestLLSDSerializeData();
  245. void doRoundTripTests(const std::string&);
  246. void checkRoundTrip(const std::string&, const LLSD& v);
  248. LLPointer<LLSDFormatter> mFormatter;
  249. LLPointer<LLSDParser> mParser;
  250. };
  252. TestLLSDSerializeData::TestLLSDSerializeData()
  253. {
  254. }
  256. TestLLSDSerializeData::~TestLLSDSerializeData()
  257. {
  258. }
  260. void TestLLSDSerializeData::checkRoundTrip(const std::string& msg, const LLSD& v)
  261. {
  262. std::stringstream stream;
  263. mFormatter->format(v, stream);
  264. //llinfos << "checkRoundTrip: length " << stream.str().length() << llendl;
  265. LLSD w;
  266. mParser->reset(); // reset() call is needed since test code re-uses mParser
  267. mParser->parse(stream, w, stream.str().size());
  269. try
  270. {
  271. ensure_equals(msg.c_str(), w, v);
  272. }
  273. catch (...)
  274. {
  275. std::cerr << "the serialized string was:" << std::endl;
  276. std::cerr << stream.str() << std::endl;
  277. throw;
  278. }
  279. }
  281. static void fillmap(LLSD& root, U32 width, U32 depth)
  282. {
  283. if(depth == 0)
  284. {
  285. root["foo"] = "bar";
  286. return;
  287. }
  289. for(U32 i = 0; i < width; ++i)
  290. {
  291. std::string key = llformat("child %d", i);
  292. root[key] = LLSD::emptyMap();
  293. fillmap(root[key], width, depth - 1);
  294. }
  295. }
  297. void TestLLSDSerializeData::doRoundTripTests(const std::string& msg)
  298. {
  299. LLSD v;
  300. checkRoundTrip(msg + " undefined", v);
  302. v = true;
  303. checkRoundTrip(msg + " true bool", v);
  305. v = false;
  306. checkRoundTrip(msg + " false bool", v);
  308. v = 1;
  309. checkRoundTrip(msg + " positive int", v);
  311. v = 0;
  312. checkRoundTrip(msg + " zero int", v);
  314. v = -1;
  315. checkRoundTrip(msg + " negative int", v);
  317. v = 1234.5f;
  318. checkRoundTrip(msg + " positive float", v);
  320. v = 0.0f;
  321. checkRoundTrip(msg + " zero float", v);
  323. v = -1234.5f;
  324. checkRoundTrip(msg + " negative float", v);
  326. // FIXME: need a NaN test
  328. v = LLUUID::null;
  329. checkRoundTrip(msg + " null uuid", v);
  331. LLUUID newUUID;
  332. newUUID.generate();
  333. v = newUUID;
  334. checkRoundTrip(msg + " new uuid", v);
  336. v = "";
  337. checkRoundTrip(msg + " empty string", v);
  339. v = "some string";
  340. checkRoundTrip(msg + " non-empty string", v);
  342. v =
  343. "Second Life is a 3-D virtual world entirely built and owned by its residents. "
  344. "Since opening to the public in 2003, it has grown explosively and today is "
  345. "inhabited by nearly 100,000 people from around the globe.n"
  346. "n"
  347. "From the moment you enter the World you'll discover a vast digital continent, "
  348. "teeming with people, entertainment, experiences and opportunity. Once you've "
  349. "explored a bit, perhaps you'll find a perfect parcel of land to build your "
  350. "house or business.n"
  351. "n"
  352. "You'll also be surrounded by the Creations of your fellow residents. Because "
  353. "residents retain the rights to their digital creations, they can buy, sell "
  354. "and trade with other residents.n"
  355. "n"
  356. "The Marketplace currently supports millions of US dollars in monthly "
  357. "transactions. This commerce is handled with the in-world currency, the Linden "
  358. "dollar, which can be converted to US dollars at several thriving online "
  359. "currency exchanges.n"
  360. "n"
  361. "Welcome to Second Life. We look forward to seeing you in-world!n"
  362. ;
  363. checkRoundTrip(msg + " long string", v);
  365. static const U32 block_size = 0x000020;
  366. for (U32 block = 0x000000; block <= 0x10ffff; block += block_size)
  367. {
  368. std::ostringstream out;
  370. for (U32 c = block; c < block + block_size; ++c)
  371. {
  372. if (c <= 0x000001f
  373. && c != 0x000009
  374. && c != 0x00000a)
  375. {
  376. // see XML standard, sections 2.2 and 4.1
  377. continue;
  378. }
  379. if (0x00d800 <= c  &&  c <= 0x00dfff) { continue; }
  380. if (0x00fdd0 <= c  &&  c <= 0x00fdef) { continue; }
  381. if ((c & 0x00fffe) == 0x00fffe) { continue; }
  382. // see Unicode standard, section 15.8 
  384. if (c <= 0x00007f)
  385. {
  386. out << (char)(c & 0x7f);
  387. }
  388. else if (c <= 0x0007ff)
  389. {
  390. out << (char)(0xc0 | ((c >> 6) & 0x1f));
  391. out << (char)(0x80 | ((c >> 0) & 0x3f));
  392. }
  393. else if (c <= 0x00ffff)
  394. {
  395. out << (char)(0xe0 | ((c >> 12) & 0x0f));
  396. out << (char)(0x80 | ((c >>  6) & 0x3f));
  397. out << (char)(0x80 | ((c >>  0) & 0x3f));
  398. }
  399. else
  400. {
  401. out << (char)(0xf0 | ((c >> 18) & 0x07));
  402. out << (char)(0x80 | ((c >> 12) & 0x3f));
  403. out << (char)(0x80 | ((c >>  6) & 0x3f));
  404. out << (char)(0x80 | ((c >>  0) & 0x3f));
  405. }
  406. }
  408. v = out.str();
  410. std::ostringstream blockmsg;
  411. blockmsg << msg << " unicode string block 0x" << std::hex << block; 
  412. checkRoundTrip(blockmsg.str(), v);
  413. }
  415. LLDate epoch;
  416. v = epoch;
  417. checkRoundTrip(msg + " epoch date", v);
  419. LLDate aDay("2002-12-07T05:07:15.00Z");
  420. v = aDay;
  421. checkRoundTrip(msg + " date", v);
  423. LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
  424. v = path;
  425. checkRoundTrip(msg + " url", v);
  427. const char source[] = "it must be a blue moon again";
  428. std::vector<U8> data;
  429. copy(&source[0], &source[sizeof(source)], back_inserter(data));
  431. v = data;
  432. checkRoundTrip(msg + " binary", v);
  434. v = LLSD::emptyMap();
  435. checkRoundTrip(msg + " empty map", v);
  437. v = LLSD::emptyMap();
  438. v["name"] = "luke"; //v.insert("name", "luke");
  439. v["age"] = 3; //v.insert("age", 3);
  440. checkRoundTrip(msg + " map", v);
  442. v.clear();
  443. v["a"]["1"] = true;
  444. v["b"]["0"] = false;
  445. checkRoundTrip(msg + " nested maps", v);
  447. v = LLSD::emptyArray();
  448. checkRoundTrip(msg + " empty array", v);
  450. v = LLSD::emptyArray();
  451. v.append("ali");
  452. v.append(28);
  453. checkRoundTrip(msg + " array", v);
  455. v.clear();
  456. v[0][0] = true;
  457. v[1][0] = false;
  458. checkRoundTrip(msg + " nested arrays", v);
  460. v = LLSD::emptyMap();
  461. fillmap(v, 10, 6); // 10^6 maps
  462. checkRoundTrip(msg + " many nested maps", v);
  463. }
  465. typedef tut::test_group<TestLLSDSerializeData> TestLLSDSerialzeGroup;
  466. typedef TestLLSDSerialzeGroup::object TestLLSDSerializeObject;
  467. TestLLSDSerialzeGroup gTestLLSDSerializeGroup("llsd serialization");
  469. template<> template<> 
  470. void TestLLSDSerializeObject::test<1>()
  471. {
  472. mFormatter = new LLSDNotationFormatter();
  473. mParser = new LLSDNotationParser();
  474. doRoundTripTests("notation serialization");
  475. }
  477. template<> template<> 
  478. void TestLLSDSerializeObject::test<2>()
  479. {
  480. mFormatter = new LLSDXMLFormatter();
  481. mParser = new LLSDXMLParser();
  482. doRoundTripTests("xml serialization");
  483. }
  485. template<> template<> 
  486. void TestLLSDSerializeObject::test<3>()
  487. {
  488. mFormatter = new LLSDBinaryFormatter();
  489. mParser = new LLSDBinaryParser();
  490. doRoundTripTests("binary serialization");
  491. }
  494. /**
  495.  * @class TestLLSDParsing
  496.  * @brief Base class for of a parse tester.
  497.  */
  498. template <class parser_t>
  499. class TestLLSDParsing
  500. {
  501. public:
  502. TestLLSDParsing()
  503. {
  504. mParser = new parser_t;
  505. }
  507. void ensureParse(
  508. const std::string& msg,
  509. const std::string& in,
  510. const LLSD& expected_value,
  511. S32 expected_count)
  512. {
  513. std::stringstream input;
  514. input.str(in);
  516. LLSD parsed_result;
  517. mParser->reset(); // reset() call is needed since test code re-uses mParser
  518. S32 parsed_count = mParser->parse(input, parsed_result, in.size());
  519. ensure_equals(msg.c_str(), parsed_result, expected_value);
  521. // This count check is really only useful for expected
  522. // parse failures, since the ensures equal will already
  523. // require eqality.
  524. std::string count_msg(msg);
  525. count_msg += " (count)";
  526. ensure_equals(count_msg, parsed_count, expected_count);
  527. }
  529. LLPointer<parser_t> mParser;
  530. };
  533. /**
  534.  * @class TestLLSDXMLParsing
  535.  * @brief Concrete instance of a parse tester.
  536.  */
  537. class TestLLSDXMLParsing : public TestLLSDParsing<LLSDXMLParser>
  538. {
  539. public:
  540. TestLLSDXMLParsing() {}
  541. };
  543. typedef tut::test_group<TestLLSDXMLParsing> TestLLSDXMLParsingGroup;
  544. typedef TestLLSDXMLParsingGroup::object TestLLSDXMLParsingObject;
  545. TestLLSDXMLParsingGroup gTestLLSDXMLParsingGroup("llsd XML parsing");
  547. template<> template<> 
  548. void TestLLSDXMLParsingObject::test<1>()
  549. {
  550. // test handling of xml not recognized as llsd results in an
  551. // LLSD Undefined
  552. ensureParse(
  553. "malformed xml",
  554. "<llsd><string>ha ha</string>",
  555. LLSD(),
  556. LLSDParser::PARSE_FAILURE);
  557. ensureParse(
  558. "not llsd",
  559. "<html><body><p>ha ha</p></body></html>",
  560. LLSD(),
  561. LLSDParser::PARSE_FAILURE);
  562. ensureParse(
  563. "value without llsd",
  564. "<string>ha ha</string>",
  565. LLSD(),
  566. LLSDParser::PARSE_FAILURE);
  567. ensureParse(
  568. "key without llsd",
  569. "<key>ha ha</key>",
  570. LLSD(),
  571. LLSDParser::PARSE_FAILURE);
  572. }
  575. template<> template<> 
  576. void TestLLSDXMLParsingObject::test<2>()
  577. {
  578. // test handling of unrecognized or unparseable llsd values
  579. LLSD v;
  580. v["amy"] = 23;
  581. v["bob"] = LLSD();
  582. v["cam"] = 1.23;
  584. ensureParse(
  585. "unknown data type",
  586. "<llsd><map>"
  587. "<key>amy</key><integer>23</integer>"
  588. "<key>bob</key><bigint>99999999999999999</bigint>"
  589. "<key>cam</key><real>1.23</real>"
  590. "</map></llsd>",
  591. v,
  592. v.size() + 1);
  593. }
  595. template<> template<> 
  596. void TestLLSDXMLParsingObject::test<3>()
  597. {
  598. // test handling of nested bad data
  600. LLSD v;
  601. v["amy"] = 23;
  602. v["cam"] = 1.23;
  604. ensureParse(
  605. "map with html",
  606. "<llsd><map>"
  607. "<key>amy</key><integer>23</integer>"
  608. "<html><body>ha ha</body></html>"
  609. "<key>cam</key><real>1.23</real>"
  610. "</map></llsd>",
  611. v,
  612. v.size() + 1);
  614. v.clear();
  615. v["amy"] = 23;
  616. v["cam"] = 1.23;
  617. ensureParse(
  618. "map with value for key",
  619. "<llsd><map>"
  620. "<key>amy</key><integer>23</integer>"
  621. "<string>ha ha</string>"
  622. "<key>cam</key><real>1.23</real>"
  623. "</map></llsd>",
  624. v,
  625. v.size() + 1);
  627. v.clear();
  628. v["amy"] = 23;
  629. v["bob"] = LLSD::emptyMap();
  630. v["cam"] = 1.23;
  631. ensureParse(
  632. "map with map of html",
  633. "<llsd><map>"
  634. "<key>amy</key><integer>23</integer>"
  635. "<key>bob</key>"
  636. "<map>"
  637. "<html><body>ha ha</body></html>"
  638. "</map>"
  639. "<key>cam</key><real>1.23</real>"
  640. "</map></llsd>",
  641. v,
  642. v.size() + 1);
  644. v.clear();
  645. v[0] = 23;
  646. v[1] = LLSD();
  647. v[2] = 1.23;
  649. ensureParse(
  650. "array value of html",
  651. "<llsd><array>"
  652. "<integer>23</integer>"
  653. "<html><body>ha ha</body></html>"
  654. "<real>1.23</real>"
  655. "</array></llsd>",
  656. v,
  657. v.size() + 1);
  659. v.clear();
  660. v[0] = 23;
  661. v[1] = LLSD::emptyMap();
  662. v[2] = 1.23;
  663. ensureParse(
  664. "array with map of html",
  665. "<llsd><array>"
  666. "<integer>23</integer>"
  667. "<map>"
  668. "<html><body>ha ha</body></html>"
  669. "</map>"
  670. "<real>1.23</real>"
  671. "</array></llsd>",
  672. v,
  673. v.size() + 1);
  674. }
  676. template<> template<> 
  677. void TestLLSDXMLParsingObject::test<4>()
  678. {
  679. // test handling of binary object in XML
  680. std::string xml;
  681. LLSD expected;
  683. // Generated by: echo -n 'hello' | openssl enc -e -base64
  684. expected = string_to_vector("hello");
  685. xml = "<llsd><binary encoding="base64">aGVsbG8=</binary></llsd>n";
  686. ensureParse(
  687. "the word 'hello' packed in binary encoded base64",
  688. xml,
  689. expected,
  690. 1);
  692. expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
  693. xml = "<llsd><binary encoding="base64">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBlNDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyOXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>n";
  694. ensureParse(
  695. "a common binary blob for object -> agent offline inv transfer",
  696. xml,
  697. expected,
  698. 1);
  700. expected = string_to_vector("6|6|asdfhappybox|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|60e44ec5-305c-43c2-9a19-b4b89b1ae2a6|00000000-0000-0000-0000-000000000000|7fffffff|7fffffff|0|0|82000|450fe394-2904-c9ad-214c-a07eb7feec29|(No Description)|0|10|0");
  701. xml = "<llsd><binary encoding="base64">Nnw2fGFzZGZoYXBweWJveHw2MGU0NGVjNS0zMDVjLTQzYzItOWExOS1iNGI4OWIxYWUyYTZ8NjBln";
  702. xml += "NDRlYzUtMzA1Yy00M2MyLTlhMTktYjRiODliMWFlMmE2fDYwZTQ0ZWM1LTMwNWMtNDNjMi05YTE5n";
  703. xml += "LWI0Yjg5YjFhZTJhNnwwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDB8N2ZmZmZmn";
  704. xml += "ZmZ8N2ZmZmZmZmZ8MHwwfDgyMDAwfDQ1MGZlMzk0LTI5MDQtYzlhZC0yMTRjLWEwN2ViN2ZlZWMyn";
  705. xml += "OXwoTm8gRGVzY3JpcHRpb24pfDB8MTB8MA==</binary></llsd>n";
  706. ensureParse(
  707. "a common binary blob for object -> agent offline inv transfer",
  708. xml,
  709. expected,
  710. 1);
  711. }
  712. /*
  713. TODO:
  714. test XML parsing
  715. binary with unrecognized encoding
  716. nested LLSD tags
  717. multiple values inside an LLSD
  718. */
  721. /**
  722.  * @class TestLLSDNotationParsing
  723.  * @brief Concrete instance of a parse tester.
  724.  */
  725. class TestLLSDNotationParsing : public TestLLSDParsing<LLSDNotationParser>
  726. {
  727. public:
  728. TestLLSDNotationParsing() {}
  729. };
  731. typedef tut::test_group<TestLLSDNotationParsing> TestLLSDNotationParsingGroup;
  732. typedef TestLLSDNotationParsingGroup::object TestLLSDNotationParsingObject;
  733. TestLLSDNotationParsingGroup gTestLLSDNotationParsingGroup(
  734. "llsd notation parsing");
  736. template<> template<> 
  737. void TestLLSDNotationParsingObject::test<1>()
  738. {
  739. // test handling of xml not recognized as llsd results in an
  740. // LLSD Undefined
  741. ensureParse(
  742. "malformed notation map",
  743. "{'ha ha'",
  744. LLSD(),
  745. LLSDParser::PARSE_FAILURE);
  746. ensureParse(
  747. "malformed notation array",
  748. "['ha ha'",
  749. LLSD(),
  750. LLSDParser::PARSE_FAILURE);
  751. ensureParse(
  752. "malformed notation string",
  753. "'ha ha",
  754. LLSD(),
  755. LLSDParser::PARSE_FAILURE);
  756. ensureParse(
  757. "bad notation noise",
  758. "g48ejlnfr",
  759. LLSD(),
  760. LLSDParser::PARSE_FAILURE);
  761. }
  763. template<> template<> 
  764. void TestLLSDNotationParsingObject::test<2>()
  765. {
  766. ensureParse("valid undef", "!", LLSD(), 1);
  767. }
  769. template<> template<> 
  770. void TestLLSDNotationParsingObject::test<3>()
  771. {
  772. LLSD val = false;
  773. ensureParse("valid boolean false 0", "false", val, 1);
  774. ensureParse("valid boolean false 1", "f", val, 1);
  775. ensureParse("valid boolean false 2", "0", val, 1);
  776. ensureParse("valid boolean false 3", "F", val, 1);
  777. ensureParse("valid boolean false 4", "FALSE", val, 1);
  778. val = true;
  779. ensureParse("valid boolean true 0", "true", val, 1);
  780. ensureParse("valid boolean true 1", "t", val, 1);
  781. ensureParse("valid boolean true 2", "1", val, 1);
  782. ensureParse("valid boolean true 3", "T", val, 1);
  783. ensureParse("valid boolean true 4", "TRUE", val, 1);
  785. val.clear();
  786. ensureParse("invalid true", "TR", val, LLSDParser::PARSE_FAILURE);
  787. ensureParse("invalid false", "FAL", val, LLSDParser::PARSE_FAILURE);
  788. }
  790. template<> template<> 
  791. void TestLLSDNotationParsingObject::test<4>()
  792. {
  793. LLSD val = 123;
  794. ensureParse("valid integer", "i123", val, 1);
  795. val.clear();
  796. ensureParse("invalid integer", "421", val, LLSDParser::PARSE_FAILURE);
  797. }
  799. template<> template<> 
  800. void TestLLSDNotationParsingObject::test<5>()
  801. {
  802. LLSD val = 456.7;
  803. ensureParse("valid real", "r456.7", val, 1);
  804. val.clear();
  805. ensureParse("invalid real", "456.7", val, LLSDParser::PARSE_FAILURE);
  806. }
  808. template<> template<> 
  809. void TestLLSDNotationParsingObject::test<6>()
  810. {
  811. LLUUID id;
  812. LLSD val = id;
  813. ensureParse(
  814. "unparseable uuid",
  815. "u123",
  816. LLSD(),
  817. LLSDParser::PARSE_FAILURE);
  818. id.generate();
  819. val = id;
  820. std::string uuid_str("u");
  821. uuid_str += id.asString();
  822. ensureParse("valid uuid", uuid_str.c_str(), val, 1);
  823. }
  825. template<> template<> 
  826. void TestLLSDNotationParsingObject::test<7>()
  827. {
  828. LLSD val = std::string("foolish");
  829. ensureParse("valid string 1", ""foolish"", val, 1);
  830. val = std::string("g'day");
  831. ensureParse("valid string 2", ""g'day"", val, 1);
  832. val = std::string("have a "nice" day");
  833. ensureParse("valid string 3", "'have a "nice" day'", val, 1);
  834. val = std::string("whatever");
  835. ensureParse("valid string 4", "s(8)"whatever"", val, 1);
  836. }
  838. template<> template<> 
  839. void TestLLSDNotationParsingObject::test<8>()
  840. {
  841. ensureParse(
  842. "invalid string 1",
  843. "s(7)"whatever"",
  844. LLSD(),
  845. LLSDParser::PARSE_FAILURE);
  846. ensureParse(
  847. "invalid string 2",
  848. "s(9)"whatever"",
  849. LLSD(),
  850. LLSDParser::PARSE_FAILURE);
  851. }
  853. template<> template<> 
  854. void TestLLSDNotationParsingObject::test<9>()
  855. {
  856. LLSD val = LLURI("http://www.google.com");
  857. ensureParse("valid uri", "l"http://www.google.com"", val, 1);
  858. }
  860. template<> template<> 
  861. void TestLLSDNotationParsingObject::test<10>()
  862. {
  863. LLSD val = LLDate("2007-12-28T09:22:53.10Z");
  864. ensureParse("valid date", "d"2007-12-28T09:22:53.10Z"", val, 1);
  865. }
  867. template<> template<> 
  868. void TestLLSDNotationParsingObject::test<11>()
  869. {
  870. std::vector<U8> vec;
  871. vec.push_back((U8)'a'); vec.push_back((U8)'b'); vec.push_back((U8)'c');
  872. vec.push_back((U8)'3'); vec.push_back((U8)'2'); vec.push_back((U8)'1');
  873. LLSD val = vec;
  874. ensureParse("valid binary b64", "b64"YWJjMzIx"", val, 1);
  875. ensureParse("valid bainry b16", "b16"616263333231"", val, 1);
  876. ensureParse("valid bainry raw", "b(6)"abc321"", val, 1);
  877. }
  879. template<> template<> 
  880. void TestLLSDNotationParsingObject::test<12>()
  881. {
  882. ensureParse(
  883. "invalid -- binary length specified too long",
  884. "b(7)"abc321"",
  885. LLSD(),
  886. LLSDParser::PARSE_FAILURE);
  887. ensureParse(
  888. "invalid -- binary length specified way too long",
  889. "b(1000000)"abc321"",
  890. LLSD(),
  891. LLSDParser::PARSE_FAILURE);
  892. }
  894. template<> template<> 
  895. void TestLLSDNotationParsingObject::test<13>()
  896. {
  897. LLSD val;
  898. val["amy"] = 23;
  899. val["bob"] = LLSD();
  900. val["cam"] = 1.23;
  901. ensureParse("simple map", "{'amy':i23,'bob':!,'cam':r1.23}", val, 4);
  903. val["bob"] = LLSD::emptyMap();
  904. val["bob"]["vehicle"] = std::string("bicycle");
  905. ensureParse(
  906. "nested map",
  907. "{'amy':i23,'bob':{'vehicle':'bicycle'},'cam':r1.23}",
  908. val,
  909. 5);
  910. }
  912. template<> template<> 
  913. void TestLLSDNotationParsingObject::test<14>()
  914. {
  915. LLSD val;
  916. val.append(23);
  917. val.append(LLSD());
  918. val.append(1.23);
  919. ensureParse("simple array", "[i23,!,r1.23]", val, 4);
  920. val[1] = LLSD::emptyArray();
  921. val[1].append("bicycle");
  922. ensureParse("nested array", "[i23,['bicycle'],r1.23]", val, 5);
  923. }
  925. template<> template<> 
  926. void TestLLSDNotationParsingObject::test<15>()
  927. {
  928. LLSD val;
  929. val["amy"] = 23;
  930. val["bob"]["dogs"] = LLSD::emptyArray();
  931. val["bob"]["dogs"].append(LLSD::emptyMap());
  932. val["bob"]["dogs"][0]["name"] = std::string("groove");
  933. val["bob"]["dogs"][0]["breed"] = std::string("samoyed");
  934. val["bob"]["dogs"].append(LLSD::emptyMap());
  935. val["bob"]["dogs"][1]["name"] = std::string("greyley");
  936. val["bob"]["dogs"][1]["breed"] = std::string("chow/husky");
  937. val["cam"] = 1.23;
  938. ensureParse(
  939. "nested notation",
  940. "{'amy':i23,"
  941. " 'bob':{'dogs':["
  942.          "{'name':'groove', 'breed':'samoyed'},"
  943.          "{'name':'greyley', 'breed':'chow/husky'}]},"
  944. " 'cam':r1.23}",
  945. val,
  946. 11);
  947. }
  949. template<> template<> 
  950. void TestLLSDNotationParsingObject::test<16>()
  951. {
  952. // text to make sure that incorrect sizes bail because 
  953. std::string bad_str("s(5)"hi"");
  954. ensureParse(
  955. "size longer than bytes left",
  956. bad_str,
  957. LLSD(),
  958. LLSDParser::PARSE_FAILURE);
  959. }
  961. template<> template<> 
  962. void TestLLSDNotationParsingObject::test<17>()
  963. {
  964. // text to make sure that incorrect sizes bail because 
  965. std::string bad_bin("b(5)"hi"");
  966. ensureParse(
  967. "size longer than bytes left",
  968. bad_bin,
  969. LLSD(),
  970. LLSDParser::PARSE_FAILURE);
  971. }
  973. /**
  974.  * @class TestLLSDBinaryParsing
  975.  * @brief Concrete instance of a parse tester.
  976.  */
  977. class TestLLSDBinaryParsing : public TestLLSDParsing<LLSDBinaryParser>
  978. {
  979. public:
  980. TestLLSDBinaryParsing() {}
  981. };
  983. typedef tut::test_group<TestLLSDBinaryParsing> TestLLSDBinaryParsingGroup;
  984. typedef TestLLSDBinaryParsingGroup::object TestLLSDBinaryParsingObject;
  985. TestLLSDBinaryParsingGroup gTestLLSDBinaryParsingGroup(
  986. "llsd binary parsing");
  988. template<> template<> 
  989. void TestLLSDBinaryParsingObject::test<1>()
  990. {
  991. std::vector<U8> vec;
  992. vec.resize(6);
  993. vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c';
  994. vec[3] = '3'; vec[4] = '2'; vec[5] = '1';
  995. std::string string_expected((char*)&vec[0], vec.size());
  996. LLSD value = string_expected;
  998. vec.resize(11);
  999. vec[0] = 's'; // for string
  1000. vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c';
  1001. vec[8] = '3'; vec[9] = '2'; vec[10] = '1';
  1003. uint32_t size = htonl(6);
  1004. memcpy(&vec[1], &size, sizeof(uint32_t));
  1005. std::string str_good((char*)&vec[0], vec.size());
  1006. ensureParse("correct string parse", str_good, value, 1);
  1008. size = htonl(7);
  1009. memcpy(&vec[1], &size, sizeof(uint32_t));
  1010. std::string str_bad_1((char*)&vec[0], vec.size());
  1011. ensureParse(
  1012. "incorrect size string parse",
  1013. str_bad_1,
  1014. LLSD(),
  1015. LLSDParser::PARSE_FAILURE);
  1017. size = htonl(100000);
  1018. memcpy(&vec[1], &size, sizeof(uint32_t));
  1019. std::string str_bad_2((char*)&vec[0], vec.size());
  1020. ensureParse(
  1021. "incorrect size string parse",
  1022. str_bad_2,
  1023. LLSD(),
  1024. LLSDParser::PARSE_FAILURE);
  1025. }
  1027. template<> template<> 
  1028. void TestLLSDBinaryParsingObject::test<2>()
  1029. {
  1030. std::vector<U8> vec;
  1031. vec.resize(6);
  1032. vec[0] = 'a'; vec[1] = 'b'; vec[2] = 'c';
  1033. vec[3] = '3'; vec[4] = '2'; vec[5] = '1';
  1034. LLSD value = vec;
  1036. vec.resize(11);
  1037. vec[0] = 'b';  // for binary
  1038. vec[5] = 'a'; vec[6] = 'b'; vec[7] = 'c';
  1039. vec[8] = '3'; vec[9] = '2'; vec[10] = '1';
  1041. uint32_t size = htonl(6);
  1042. memcpy(&vec[1], &size, sizeof(uint32_t));
  1043. std::string str_good((char*)&vec[0], vec.size());
  1044. ensureParse("correct binary parse", str_good, value, 1);
  1046. size = htonl(7);
  1047. memcpy(&vec[1], &size, sizeof(uint32_t));
  1048. std::string str_bad_1((char*)&vec[0], vec.size());
  1049. ensureParse(
  1050. "incorrect size binary parse 1",
  1051. str_bad_1,
  1052. LLSD(),
  1053. LLSDParser::PARSE_FAILURE);
  1055. size = htonl(100000);
  1056. memcpy(&vec[1], &size, sizeof(uint32_t));
  1057. std::string str_bad_2((char*)&vec[0], vec.size());
  1058. ensureParse(
  1059. "incorrect size binary parse 2",
  1060. str_bad_2,
  1061. LLSD(),
  1062. LLSDParser::PARSE_FAILURE);
  1063. }
  1065. template<> template<> 
  1066. void TestLLSDBinaryParsingObject::test<3>()
  1067. {
  1068. // test handling of xml not recognized as llsd results in an
  1069. // LLSD Undefined
  1070. ensureParse(
  1071. "malformed binary map",
  1072. "{'ha ha'",
  1073. LLSD(),
  1074. LLSDParser::PARSE_FAILURE);
  1075. ensureParse(
  1076. "malformed binary array",
  1077. "['ha ha'",
  1078. LLSD(),
  1079. LLSDParser::PARSE_FAILURE);
  1080. ensureParse(
  1081. "malformed binary string",
  1082. "'ha ha",
  1083. LLSD(),
  1084. LLSDParser::PARSE_FAILURE);
  1085. ensureParse(
  1086. "bad noise",
  1087. "g48ejlnfr",
  1088. LLSD(),
  1089. LLSDParser::PARSE_FAILURE);
  1090. }
  1091. template<> template<> 
  1092. void TestLLSDBinaryParsingObject::test<4>()
  1093. {
  1094. ensureParse("valid undef", "!", LLSD(), 1);
  1095. }
  1097. template<> template<> 
  1098. void TestLLSDBinaryParsingObject::test<5>()
  1099. {
  1100. LLSD val = false;
  1101. ensureParse("valid boolean false 2", "0", val, 1);
  1102. val = true;
  1103. ensureParse("valid boolean true 2", "1", val, 1);
  1105. val.clear();
  1106. ensureParse("invalid true", "t", val, LLSDParser::PARSE_FAILURE);
  1107. ensureParse("invalid false", "f", val, LLSDParser::PARSE_FAILURE);
  1108. }
  1110. template<> template<> 
  1111. void TestLLSDBinaryParsingObject::test<6>()
  1112. {
  1113. std::vector<U8> vec;
  1114. vec.push_back('{');
  1115. vec.resize(vec.size() + 4);
  1116. uint32_t size = htonl(1);
  1117. memcpy(&vec[1], &size, sizeof(uint32_t));
  1118. vec.push_back('k');
  1119. int key_size_loc = vec.size();
  1120. size = htonl(1); // 1 too short
  1121. vec.resize(vec.size() + 4);
  1122. memcpy(&vec[key_size_loc], &size, sizeof(uint32_t));
  1123. vec.push_back('a'); vec.push_back('m'); vec.push_back('y');
  1124. vec.push_back('i');
  1125. int integer_loc = vec.size();
  1126. vec.resize(vec.size() + 4);
  1127. uint32_t val_int = htonl(23);
  1128. memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t));
  1129. std::string str_bad_1((char*)&vec[0], vec.size());
  1130. ensureParse(
  1131. "invalid key size",
  1132. str_bad_1,
  1133. LLSD(),
  1134. LLSDParser::PARSE_FAILURE);
  1136. // check with correct size, but unterminated map (missing '}')
  1137. size = htonl(3); // correct size
  1138. memcpy(&vec[key_size_loc], &size, sizeof(uint32_t));
  1139. std::string str_bad_2((char*)&vec[0], vec.size());
  1140. ensureParse(
  1141. "valid key size, unterminated map",
  1142. str_bad_2,
  1143. LLSD(),
  1144. LLSDParser::PARSE_FAILURE);
  1146. // check w/ correct size and correct map termination
  1147. LLSD val;
  1148. val["amy"] = 23;
  1149. vec.push_back('}');
  1150. std::string str_good((char*)&vec[0], vec.size());
  1151. ensureParse(
  1152. "valid map",
  1153. str_good,
  1154. val,
  1155. 2);
  1157. // check w/ incorrect sizes and correct map termination
  1158. size = htonl(0); // 1 too few (for the map entry)
  1159. memcpy(&vec[1], &size, sizeof(uint32_t));
  1160. std::string str_bad_3((char*)&vec[0], vec.size());
  1161. ensureParse(
  1162. "invalid map too long",
  1163. str_bad_3,
  1164. LLSD(),
  1165. LLSDParser::PARSE_FAILURE);
  1167. size = htonl(2); // 1 too many
  1168. memcpy(&vec[1], &size, sizeof(uint32_t));
  1169. std::string str_bad_4((char*)&vec[0], vec.size());
  1170. ensureParse(
  1171. "invalid map too short",
  1172. str_bad_4,
  1173. LLSD(),
  1174. LLSDParser::PARSE_FAILURE);
  1175. }
  1177. template<> template<> 
  1178. void TestLLSDBinaryParsingObject::test<7>()
  1179. {
  1180. std::vector<U8> vec;
  1181. vec.push_back('[');
  1182. vec.resize(vec.size() + 4);
  1183. uint32_t size = htonl(1); // 1 too short
  1184. memcpy(&vec[1], &size, sizeof(uint32_t));
  1185. vec.push_back('"'); vec.push_back('a'); vec.push_back('m');
  1186. vec.push_back('y'); vec.push_back('"'); vec.push_back('i');
  1187. int integer_loc = vec.size();
  1188. vec.resize(vec.size() + 4);
  1189. uint32_t val_int = htonl(23);
  1190. memcpy(&vec[integer_loc], &val_int, sizeof(uint32_t));
  1192. std::string str_bad_1((char*)&vec[0], vec.size());
  1193. ensureParse(
  1194. "invalid array size",
  1195. str_bad_1,
  1196. LLSD(),
  1197. LLSDParser::PARSE_FAILURE);
  1199. // check with correct size, but unterminated map (missing ']')
  1200. size = htonl(2); // correct size
  1201. memcpy(&vec[1], &size, sizeof(uint32_t));
  1202. std::string str_bad_2((char*)&vec[0], vec.size());
  1203. ensureParse(
  1204. "unterminated array",
  1205. str_bad_2,
  1206. LLSD(),
  1207. LLSDParser::PARSE_FAILURE);
  1209. // check w/ correct size and correct map termination
  1210. LLSD val;
  1211. val.append("amy");
  1212. val.append(23);
  1213. vec.push_back(']');
  1214. std::string str_good((char*)&vec[0], vec.size());
  1215. ensureParse(
  1216. "valid array",
  1217. str_good,
  1218. val,
  1219. 3);
  1221. // check with too many elements
  1222. size = htonl(3); // 1 too long
  1223. memcpy(&vec[1], &size, sizeof(uint32_t));
  1224. std::string str_bad_3((char*)&vec[0], vec.size());
  1225. ensureParse(
  1226. "array too short",
  1227. str_bad_3,
  1228. LLSD(),
  1229. LLSDParser::PARSE_FAILURE);
  1230. }
  1232. template<> template<> 
  1233. void TestLLSDBinaryParsingObject::test<8>()
  1234. {
  1235. std::vector<U8> vec;
  1236. vec.push_back('{');
  1237. vec.resize(vec.size() + 4);
  1238. memset(&vec[1], 0, 4);
  1239. vec.push_back('}');
  1240. std::string str_good((char*)&vec[0], vec.size());
  1241. LLSD val = LLSD::emptyMap();
  1242. ensureParse(
  1243. "empty map",
  1244. str_good,
  1245. val,
  1246. 1);
  1247. }
  1249. template<> template<> 
  1250. void TestLLSDBinaryParsingObject::test<9>()
  1251. {
  1252. std::vector<U8> vec;
  1253. vec.push_back('[');
  1254. vec.resize(vec.size() + 4);
  1255. memset(&vec[1], 0, 4);
  1256. vec.push_back(']');
  1257. std::string str_good((char*)&vec[0], vec.size());
  1258. LLSD val = LLSD::emptyArray();
  1259. ensureParse(
  1260. "empty array",
  1261. str_good,
  1262. val,
  1263. 1);
  1264. }
  1266. template<> template<> 
  1267. void TestLLSDBinaryParsingObject::test<10>()
  1268. {
  1269. std::vector<U8> vec;
  1270. vec.push_back('l');
  1271. vec.resize(vec.size() + 4);
  1272. uint32_t size = htonl(14); // 1 too long
  1273. memcpy(&vec[1], &size, sizeof(uint32_t));
  1274. vec.push_back('h'); vec.push_back('t'); vec.push_back('t');
  1275. vec.push_back('p'); vec.push_back(':'); vec.push_back('/');
  1276. vec.push_back('/'); vec.push_back('s'); vec.push_back('l');
  1277. vec.push_back('.'); vec.push_back('c'); vec.push_back('o');
  1278. vec.push_back('m');
  1279. std::string str_bad((char*)&vec[0], vec.size());
  1280. ensureParse(
  1281. "invalid uri length size",
  1282. str_bad,
  1283. LLSD(),
  1284. LLSDParser::PARSE_FAILURE);
  1286. LLSD val;
  1287. val = LLURI("http://sl.com");
  1288. size = htonl(13); // correct length
  1289. memcpy(&vec[1], &size, sizeof(uint32_t));
  1290. std::string str_good((char*)&vec[0], vec.size());
  1291. ensureParse(
  1292. "valid key size",
  1293. str_good,
  1294. val,
  1295. 1);
  1296. }
  1298. /*
  1299. template<> template<> 
  1300. void TestLLSDBinaryParsingObject::test<11>()
  1301. {
  1302. }
  1303. */
  1305.    /**
  1306.  * @class TestLLSDCrossCompatible
  1307.  * @brief Miscellaneous serialization and parsing tests
  1308.  */
  1309. class TestLLSDCrossCompatible
  1310. {
  1311. public:
  1312. TestLLSDCrossCompatible() {}
  1314. void ensureBinaryAndNotation(
  1315. const std::string& msg,
  1316. const LLSD& input)
  1317. {
  1318. // to binary, and back again
  1319. std::stringstream str1;
  1320. S32 count1 = LLSDSerialize::toBinary(input, str1);
  1321. LLSD actual_value_bin;
  1322. S32 count2 = LLSDSerialize::fromBinary(
  1323. actual_value_bin,
  1324. str1,
  1325. LLSDSerialize::SIZE_UNLIMITED);
  1326. ensure_equals(
  1327. "ensureBinaryAndNotation binary count",
  1328. count2,
  1329. count1);
  1331. // to notation and back again
  1332. std::stringstream str2;
  1333. S32 count3 = LLSDSerialize::toNotation(actual_value_bin, str2);
  1334. ensure_equals(
  1335. "ensureBinaryAndNotation notation count1",
  1336. count3,
  1337. count2);
  1338. LLSD actual_value_notation;
  1339. S32 count4 = LLSDSerialize::fromNotation(
  1340. actual_value_notation,
  1341. str2,
  1342. LLSDSerialize::SIZE_UNLIMITED);
  1343. ensure_equals(
  1344. "ensureBinaryAndNotation notation count2",
  1345. count4,
  1346. count3);
  1347. ensure_equals(
  1348. (msg + " (binaryandnotation)").c_str(),
  1349. actual_value_notation,
  1350. input);
  1351. }
  1353. void ensureBinaryAndXML(
  1354. const std::string& msg,
  1355. const LLSD& input)
  1356. {
  1357. // to binary, and back again
  1358. std::stringstream str1;
  1359. S32 count1 = LLSDSerialize::toBinary(input, str1);
  1360. LLSD actual_value_bin;
  1361. S32 count2 = LLSDSerialize::fromBinary(
  1362. actual_value_bin,
  1363. str1,
  1364. LLSDSerialize::SIZE_UNLIMITED);
  1365. ensure_equals(
  1366. "ensureBinaryAndXML binary count",
  1367. count2,
  1368. count1);
  1370. // to xml and back again
  1371. std::stringstream str2;
  1372. S32 count3 = LLSDSerialize::toXML(actual_value_bin, str2);
  1373. ensure_equals(
  1374. "ensureBinaryAndXML xml count1",
  1375. count3,
  1376. count2);
  1377. LLSD actual_value_xml;
  1378. S32 count4 = LLSDSerialize::fromXML(actual_value_xml, str2);
  1379. ensure_equals(
  1380. "ensureBinaryAndXML xml count2",
  1381. count4,
  1382. count3);
  1383. ensure_equals((msg + " (binaryandxml)").c_str(), actual_value_xml, input);
  1384. }
  1385. };
  1387. typedef tut::test_group<TestLLSDCrossCompatible> TestLLSDCompatibleGroup;
  1388. typedef TestLLSDCompatibleGroup::object TestLLSDCompatibleObject;
  1389. TestLLSDCompatibleGroup gTestLLSDCompatibleGroup(
  1390. "llsd serialize compatible");
  1392. template<> template<> 
  1393. void TestLLSDCompatibleObject::test<1>()
  1394. {
  1395. LLSD test;
  1396. ensureBinaryAndNotation("undef", test);
  1397. ensureBinaryAndXML("undef", test);
  1398. test = true;
  1399. ensureBinaryAndNotation("boolean true", test);
  1400. ensureBinaryAndXML("boolean true", test);
  1401. test = false;
  1402. ensureBinaryAndNotation("boolean false", test);
  1403. ensureBinaryAndXML("boolean false", test);
  1404. test = 0;
  1405. ensureBinaryAndNotation("integer zero", test);
  1406. ensureBinaryAndXML("integer zero", test);
  1407. test = 1;
  1408. ensureBinaryAndNotation("integer positive", test);
  1409. ensureBinaryAndXML("integer positive", test);
  1410. test = -234567;
  1411. ensureBinaryAndNotation("integer negative", test);
  1412. ensureBinaryAndXML("integer negative", test);
  1413. test = 0.0;
  1414. ensureBinaryAndNotation("real zero", test);
  1415. ensureBinaryAndXML("real zero", test);
  1416. test = 1.0;
  1417. ensureBinaryAndNotation("real positive", test);
  1418. ensureBinaryAndXML("real positive", test);
  1419. test = -1.0;
  1420. ensureBinaryAndNotation("real negative", test);
  1421. ensureBinaryAndXML("real negative", test);
  1422. }
  1424. template<> template<> 
  1425. void TestLLSDCompatibleObject::test<2>()
  1426. {
  1427. LLSD test;
  1428. test = "foobar";
  1429. ensureBinaryAndNotation("string", test);
  1430. ensureBinaryAndXML("string", test);
  1431. }
  1433. template<> template<> 
  1434. void TestLLSDCompatibleObject::test<3>()
  1435. {
  1436. LLSD test;
  1437. LLUUID id;
  1438. id.generate();
  1439. test = id;
  1440. ensureBinaryAndNotation("uuid", test);
  1441. ensureBinaryAndXML("uuid", test);
  1442. }
  1444. template<> template<> 
  1445. void TestLLSDCompatibleObject::test<4>()
  1446. {
  1447. LLSD test;
  1448. test = LLDate(12345.0);
  1449. ensureBinaryAndNotation("date", test);
  1450. ensureBinaryAndXML("date", test);
  1451. }
  1453. template<> template<> 
  1454. void TestLLSDCompatibleObject::test<5>()
  1455. {
  1456. LLSD test;
  1457. test = LLURI("http://www.secondlife.com/");
  1458. ensureBinaryAndNotation("uri", test);
  1459. ensureBinaryAndXML("uri", test);
  1460. }
  1462. template<> template<> 
  1463. void TestLLSDCompatibleObject::test<6>()
  1464. {
  1465. LLSD test;
  1466. typedef std::vector<U8> buf_t;
  1467. buf_t val;
  1468. for(int ii = 0; ii < 100; ++ii)
  1469. {
  1470. srand(ii); /* Flawfinder: ignore */
  1471. S32 size = rand() % 100 + 10;
  1472. std::generate_n(
  1473. std::back_insert_iterator<buf_t>(val),
  1474. size,
  1475. rand);
  1476. }
  1477. test = val;
  1478. ensureBinaryAndNotation("binary", test);
  1479. ensureBinaryAndXML("binary", test);
  1480. }
  1482. template<> template<> 
  1483. void TestLLSDCompatibleObject::test<7>()
  1484. {
  1485. LLSD test;
  1486. test = LLSD::emptyArray();
  1487. test.append(1);
  1488. test.append("hello");
  1489. ensureBinaryAndNotation("array", test);
  1490. ensureBinaryAndXML("array", test);
  1491. }
  1493. template<> template<> 
  1494. void TestLLSDCompatibleObject::test<8>()
  1495. {
  1496. LLSD test;
  1497. test = LLSD::emptyArray();
  1498. test["foo"] = "bar";
  1499. test["baz"] = 100;
  1500. ensureBinaryAndNotation("map", test);
  1501. ensureBinaryAndXML("map", test);
  1502. }
  1503. }