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

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

游戏引擎

开发平台：

C++ Builder

llsd_new_tut.cpp：源码内容
  1. /** 
  2.  * @file llsd_new_tut.cpp
  3.  * @date   February 2006
  4.  * @brief LLSD 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. #include <tut/tut.hpp>
  35. #include "linden_common.h"
  36. #include "lltut.h"
  38. #include "llsdtraits.h"
  39. #include "llstring.h"
  41. namespace tut
  42. {
  43. class SDCleanupCheck
  44. {
  45. private:
  46. U32 mOutstandingAtStart;
  47. public:
  48. SDCleanupCheck() : mOutstandingAtStart(LLSD::outstandingCount()) { }
  49. ~SDCleanupCheck()
  50. {
  51. ensure_equals("SDCleanupCheck",
  52. LLSD::outstandingCount(), mOutstandingAtStart);
  53. }
  54. };
  56. class SDAllocationCheck : public SDCleanupCheck
  57. {
  58. private:
  59. std::string mMessage;
  60. U32 mExpectedAllocations;
  61. U32 mAllocationAtStart;
  62. public:
  63. SDAllocationCheck(const std::string& message, int expectedAllocations)
  64. : mMessage(message),
  65. mExpectedAllocations(expectedAllocations),
  66. mAllocationAtStart(LLSD::allocationCount())
  67. { }
  68. ~SDAllocationCheck()
  69. {
  70. ensure_equals(mMessage + " SDAllocationCheck",
  71. LLSD::allocationCount() - mAllocationAtStart,
  72. mExpectedAllocations);
  73. }
  74. };
  76. struct SDTestData {
  77. template<class T>
  78. static void ensureTypeAndValue(const char* msg, const LLSD& actual,
  79. T expectedValue)
  80. {
  81. LLSDTraits<T> traits;
  83. std::string s(msg);
  85. ensure( s + " type", traits.checkType(actual));
  86. ensure_equals( s + " value", traits.get(actual), expectedValue);
  87. }
  88. };
  90. typedef test_group<SDTestData> SDTestGroup;
  91. typedef SDTestGroup::object SDTestObject;
  93. SDTestGroup sdTestGroup("LLSD(new)");
  95. template<> template<>
  96. void SDTestObject::test<1>()
  97. // construction and test of undefined
  98. {
  99. SDCleanupCheck check;
  101. LLSD u;
  102. ensure("is undefined", u.isUndefined());
  103. }
  105. template<> template<>
  106. void SDTestObject::test<2>()
  107. // setting and fetching scalar types
  108. {
  109. SDCleanupCheck check;
  111. LLSD v;
  113. v = true; ensureTypeAndValue("set true", v, true);
  114. v = false; ensureTypeAndValue("set false", v, false);
  115. v = true; ensureTypeAndValue("set true again", v, true);
  117. v = 42; ensureTypeAndValue("set to 42", v, 42);
  118. v = 0; ensureTypeAndValue("set to zero", v, 0);
  119. v = -12345; ensureTypeAndValue("set to neg", v, -12345);
  120. v = 2000000000; ensureTypeAndValue("set to big", v, 2000000000);
  122. v = 3.14159265359;
  123. ensureTypeAndValue("set to pi", v, 3.14159265359);
  124. ensure_not_equals("isn't float", v.asReal(),
  125. (float)3.14159265359);
  126. v = 6.7e256; ensureTypeAndValue("set to big", v, 6.7e256);
  128. LLUUID nullUUID;
  129. LLUUID newUUID;
  130. newUUID.generate();
  132. v = nullUUID; ensureTypeAndValue("set to null UUID", v, nullUUID);
  133. v = newUUID; ensureTypeAndValue("set to new UUID", v, newUUID);
  134. v = nullUUID; ensureTypeAndValue("set to null again", v, nullUUID);
  136. // strings must be tested with two types of string objects
  137. std::string s = "now is the time";
  138. const char* cs = "for all good zorks";
  140. v = s; ensureTypeAndValue("set to std::string", v, s);
  141. v = cs; ensureTypeAndValue("set to const char*", v, cs);
  143. LLDate epoch;
  144. LLDate aDay("2001-10-22T10:11:12.00Z");
  146. v = epoch; ensureTypeAndValue("set to epoch", v, epoch);
  147. v = aDay; ensureTypeAndValue("set to a day", v, aDay);
  149. LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
  151. v = path; ensureTypeAndValue("set to a uri", v, path);
  153. const char source[] = "once in a blue moon";
  154. std::vector<U8> data;
  155. copy(&source[0], &source[sizeof(source)], back_inserter(data));
  157. v = data; ensureTypeAndValue("set to data", v, data);
  159. v.clear();
  160. ensure("reset to undefined", v.type() == LLSD::TypeUndefined);
  161. }
  163. template<> template<>
  164. void SDTestObject::test<3>()
  165. // construction via scalar values
  166. // tests both constructor and initialize forms
  167. {
  168. SDCleanupCheck check;
  170. LLSD b1(true); ensureTypeAndValue("construct boolean", b1, true);
  171. LLSD b2 = true; ensureTypeAndValue("initialize  boolean", b2, true);
  172. LLSD i1(42); ensureTypeAndValue("construct int", i1, 42);
  173. LLSD i2 =42; ensureTypeAndValue("initialize  int", i2, 42);
  174. LLSD d1(1.2); ensureTypeAndValue("construct double", d1, 1.2);
  175. LLSD d2 = 1.2; ensureTypeAndValue("initialize double", d2, 1.2);
  177. LLUUID newUUID;
  178. newUUID.generate();
  179. LLSD u1(newUUID);
  180. ensureTypeAndValue("construct UUID", u1, newUUID);
  181. LLSD u2 = newUUID;
  182. ensureTypeAndValue("initialize UUID", u2, newUUID);
  184. LLSD ss1(std::string("abc"));
  185. ensureTypeAndValue("construct std::string", ss1, "abc");
  186. LLSD ss2 = std::string("abc");
  187. ensureTypeAndValue("initialize std::string",ss2, "abc");
  188. LLSD sl1(std::string("def"));
  189. ensureTypeAndValue("construct std::string", sl1, "def");
  190. LLSD sl2 = std::string("def");
  191. ensureTypeAndValue("initialize std::string", sl2, "def");
  192. LLSD sc1("ghi");
  193. ensureTypeAndValue("construct const char*", sc1, "ghi");
  194. LLSD sc2 = "ghi";
  195. ensureTypeAndValue("initialize const char*",sc2, "ghi");
  197. LLDate aDay("2001-10-22T10:11:12.00Z");
  198. LLSD t1(aDay); ensureTypeAndValue("construct LLDate", t1, aDay);
  199. LLSD t2 = aDay; ensureTypeAndValue("initialize LLDate", t2, aDay);
  201. LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
  202. LLSD p1(path); ensureTypeAndValue("construct LLURI", p1, path);
  203. LLSD p2 = path; ensureTypeAndValue("initialize LLURI", p2, path);
  205. const char source[] = "once in a blue moon";
  206. std::vector<U8> data;
  207. copy(&source[0], &source[sizeof(source)], back_inserter(data));
  208. LLSD x1(data); ensureTypeAndValue("construct vector<U8>", x1, data);
  209. LLSD x2 = data; ensureTypeAndValue("initialize vector<U8>", x2, data);
  210. }
  212. void checkConversions(const char* msg, const LLSD& v,
  213. LLSD::Boolean eBoolean, LLSD::Integer eInteger,
  214. LLSD::Real eReal, const LLSD::String& eString)
  215. {
  216. std::string s(msg);
  218. ensure_equals(s+" to bool", v.asBoolean(), eBoolean);
  219. ensure_equals(s+" to int", v.asInteger(), eInteger);
  220. if (eReal == eReal)
  221. {
  222. ensure_equals(s+" to real", v.asReal(), eReal);
  223. ensure_equals(s+" to string", v.asString(), eString);
  224. }
  225. else
  226. {
  227. // TODO: Fix on windows....
  228. #ifndef LL_WINDOWS
  229. # if !defined(fpclassify) && __GNUC__ >= 3
  230. #   define FPCLASSIFY_NAMESPACE std::
  231. # else
  232. #   define FPCLASSIFY_NAMESPACE
  233. # endif
  234. int left  = FPCLASSIFY_NAMESPACE fpclassify(v.asReal());
  235. int right = FPCLASSIFY_NAMESPACE fpclassify(eReal);
  237. ensure_equals(s+" to real",  left,  right);
  238. ensure_equals(s+" to string", v.asString(), eString);
  239. #endif
  240. }
  241. }
  243. template<> template<>
  244. void SDTestObject::test<4>()
  245. // conversion between undefined and basic scalar types:
  246. // boolean, integer, real and string
  247. {
  248. SDCleanupCheck check;
  250. LLSD v; checkConversions("untitled", v, false, 0, 0.0, "");
  252. v = false; checkConversions("false", v, false, 0, 0.0, "");
  253. v = true; checkConversions("true", v, true, 1, 1.0, "true");
  255. v = 0; checkConversions("zero", v, false, 0, 0.0, "0");
  256. v = 1; checkConversions("one", v, true, 1, 1.0, "1");
  257. v = -33; checkConversions("neg33", v, true, -33, -33.0, "-33");
  259. v = 0.0; checkConversions("0.0", v, false, 0, 0.0, "0");
  260. v = 0.5; checkConversions("point5", v, true, 0, 0.5, "0.5");
  261. v = 0.9; checkConversions("point9", v, true, 0, 0.9, "0.9");
  262. v = -3.9; checkConversions("neg3dot9", v, true, -3, -3.9, "-3.9");
  263. v = sqrt(-1.0); checkConversions("NaN", v, false, 0, sqrt(-1.0), "nan");
  265. v = ""; checkConversions("empty", v, false, 0, 0.0, "");
  266. v = "0"; checkConversions("digit0", v, true, 0, 0.0, "0");
  267. v = "10"; checkConversions("digit10", v, true, 10, 10.0, "10");
  268. v = "-2.345"; checkConversions("decdigits", v,
  269. true, -2, -2.345, "-2.345");
  270. v = "apple"; checkConversions("apple", v, true, 0, 0.0, "apple");
  271. v = "33bob"; checkConversions("digialpha", v, true, 0, 0.0, "33bob");
  272. v = " "; checkConversions("space", v, true, 0, 0.0, " ");
  273. v = "n"; checkConversions("newline", v, true, 0, 0.0, "n");
  274. }
  276. template<class T>
  277. void checkRoundTrip(const std::string& msg, const LLSD& actual,
  278. const char* sExpected, T vExpected)
  279. {
  280. std::string str = actual.asString();
  282. if (sExpected) {
  283. ensure_equals(msg + " string", str, sExpected);
  284. }
  286. LLSD u(str);
  287. LLSDTraits<T> traits;
  289. ensure_equals(msg + " value", traits.get(u), vExpected);
  290. }
  293. template<> template<>
  294. void SDTestObject::test<5>()
  295. // conversion of String to and from UUID, Date and URI.
  296. {
  297. SDCleanupCheck check;
  299. LLSD v;
  301. LLUUID nullUUID;
  302. LLUUID someUUID;
  303. someUUID.generate();
  305. v = nullUUID; checkRoundTrip("null uuid", v,
  306. "00000000-0000-0000-0000-000000000000", nullUUID);
  307. v = someUUID; checkRoundTrip("random uuid", v, 0, someUUID);
  309. LLDate epoch;
  310. LLDate beta("2003-04-30T04:00:00Z");
  311. LLDate oneOh("2003-06-23T04:00:00Z");
  313. v = epoch; checkRoundTrip("epoch date", v, 0, epoch);
  314. v = beta; checkRoundTrip("beta date", v,
  315. "2003-04-30T04:00:00Z", beta);
  316. v = oneOh; checkRoundTrip("1.0 date", v,
  317. "2003-06-23T04:00:00Z", oneOh);
  319. LLURI empty;
  320. LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
  321. LLURI mail("mailto:zero.linden@secondlife.com");
  323. v = empty; checkRoundTrip("empty URI", v, 0, empty);
  324. v = path; checkRoundTrip("path URI", v,
  325. "http://slurl.com/secondlife/Ambleside/57/104/26/",
  326. path);
  327. v = mail; checkRoundTrip("mail URI", v,
  328. "mailto:zero.linden@secondlife.com", mail);
  329. }
  331. template<> template<>
  332. void SDTestObject::test<6>()
  333. // copy construction and assignment
  334. // checking for shared values after constr. or assignment
  335. // checking in both the same type and change of type case
  336. {
  337. SDCleanupCheck check;
  339. {
  340. LLSD v = 42;
  342. LLSD w0(v);
  343. ensureTypeAndValue("int constr.", w0, 42);
  345. LLSD w1(v);
  346. w1 = 13;
  347. ensureTypeAndValue("int constr. change case 1", w1, 13);
  348. ensureTypeAndValue("int constr. change case 2", v, 42);
  350. LLSD w2(v);
  351. v = 7;
  352. ensureTypeAndValue("int constr. change case 3", w2, 42);
  353. ensureTypeAndValue("int constr. change case 4", v, 7);
  354. }
  356. {
  357. LLSD v = 42;
  359. LLSD w1(v);
  360. w1 = "bob";
  361. ensureTypeAndValue("string constr. change case 1", w1, "bob");
  362. ensureTypeAndValue("string constr. change case 2", v, 42);
  364. LLSD w2(v);
  365. v = "amy";
  366. ensureTypeAndValue("string constr. change case 3", w2, 42);
  367. ensureTypeAndValue("string constr. change case 4", v, "amy");
  368. }
  370. {
  371. LLSD v = 42;
  373. LLSD w0;
  374. w0 = v;
  375. ensureTypeAndValue("int assign", w0, 42);
  377. LLSD w1;
  378. w1 = v;
  379. w1 = 13;
  380. ensureTypeAndValue("int assign change case 1", w1, 13);
  381. ensureTypeAndValue("int assign change case 2", v, 42);
  383. LLSD w2;
  384. w2 = v;
  385. v = 7;
  386. ensureTypeAndValue("int assign change case 3", w2, 42);
  387. ensureTypeAndValue("int assign change case 4", v, 7);
  388. }
  390. {
  391. LLSD v = 42;
  393. LLSD w1;
  394. w1 = v;
  395. w1 = "bob";
  396. ensureTypeAndValue("string assign change case 1", w1, "bob");
  397. ensureTypeAndValue("string assign change case 2", v, 42);
  399. LLSD w2;
  400. w2 = v;
  401. v = "amy";
  402. ensureTypeAndValue("string assign change case 3", w2, 42);
  403. ensureTypeAndValue("string assign change case 4", v, "amy");
  404. }
  405. }
  408. template<> template<>
  409. void SDTestObject::test<7>()
  410. // Test assignment and casting to various scalar types.  These
  411. // assignments should invoke the right conversion without it being
  412. // mentioned explicitly.  The few exceptions are marked SAD.
  413. {
  414. SDCleanupCheck check;
  416. LLSD v("  42.375");
  418. bool b = false;
  419. b = v; ensure_equals("assign to bool", b, true);
  420. b = (bool)v; ensure_equals("cast to bool", b, true);
  422. int i = 99;
  423. i = v; ensure_equals("assign to int", i, 42);
  424. i = (int)v; ensure_equals("cast to int", i, 42);
  426. double d = 3.14159;
  427. d = v; ensure_equals("assign to double", d, 42.375);
  428. d = (double)v; ensure_equals("cast to double", d, 42.375);
  430. std::string s = "yo";
  431. // SAD s = v; ensure_equals("assign to string", s, "  42.375");
  432. s = (std::string)v; ensure_equals("cast to string", s, "  42.375");
  434. std::string uuidStr = "b1e50c2b-b627-4d23-8a86-a65d97b6319b";
  435. v = uuidStr;
  436. LLUUID u;
  437. u = v;
  438. ensure_equals("assign to LLUUID", u, LLUUID(uuidStr));
  439. // SAD u = (LLUUID)v;
  440. // ensure_equals("cast to LLUUID", u, LLUUID(uuidStr));
  442. std::string dateStr = "2005-10-24T15:00:00Z";
  443. v = dateStr;
  444. LLDate date;
  445. date = v;
  446. ensure_equals("assign to LLDate", date.asString(), dateStr);
  447. // SAD date = (LLDate)v;
  448. // ensure_equals("cast to LLDate", date.asString(), dateStr);
  450. std::string uriStr = "http://secondlife.com";
  451. v = uriStr;
  452. LLURI uri;
  453. uri = v;
  454. ensure_equals("assign to LLURI", uri.asString(), uriStr);
  455. // SAD  uri = (LLURI)v;
  456. // ensure_equals("cast to LLURI", uri.asString(), uriStr);
  457. }
  459. template<> template<>
  460. void SDTestObject::test<8>()
  461. // Test construction of various scalar types from LLSD.
  462. // Test both construction and initialization forms.
  463. // These should invoke the right conversion without it being
  464. // mentioned explicitly.  The few exceptions are marked SAD.
  465. {
  466. SDCleanupCheck check;
  468. LLSD v("  42.375");
  470. bool b1(v); ensure_equals("contruct bool", b1, true);
  471. bool b2 = v; ensure_equals("initialize bool", b2, true);
  473. int i1(v); ensure_equals("contruct int", i1, 42);
  474. int i2 = v; ensure_equals("initialize int", i2, 42);
  476. double d1(v); ensure_equals("contruct double", d1, 42.375);
  477. double d2 = v; ensure_equals("initialize double", d2, 42.375);
  479. std::string s1(v);
  480. std::string s2 = v;
  481. ensure_equals("contruct string", s1, "  42.375");
  482. ensure_equals("initialize string", s2, "  42.375");
  484. std::string t1(v);
  485. std::string t2 = v.asString(); // SAD
  486. ensure_equals("contruct std::string", t1, "  42.375");
  487. ensure_equals("initialize std::string", t2, "  42.375");
  489. std::string uuidStr = "b1e50c2b-b627-4d23-8a86-a65d97b6319b";
  490. v = uuidStr;
  491. LLUUID uuid1(v.asUUID()); // SAD
  492. LLUUID uuid2 = v;
  493. ensure_equals("contruct LLUUID", uuid1, LLUUID(uuidStr));
  494. ensure_equals("initialize LLUUID", uuid2, LLUUID(uuidStr));
  496. std::string dateStr = "2005-10-24T15:00:00Z";
  497. v = dateStr;
  498. LLDate date1(v.asDate()); // SAD
  499. LLDate date2 = v;
  500. ensure_equals("contruct LLDate", date1.asString(), dateStr);
  501. ensure_equals("initialize LLDate", date2.asString(), dateStr);
  503. std::string uriStr = "http://secondlife.com";
  504. v = uriStr;
  505. LLURI uri1(v.asURI()); // SAD
  506. LLURI uri2 = v;
  507. ensure_equals("contruct LLURI", uri1.asString(), uriStr);
  508. ensure_equals("initialize LLURI", uri2.asString(), uriStr);
  509. }
  512. template<> template<>
  513. void SDTestObject::test<9>()
  514. // test to make sure v is interpreted as a bool in a various
  515. // scenarios.
  516. {
  517. SDCleanupCheck check;
  519. LLSD v = "0";
  520. // magic value that is interpreted as boolean true, but integer false!
  522. ensure_equals("trinary operator bool", (v ? true : false), true);
  523. ensure_equals("convert to int, then bool",
  524. ((int)v ? true : false), false);
  526. if(v)
  527. {
  528. ensure("if converted to bool", true);
  529. }
  530. else
  531. {
  532. fail("bool did not convert to a bool in if statement.");
  533. }
  535. if(!v)
  536. {
  537. fail("bool did not convert to a bool in negated if statement.");
  538. }
  539. }
  541. template<> template<>
  542. void SDTestObject::test<10>()
  543. // map operations
  544. {
  545. SDCleanupCheck check;
  547. LLSD v;
  548. ensure("undefined has no members", !v.has("amy"));
  549. ensure("undefined get() is undefined", v.get("bob").isUndefined());
  551. v = LLSD::emptyMap();
  552. ensure("empty map is a map", v.isMap());
  553. ensure("empty map has no members", !v.has("cam"));
  554. ensure("empty map get() is undefined", v.get("don").isUndefined());
  556. v.clear();
  557. v.insert("eli", 43);
  558. ensure("insert converts to map", v.isMap());
  559. ensure("inserted key is present", v.has("eli"));
  560. ensureTypeAndValue("inserted value", v.get("eli"), 43);
  562. v.insert("fra", false);
  563. ensure("first key still present", v.has("eli"));
  564. ensure("second key is present", v.has("fra"));
  565. ensureTypeAndValue("first value", v.get("eli"), 43);
  566. ensureTypeAndValue("second value", v.get("fra"), false);
  568. v.erase("eli");
  569. ensure("first key now gone", !v.has("eli"));
  570. ensure("second key still present", v.has("fra"));
  571. ensure("first value gone", v.get("eli").isUndefined());
  572. ensureTypeAndValue("second value sill there", v.get("fra"), false);
  574. v.erase("fra");
  575. ensure("second key now gone", !v.has("fra"));
  576. ensure("second value gone", v.get("fra").isUndefined());
  578. v["gil"] = (std::string)"good morning";
  579. ensure("third key present", v.has("gil"));
  580. ensureTypeAndValue("third key value", v.get("gil"), "good morning");
  582. const LLSD& cv = v; // FIX ME IF POSSIBLE
  583. ensure("missing key", cv["ham"].isUndefined());
  584. ensure("key not present", !v.has("ham"));
  586. LLSD w = 43;
  587. const LLSD& cw = w; // FIX ME IF POSSIBLE
  588. int i = cw["ian"];
  589. ensureTypeAndValue("other missing value", i, 0);
  590. ensure("other missing key", !w.has("ian"));
  591. ensure("no conversion", w.isInteger());
  593. LLSD x;
  594. x = v;
  595. ensure("copy map type", x.isMap());
  596. ensureTypeAndValue("copy map value gil", x.get("gil"), "good morning");
  597. }
  600. template<> template<>
  601. void SDTestObject::test<11>()
  602. // array operations
  603. {
  604. SDCleanupCheck check;
  606. LLSD v;
  607. ensure_equals("undefined has no size", v.size(), 0);
  608. ensure("undefined get() is undefined", v.get(0).isUndefined());
  610. v = LLSD::emptyArray();
  611. ensure("empty array is an array", v.isArray());
  612. ensure_equals("empty array has no size", v.size(), 0);
  613. ensure("empty map get() is undefined", v.get(0).isUndefined());
  615. v.clear();
  616. v.append(88);
  617. v.append("noodle");
  618. v.append(true);
  619. ensure_equals("appened array size", v.size(), 3);
  620. ensure("append array is an array", v.isArray());
  621. ensureTypeAndValue("append 0", v[0], 88);
  622. ensureTypeAndValue("append 1", v[1], "noodle");
  623. ensureTypeAndValue("append 2", v[2], true);
  625. v.insert(0, 77);
  626. v.insert(2, "soba");
  627. v.insert(4, false);
  628. ensure_equals("inserted array size", v.size(), 6);
  629. ensureTypeAndValue("post insert 0", v[0], 77);
  630. ensureTypeAndValue("post insert 1", v[1], 88);
  631. ensureTypeAndValue("post insert 2", v[2], "soba");
  632. ensureTypeAndValue("post insert 3", v[3], "noodle");
  633. ensureTypeAndValue("post insert 4", v[4], false);
  634. ensureTypeAndValue("post insert 5", v[5], true);
  636. ensureTypeAndValue("get 1", v.get(1), 88);
  637. v.set(1, "hot");
  638. ensureTypeAndValue("set 1", v.get(1), "hot");
  640. v.erase(3);
  641. ensure_equals("post erase array size", v.size(), 5);
  642. ensureTypeAndValue("post erase 0", v[0], 77);
  643. ensureTypeAndValue("post erase 1", v[1], "hot");
  644. ensureTypeAndValue("post erase 2", v[2], "soba");
  645. ensureTypeAndValue("post erase 3", v[3], false);
  646. ensureTypeAndValue("post erase 4", v[4], true);
  648. v.append(34);
  649. ensure_equals("size after append", v.size(), 6);
  650. ensureTypeAndValue("post append 5", v[5], 34);
  652. LLSD w;
  653. w = v;
  654. ensure("copy array type", w.isArray());
  655. ensure_equals("copy array size", w.size(), 6);
  656. ensureTypeAndValue("copy array 0", w[0], 77);
  657. ensureTypeAndValue("copy array 1", w[1], "hot");
  658. ensureTypeAndValue("copy array 2", w[2], "soba");
  659. ensureTypeAndValue("copy array 3", w[3], false);
  660. ensureTypeAndValue("copy array 4", w[4], true);
  661. ensureTypeAndValue("copy array 5", w[5], 34);
  662. }
  665. template<> template<>
  666. void SDTestObject::test<12>()
  667. // no sharing
  668. {
  669. SDCleanupCheck check;
  671. LLSD a = 99;
  672. LLSD b = a;
  673. a = 34;
  674. ensureTypeAndValue("top level original changed", a, 34);
  675. ensureTypeAndValue("top level copy unaltered", b, 99);
  676. b = a;
  677. b = 66;
  678. ensureTypeAndValue("top level original unaltered", a, 34);
  679. ensureTypeAndValue("top level copy changed", b, 66);
  681. a[0] = "uno";
  682. a[1] = 99;
  683. a[2] = 1.414;
  684. b = a;
  685. a[1] = 34;
  686. ensureTypeAndValue("array member original changed", a[1], 34);
  687. ensureTypeAndValue("array member copy unaltered", b[1], 99);
  688. b = a;
  689. b[1] = 66;
  690. ensureTypeAndValue("array member original unaltered", a[1], 34);
  691. ensureTypeAndValue("array member copy changed", b[1], 66);
  693. a["alpha"] = "uno";
  694. a["beta"] = 99;
  695. a["gamma"] = 1.414;
  696. b = a;
  697. a["beta"] = 34;
  698. ensureTypeAndValue("map member original changed", a["beta"], 34);
  699. ensureTypeAndValue("map member copy unaltered", b["beta"], 99);
  700. b = a;
  701. b["beta"] = 66;
  702. ensureTypeAndValue("map member original unaltered", a["beta"], 34);
  703. ensureTypeAndValue("map member copy changed", b["beta"], 66);
  704. }
  706. template<> template<>
  707. void SDTestObject::test<13>()
  708. // sharing implementation
  709. {
  710. SDCleanupCheck check;
  712. {
  713. SDAllocationCheck check("copy construct undefinded", 0);
  714. LLSD v;
  715. LLSD w = v;
  716. }
  718. {
  719. SDAllocationCheck check("assign undefined", 0);
  720. LLSD v;
  721. LLSD w;
  722. w = v;
  723. }
  725. {
  726. SDAllocationCheck check("assign integer value", 1);
  727. LLSD v = 45;
  728. v = 33;
  729. v = 0;
  730. }
  732. {
  733. SDAllocationCheck check("copy construct integer", 1);
  734. LLSD v = 45;
  735. LLSD w = v;
  736. }
  738. {
  739. SDAllocationCheck check("assign integer", 1);
  740. LLSD v = 45;
  741. LLSD w;
  742. w = v;
  743. }
  745. {
  746. SDAllocationCheck check("avoids extra clone", 2);
  747. LLSD v = 45;
  748. LLSD w = v;
  749. w = "nice day";
  750. }
  751. }
  753. template<> template<>
  754. void SDTestObject::test<14>()
  755. // make sure that assignment of char* NULL in a string does not crash.
  756. {
  757. LLSD v;
  758. v = (const char*)NULL;
  759. ensure("type is a string", v.isString());
  760. }
  762. /* TO DO:
  763. conversion of undefined to UUID, Date, URI and Binary
  764. conversion of undefined to map and array
  765. test map operations
  766. test array operations
  767. test array extension
  769. test copying and assign maps and arrays (clone)
  770. test iteration over map
  771. test iteration over array
  772. test iteration over scalar
  774. test empty map and empty array are indeed shared
  775. test serializations
  776. */
  777. }