/indra/test/llsdmessagebuilder_tut.cpp

https://bitbucket.org/lindenlab/viewer-beta/ · C++ · 837 lines · 604 code · 149 blank · 84 comment · 3 complexity · 14818e7efa4cc1424649b23f7e9994dd MD5 · raw file

  1. /**
  2. * @file llsdmessagebuilder_tut.cpp
  3. * @date February 2006
  4. * @brief LLSDMessageBuilder unit tests
  5. *
  6. * $LicenseInfo:firstyear=2006&license=viewerlgpl$
  7. * Second Life Viewer Source Code
  8. * Copyright (C) 2010, Linden Research, Inc.
  9. *
  10. * This library is free software; you can redistribute it and/or
  11. * modify it under the terms of the GNU Lesser General Public
  12. * License as published by the Free Software Foundation;
  13. * version 2.1 of the License only.
  14. *
  15. * This library is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18. * Lesser General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU Lesser General Public
  21. * License along with this library; if not, write to the Free Software
  22. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23. *
  24. * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
  25. * $/LicenseInfo$
  26. */
  27. #include <tut/tut.hpp>
  28. #include "linden_common.h"
  29. #include "lltut.h"
  30. #include "llmessagetemplate.h"
  31. #include "llsdmessagebuilder.h"
  32. #include "llsdmessagereader.h"
  33. #include "llsdtraits.h"
  34. #include "llmath.h"
  35. #include "llquaternion.h"
  36. #include "u64.h"
  37. #include "v3dmath.h"
  38. #include "v3math.h"
  39. #include "v4math.h"
  40. #include "llsdutil.h"
  41. //#include "llsdutil.cpp"
  42. #include "llsdutil_math.cpp"
  43. #include "lltemplatemessagebuilder.h"
  44. namespace tut
  45. {
  46. static LLTemplateMessageBuilder::message_template_name_map_t templateNameMap;
  47. LLMsgData* messageData = NULL;
  48. LLMsgBlkData* messageBlockData = NULL;
  49. struct LLSDMessageBuilderTestData {
  50. LLSDMessageBuilderTestData()
  51. {
  52. messageData = new LLMsgData("testMessage");
  53. messageBlockData = new LLMsgBlkData("testBlock", 0);
  54. }
  55. static LLSDMessageBuilder defaultBuilder()
  56. {
  57. LLSDMessageBuilder builder;
  58. builder.newMessage("name");
  59. builder.nextBlock("block");
  60. return builder;
  61. }
  62. static LLSDMessageReader setReader(const LLSDMessageBuilder& builder)
  63. {
  64. LLSDMessageReader reader;
  65. reader.setMessage("name", builder.getMessage());
  66. return reader;
  67. }
  68. static void addValue(LLMsgBlkData* mbd, char* name, void* v, EMsgVariableType type, int size, int data_size = -1)
  69. {
  70. LLMsgVarData tmp(name, type);
  71. tmp.addData(v, size, type, data_size);
  72. mbd->mMemberVarData[name] = tmp;
  73. }
  74. static LLMessageBlock* defaultTemplateBlock(const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
  75. {
  76. return createTemplateBlock(_PREHASH_Test0, type, size, block);
  77. }
  78. static LLMessageBlock* createTemplateBlock(const char* name, const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
  79. {
  80. LLMessageBlock* result = new LLMessageBlock(name, block);
  81. if(type != MVT_NULL)
  82. {
  83. result->addVariable(const_cast<char*>(_PREHASH_Test0), type, size);
  84. }
  85. return result;
  86. }
  87. static LLTemplateMessageBuilder* defaultTemplateBuilder(LLMessageTemplate& messageTemplate, char* name = const_cast<char*>(_PREHASH_Test0))
  88. {
  89. templateNameMap[_PREHASH_TestMessage] = &messageTemplate;
  90. LLTemplateMessageBuilder* builder = new LLTemplateMessageBuilder(templateNameMap);
  91. builder->newMessage(_PREHASH_TestMessage);
  92. builder->nextBlock(name);
  93. return builder;
  94. }
  95. static LLMessageTemplate defaultTemplate()
  96. {
  97. return LLMessageTemplate(_PREHASH_TestMessage, 1, MFT_HIGH);
  98. }
  99. };
  100. typedef test_group<LLSDMessageBuilderTestData> LLSDMessageBuilderTestGroup;
  101. typedef LLSDMessageBuilderTestGroup::object LLSDMessageBuilderTestObject;
  102. LLSDMessageBuilderTestGroup llsdMessageBuilderTestGroup("LLSDMessageBuilder");
  103. template<> template<>
  104. void LLSDMessageBuilderTestObject::test<1>()
  105. // construction and test of undefined
  106. {
  107. LLSDMessageBuilder builder = defaultBuilder();
  108. LLSDMessageReader reader = setReader(builder);
  109. }
  110. template<> template<>
  111. void LLSDMessageBuilderTestObject::test<2>()
  112. // BOOL
  113. {
  114. BOOL outValue, inValue = TRUE;
  115. LLSDMessageBuilder builder = defaultBuilder();
  116. builder.addBOOL("var", inValue);
  117. LLSDMessageReader reader = setReader(builder);
  118. reader.getBOOL("block", "var", outValue);
  119. ensure_equals("Ensure BOOL", inValue, outValue);
  120. }
  121. template<> template<>
  122. void LLSDMessageBuilderTestObject::test<3>()
  123. // U8
  124. {
  125. U8 outValue, inValue = 2;
  126. LLSDMessageBuilder builder = defaultBuilder();
  127. builder.addU8("var", inValue);
  128. LLSDMessageReader reader = setReader(builder);
  129. reader.getU8("block", "var", outValue);
  130. ensure_equals("Ensure U8", inValue, outValue);
  131. }
  132. template<> template<>
  133. void LLSDMessageBuilderTestObject::test<4>()
  134. // S16
  135. {
  136. S16 outValue, inValue = 90;
  137. LLSDMessageBuilder builder = defaultBuilder();
  138. builder.addS16("var", inValue);
  139. LLSDMessageReader reader = setReader(builder);
  140. reader.getS16("block", "var", outValue);
  141. ensure_equals("Ensure S16", inValue, outValue);
  142. }
  143. template<> template<>
  144. void LLSDMessageBuilderTestObject::test<5>()
  145. // U16
  146. {
  147. U16 outValue, inValue = 3;
  148. LLSDMessageBuilder builder = defaultBuilder();
  149. builder.addU16("var", inValue);
  150. LLSDMessageReader reader = setReader(builder);
  151. reader.getU16("block", "var", outValue);
  152. ensure_equals("Ensure U16", inValue, outValue);
  153. }
  154. template<> template<>
  155. void LLSDMessageBuilderTestObject::test<6>()
  156. // S32
  157. {
  158. S32 outValue, inValue = 44;
  159. LLSDMessageBuilder builder = defaultBuilder();
  160. builder.addS32("var", inValue);
  161. LLSDMessageReader reader = setReader(builder);
  162. reader.getS32("block", "var", outValue);
  163. ensure_equals("Ensure S32", inValue, outValue);
  164. }
  165. template<> template<>
  166. void LLSDMessageBuilderTestObject::test<7>()
  167. // F32
  168. {
  169. F32 outValue, inValue = 121.44f;
  170. LLSDMessageBuilder builder = defaultBuilder();
  171. builder.addF32("var", inValue);
  172. LLSDMessageReader reader = setReader(builder);
  173. reader.getF32("block", "var", outValue);
  174. ensure_equals("Ensure F32", inValue, outValue);
  175. }
  176. template<> template<>
  177. void LLSDMessageBuilderTestObject::test<8>()
  178. // U32
  179. {
  180. U32 outValue, inValue = 88;
  181. LLSDMessageBuilder builder = defaultBuilder();
  182. builder.addU32("var", inValue);
  183. LLSDMessageReader reader = setReader(builder);
  184. reader.getU32("block", "var", outValue);
  185. ensure_equals("Ensure U32", inValue, outValue);
  186. }
  187. template<> template<>
  188. void LLSDMessageBuilderTestObject::test<9>()
  189. // U64
  190. {
  191. U64 outValue, inValue = 121;
  192. LLSDMessageBuilder builder = defaultBuilder();
  193. builder.addU64("var", inValue);
  194. LLSDMessageReader reader = setReader(builder);
  195. reader.getU64("block", "var", outValue);
  196. ensure_equals("Ensure U64", inValue, outValue);
  197. }
  198. template<> template<>
  199. void LLSDMessageBuilderTestObject::test<10>()
  200. // F64
  201. {
  202. F64 outValue, inValue = 3232143.33;
  203. LLSDMessageBuilder builder = defaultBuilder();
  204. builder.addF64("var", inValue);
  205. LLSDMessageReader reader = setReader(builder);
  206. reader.getF64("block", "var", outValue);
  207. ensure_equals("Ensure F64", inValue, outValue);
  208. }
  209. template<> template<>
  210. void LLSDMessageBuilderTestObject::test<11>()
  211. // Vector3
  212. {
  213. LLVector3 outValue, inValue = LLVector3(1,2,3);
  214. LLSDMessageBuilder builder = defaultBuilder();
  215. builder.addVector3("var", inValue);
  216. LLSDMessageReader reader = setReader(builder);
  217. reader.getVector3("block", "var", outValue);
  218. ensure_equals("Ensure Vector3", inValue, outValue);
  219. }
  220. template<> template<>
  221. void LLSDMessageBuilderTestObject::test<12>()
  222. // Vector4
  223. {
  224. LLVector4 outValue, inValue = LLVector4(1,2,3,4);
  225. LLSDMessageBuilder builder = defaultBuilder();
  226. builder.addVector4("var", inValue);
  227. LLSDMessageReader reader = setReader(builder);
  228. reader.getVector4("block", "var", outValue);
  229. ensure_equals("Ensure Vector4", inValue, outValue);
  230. }
  231. template<> template<>
  232. void LLSDMessageBuilderTestObject::test<13>()
  233. // Vector3d
  234. {
  235. LLVector3d outValue, inValue = LLVector3d(1,2,3);
  236. LLSDMessageBuilder builder = defaultBuilder();
  237. builder.addVector3d("var", inValue);
  238. LLSDMessageReader reader = setReader(builder);
  239. reader.getVector3d("block", "var", outValue);
  240. ensure_equals("Ensure Vector3d", inValue, outValue);
  241. }
  242. template<> template<>
  243. void LLSDMessageBuilderTestObject::test<14>()
  244. // Quaternion
  245. {
  246. LLQuaternion outValue, inValue = LLQuaternion(1,2,3,4);
  247. LLSDMessageBuilder builder = defaultBuilder();
  248. builder.addQuat("var", inValue);
  249. LLSDMessageReader reader = setReader(builder);
  250. reader.getQuat("block", "var", outValue);
  251. ensure_equals("Ensure Quaternion", inValue, outValue);
  252. }
  253. template<> template<>
  254. void LLSDMessageBuilderTestObject::test<15>()
  255. // UUID
  256. {
  257. LLUUID outValue, inValue;
  258. inValue.generate();
  259. LLSDMessageBuilder builder = defaultBuilder();
  260. builder.addUUID("var", inValue);
  261. LLSDMessageReader reader = setReader(builder);
  262. reader.getUUID("block", "var", outValue);
  263. ensure_equals("Ensure UUID", inValue, outValue);
  264. }
  265. template<> template<>
  266. void LLSDMessageBuilderTestObject::test<16>()
  267. // IPAddr
  268. {
  269. U32 outValue, inValue = 12344556;
  270. LLSDMessageBuilder builder = defaultBuilder();
  271. builder.addIPAddr("var", inValue);
  272. LLSDMessageReader reader = setReader(builder);
  273. reader.getIPAddr("block", "var", outValue);
  274. ensure_equals("Ensure IPAddr", inValue, outValue);
  275. }
  276. template<> template<>
  277. void LLSDMessageBuilderTestObject::test<17>()
  278. // IPPort
  279. {
  280. U16 outValue, inValue = 80;
  281. LLSDMessageBuilder builder = defaultBuilder();
  282. builder.addIPPort("var", inValue);
  283. LLSDMessageReader reader = setReader(builder);
  284. reader.getIPPort("block", "var", outValue);
  285. ensure_equals("Ensure IPPort", inValue, outValue);
  286. }
  287. template<> template<>
  288. void LLSDMessageBuilderTestObject::test<18>()
  289. {
  290. std::string outValue, inValue = "testing";
  291. LLSDMessageBuilder builder = defaultBuilder();
  292. builder.addString("var", inValue.c_str());
  293. LLSDMessageReader reader = setReader(builder);
  294. char buffer[MAX_STRING];
  295. reader.getString("block", "var", MAX_STRING, buffer);
  296. outValue = buffer;
  297. ensure_equals("Ensure String", inValue, outValue);
  298. }
  299. template<> template<>
  300. void LLSDMessageBuilderTestObject::test<19>()
  301. {
  302. LLMsgBlkData* mbd = new LLMsgBlkData("testBlock", 0);
  303. LLMsgData* md = new LLMsgData("testMessage");
  304. md->addBlock(mbd);
  305. LLSDMessageBuilder builder = defaultBuilder();
  306. builder.copyFromMessageData(*md);
  307. LLSD output = builder.getMessage();
  308. ensure("Ensure message block created when copied from legacy message to llsd", output["testBlock"].isDefined());
  309. }
  310. // MVT_FIXED
  311. template<> template<>
  312. void LLSDMessageBuilderTestObject::test<20>()
  313. {
  314. char binData[] = "abcdefghijklmnop";
  315. addValue(messageBlockData, (char *)"testBinData", &binData, MVT_FIXED, sizeof(binData));
  316. messageData->addBlock(messageBlockData);
  317. LLSDMessageBuilder builder = defaultBuilder();
  318. builder.copyFromMessageData(*messageData);
  319. LLSD output = builder.getMessage();
  320. std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  321. ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
  322. ensure_memory_matches("Ensure fixed binary data works in a message copied from legacy to llsd",
  323. &v[0], sizeof(binData), binData, sizeof(binData));
  324. }
  325. // MVT_VARIABLE data_size 1 (U8's)
  326. template<> template<>
  327. void LLSDMessageBuilderTestObject::test<21>()
  328. {
  329. /* U8 binData[] = "abcdefghijklmnop";
  330. addValue(messageBlockData, "testBinData", &binData, MVT_VARIABLE, sizeof(binData), 1);
  331. messageData->addBlock(messageBlockData);
  332. LLSDMessageBuilder builder = defaultBuilder();
  333. builder.copyFromMessageData(*messageData);
  334. LLSD output = builder.getMessage();
  335. std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  336. ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
  337. ensure_memory_matches("Ensure MVT_VARIABLE U8 binary data works in a message copied from legacy to llsd",
  338. &v[0], sizeof(binData), binData, sizeof(binData));*/
  339. }
  340. // MVT_VARIABLE data_size 2 (U16's)
  341. template<> template<>
  342. void LLSDMessageBuilderTestObject::test<22>()
  343. {
  344. U16 binData[] = {1,2,3,4,5,6,7,8,9}; //9 shorts
  345. addValue(messageBlockData, (char *)"testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 1, 2);
  346. messageData->addBlock(messageBlockData);
  347. LLSDMessageBuilder builder = defaultBuilder();
  348. builder.copyFromMessageData(*messageData);
  349. LLSD output = builder.getMessage();
  350. std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  351. ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
  352. ensure_memory_matches("Ensure MVT_VARIABLE U16 binary data works in a message copied from legacy to llsd",
  353. &v[0], sizeof(binData) >> 1, binData, sizeof(binData) >> 1);
  354. }
  355. // MVT_VARIABLE data_size 4 (S32's)
  356. template<> template<>
  357. void LLSDMessageBuilderTestObject::test<23>()
  358. {
  359. U32 binData[] = {9,8,7,6,5,4,3,2,1};
  360. addValue(messageBlockData, (char *)"testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 2, 4);
  361. messageData->addBlock(messageBlockData);
  362. LLSDMessageBuilder builder = defaultBuilder();
  363. builder.copyFromMessageData(*messageData);
  364. LLSD output = builder.getMessage();
  365. std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  366. ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
  367. ensure_memory_matches("Ensure MVT_VARIABLE S32 binary data works in a message copied from legacy to llsd",
  368. &v[0], sizeof(binData) >> 2, binData, sizeof(binData) >> 2);
  369. }
  370. // MVT_U8
  371. template<> template<>
  372. void LLSDMessageBuilderTestObject::test<24>()
  373. {
  374. U8 data = 0xa5;
  375. addValue(messageBlockData, (char *)"testBinData", &data, MVT_U8, sizeof(data));
  376. messageData->addBlock(messageBlockData);
  377. LLSDMessageBuilder builder = defaultBuilder();
  378. builder.copyFromMessageData(*messageData);
  379. LLSD output = builder.getMessage();
  380. ensure_equals("Ensure MVT_U8 data works in a message copied from legacy to llsd",
  381. output["testBlock"][0]["testBinData"].asInteger(), data);
  382. }
  383. // MVT_U16
  384. template<> template<>
  385. void LLSDMessageBuilderTestObject::test<25>()
  386. {
  387. U16 data = 0xa55a;
  388. addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16, sizeof(data));
  389. messageData->addBlock(messageBlockData);
  390. LLSDMessageBuilder builder = defaultBuilder();
  391. builder.copyFromMessageData(*messageData);
  392. LLSD output = builder.getMessage();
  393. ensure_equals("Ensure MVT_U16 data works in a message copied from legacy to llsd",
  394. output["testBlock"][0]["testBinData"].asInteger(), data);
  395. }
  396. // MVT_U32
  397. template<> template<>
  398. void LLSDMessageBuilderTestObject::test<26>()
  399. {
  400. U32 data = 0xa55a7117;
  401. addValue(messageBlockData, (char *)"testBinData", &data, MVT_U32, sizeof(data));
  402. messageData->addBlock(messageBlockData);
  403. LLSDMessageBuilder builder = defaultBuilder();
  404. builder.copyFromMessageData(*messageData);
  405. LLSD output = builder.getMessage();
  406. ensure_equals("Ensure MVT_U32 data works in a message copied from legacy to llsd",
  407. ll_U32_from_sd(output["testBlock"][0]["testBinData"]), data);
  408. }
  409. // MVT_U64 - crush into an s32: LLSD does not support 64 bit values
  410. template<> template<>
  411. void LLSDMessageBuilderTestObject::test<27>()
  412. {
  413. U64 data = U64L(0xa55a711711223344);
  414. addValue(messageBlockData, (char *)"testBinData", &data, MVT_U64, sizeof(data));
  415. messageData->addBlock(messageBlockData);
  416. LLSDMessageBuilder builder = defaultBuilder();
  417. builder.copyFromMessageData(*messageData);
  418. LLSD output = builder.getMessage();
  419. ensure_equals("Ensure MVT_U64 data works in a message copied from legacy to llsd",
  420. ll_U64_from_sd(output["testBlock"][0]["testBinData"]), data);
  421. }
  422. // MVT_S8
  423. template<> template<>
  424. void LLSDMessageBuilderTestObject::test<28>()
  425. {
  426. S8 data = -31;
  427. addValue(messageBlockData, (char *)"testBinData", &data, MVT_S8, sizeof(data));
  428. messageData->addBlock(messageBlockData);
  429. LLSDMessageBuilder builder = defaultBuilder();
  430. builder.copyFromMessageData(*messageData);
  431. LLSD output = builder.getMessage();
  432. ensure_equals("Ensure MVT_S8 data works in a message copied from legacy to llsd",
  433. output["testBlock"][0]["testBinData"].asInteger(), data);
  434. }
  435. // MVT_S16
  436. template<> template<>
  437. void LLSDMessageBuilderTestObject::test<29>()
  438. {
  439. S16 data = -31;
  440. addValue(messageBlockData, (char *)"testBinData", &data, MVT_S16, sizeof(data));
  441. messageData->addBlock(messageBlockData);
  442. LLSDMessageBuilder builder = defaultBuilder();
  443. builder.copyFromMessageData(*messageData);
  444. LLSD output = builder.getMessage();
  445. ensure_equals("Ensure MVT_S16 data works in a message copied from legacy to llsd",
  446. output["testBlock"][0]["testBinData"].asInteger(), data);
  447. }
  448. // MVT_S32
  449. template<> template<>
  450. void LLSDMessageBuilderTestObject::test<30>()
  451. {
  452. S32 data = -3100;
  453. addValue(messageBlockData, (char *)"testBinData", &data, MVT_S32, sizeof(data));
  454. messageData->addBlock(messageBlockData);
  455. LLSDMessageBuilder builder = defaultBuilder();
  456. builder.copyFromMessageData(*messageData);
  457. LLSD output = builder.getMessage();
  458. ensure_equals("Ensure MVT_S32 data works in a message copied from legacy to llsd",
  459. output["testBlock"][0]["testBinData"].asInteger(), data);
  460. }
  461. // MVT_S64 - crush into an s32: LLSD does not support 64 bit values
  462. template<> template<>
  463. void LLSDMessageBuilderTestObject::test<31>()
  464. {
  465. S64 data = -31003100;
  466. addValue(messageBlockData, (char *)"testBinData", &data, MVT_S64, sizeof(data));
  467. messageData->addBlock(messageBlockData);
  468. LLSDMessageBuilder builder = defaultBuilder();
  469. builder.copyFromMessageData(*messageData);
  470. LLSD output = builder.getMessage();
  471. ensure_equals("Ensure MVT_S64 data works in a message copied from legacy to llsd",
  472. output["testBlock"][0]["testBinData"].asInteger(), (S32)data);
  473. }
  474. // MVT_F32
  475. template<> template<>
  476. void LLSDMessageBuilderTestObject::test<32>()
  477. {
  478. F32 data = 1234.1234f;
  479. addValue(messageBlockData, (char *)"testBinData", &data, MVT_F32, sizeof(data));
  480. messageData->addBlock(messageBlockData);
  481. LLSDMessageBuilder builder = defaultBuilder();
  482. builder.copyFromMessageData(*messageData);
  483. LLSD output = builder.getMessage();
  484. ensure_equals("Ensure MVT_F32 data works in a message copied from legacy to llsd",
  485. output["testBlock"][0]["testBinData"].asReal(), data);
  486. }
  487. // MVT_F64
  488. template<> template<>
  489. void LLSDMessageBuilderTestObject::test<33>()
  490. {
  491. F64 data = 1234.1234;
  492. addValue(messageBlockData, (char *)"testBinData", &data, MVT_F64, sizeof(data));
  493. messageData->addBlock(messageBlockData);
  494. LLSDMessageBuilder builder = defaultBuilder();
  495. builder.copyFromMessageData(*messageData);
  496. LLSD output = builder.getMessage();
  497. ensure_equals("Ensure MVT_F64 data works in a message copied from legacy to llsd",
  498. output["testBlock"][0]["testBinData"].asReal(), data);
  499. }
  500. // MVT_LLVector3
  501. template<> template<>
  502. void LLSDMessageBuilderTestObject::test<34>()
  503. {
  504. LLVector3 data(1,2,3);
  505. addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector3, sizeof(data));
  506. messageData->addBlock(messageBlockData);
  507. LLSDMessageBuilder builder = defaultBuilder();
  508. builder.copyFromMessageData(*messageData);
  509. LLSD output = builder.getMessage();
  510. ensure_equals("Ensure MVT_LLVector3 data works in a message copied from legacy to llsd",
  511. ll_vector3_from_sd(output["testBlock"][0]["testBinData"]), data);
  512. }
  513. // MVT_LLVector3d
  514. template<> template<>
  515. void LLSDMessageBuilderTestObject::test<35>()
  516. {
  517. LLVector3d data(1,2,3);
  518. addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector3d, sizeof(data));
  519. messageData->addBlock(messageBlockData);
  520. LLSDMessageBuilder builder = defaultBuilder();
  521. builder.copyFromMessageData(*messageData);
  522. LLSD output = builder.getMessage();
  523. ensure_equals("Ensure MVT_LLVector3 data works in a message copied from legacy to llsd",
  524. ll_vector3d_from_sd(output["testBlock"][0]["testBinData"]), data);
  525. }
  526. // MVT_LLVector4
  527. template<> template<>
  528. void LLSDMessageBuilderTestObject::test<36>()
  529. {
  530. LLVector4 data(1,2,3,4);
  531. LLSD v = ll_sd_from_vector4(data);
  532. addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector4, sizeof(data));
  533. messageData->addBlock(messageBlockData);
  534. LLSDMessageBuilder builder = defaultBuilder();
  535. builder.copyFromMessageData(*messageData);
  536. LLSD output = builder.getMessage();
  537. ensure_equals("Ensure MVT_LLVector4 data works in a message copied from legacy to llsd",
  538. output["testBlock"][0]["testBinData"], v);
  539. }
  540. // MVT_LLQuaternion
  541. template<> template<>
  542. void LLSDMessageBuilderTestObject::test<37>()
  543. {
  544. LLQuaternion data(1,2,3,0);
  545. //we send a quaternion packed into a vec3 (w is infered) - so sizeof(vec) == 12 bytes not 16.
  546. LLVector3 vec = data.packToVector3();
  547. addValue(messageBlockData, (char *)"testBinData", &vec, MVT_LLQuaternion, sizeof(vec));
  548. messageData->addBlock(messageBlockData);
  549. LLSDMessageBuilder builder = defaultBuilder();
  550. builder.copyFromMessageData(*messageData);
  551. LLSD output = builder.getMessage();
  552. ensure_equals("Ensure MVT_LLQuaternion data works in a message copied from legacy to llsd",
  553. ll_quaternion_from_sd(output["testBlock"][0]["testBinData"]), data);
  554. }
  555. // MVT_LLUUID
  556. template<> template<>
  557. void LLSDMessageBuilderTestObject::test<38>()
  558. {
  559. LLUUID data("01234567-0123-0123-0123-234567abcdef");
  560. addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLUUID, sizeof(data));
  561. messageData->addBlock(messageBlockData);
  562. LLSDMessageBuilder builder = defaultBuilder();
  563. builder.copyFromMessageData(*messageData);
  564. LLSD output = builder.getMessage();
  565. std::string v = output["testBlock"][0]["testBinData"].asUUID().asString();
  566. ensure_equals("Ensure MVT_LLUUID data works in a message copied from legacy to llsd",
  567. output["testBlock"][0]["testBinData"].asUUID(), data);
  568. }
  569. // MVT_BOOL
  570. template<> template<>
  571. void LLSDMessageBuilderTestObject::test<39>()
  572. {
  573. BOOL valueTrue = true;
  574. BOOL valueFalse = false;
  575. LLMsgData* md = new LLMsgData("testMessage");
  576. LLMsgBlkData* mbd = new LLMsgBlkData("testBlock", 0);
  577. addValue(mbd, (char *)"testBoolFalse", &valueFalse, MVT_BOOL, sizeof(BOOL));
  578. addValue(mbd, (char *)"testBoolTrue", &valueTrue, MVT_BOOL, sizeof(BOOL));
  579. md->addBlock(mbd);
  580. LLSDMessageBuilder builder = defaultBuilder();
  581. builder.copyFromMessageData(*md);
  582. LLSD output = builder.getMessage();
  583. ensure("Ensure bools work in a message copied from legacy to llsd",
  584. output["testBlock"][0]["testBoolTrue"].asBoolean() && !output["testBlock"][0]["testBoolFalse"].asBoolean());
  585. }
  586. // MVT_IP_ADDR
  587. template<> template<>
  588. void LLSDMessageBuilderTestObject::test<40>()
  589. {
  590. U32 data(0xff887766);
  591. LLSD v = ll_sd_from_ipaddr(data);
  592. addValue(messageBlockData, (char *)"testBinData", &data, MVT_IP_ADDR, sizeof(data));
  593. messageData->addBlock(messageBlockData);
  594. LLSDMessageBuilder builder = defaultBuilder();
  595. builder.copyFromMessageData(*messageData);
  596. LLSD output = builder.getMessage();
  597. ensure_equals("Ensure MVT_IP_ADDR data works in a message copied from legacy to llsd",
  598. output["testBlock"][0]["testBinData"], v);
  599. }
  600. // MVT_IP_PORT
  601. template<> template<>
  602. void LLSDMessageBuilderTestObject::test<41>()
  603. {
  604. U16 data = 0xff88;
  605. addValue(messageBlockData, (char *)"testBinData", &data, MVT_IP_PORT, sizeof(data));
  606. messageData->addBlock(messageBlockData);
  607. LLSDMessageBuilder builder = defaultBuilder();
  608. builder.copyFromMessageData(*messageData);
  609. LLSD output = builder.getMessage();
  610. ensure_equals("Ensure MVT_IP_PORT data works in a message copied from legacy to llsd",
  611. output["testBlock"][0]["testBinData"].asInteger(), data);
  612. }
  613. // MVT_U16Vec3
  614. template<> template<>
  615. void LLSDMessageBuilderTestObject::test<42>()
  616. {
  617. U16 data[3] = {0,1,2};
  618. addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16Vec3, sizeof(data));
  619. messageData->addBlock(messageBlockData);
  620. LLSDMessageBuilder builder = defaultBuilder();
  621. builder.copyFromMessageData(*messageData);
  622. LLSD output = builder.getMessage();
  623. std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  624. ensure("Ensure MVT_U16Vec3 data copied from legacy to llsd give a valid vector", v.size() > 0);
  625. ensure_memory_matches("Ensure MVT_U16Vec3 data works in a message copied from legacy to llsd",
  626. (U16*)&v[0], 6, data, 6);
  627. }
  628. // MVT_U16Quat
  629. template<> template<>
  630. void LLSDMessageBuilderTestObject::test<43>()
  631. {
  632. U16 data[4] = {0,1,2,4};
  633. addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16Quat, sizeof(data));
  634. messageData->addBlock(messageBlockData);
  635. LLSDMessageBuilder builder = defaultBuilder();
  636. builder.copyFromMessageData(*messageData);
  637. LLSD output = builder.getMessage();
  638. std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  639. ensure("Ensure MVT_U16Quat data copied from legacy to llsd give a valid vector", v.size() > 0);
  640. ensure_memory_matches("Ensure MVT_U16Quat data works in a message copied from legacy to llsd",
  641. (U16*)&v[0], 8, data, 8);
  642. }
  643. // MVT_S16Array
  644. template<> template<>
  645. void LLSDMessageBuilderTestObject::test<44>()
  646. {
  647. S16 data[19] = {0,-1,2,-4,5,-6,7,-8,9,-10,11,-12,13,-14,15,16,17,18};
  648. addValue(messageBlockData, (char *)"testBinData", &data, MVT_S16Array, sizeof(data));
  649. messageData->addBlock(messageBlockData);
  650. LLSDMessageBuilder builder = defaultBuilder();
  651. builder.copyFromMessageData(*messageData);
  652. LLSD output = builder.getMessage();
  653. std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  654. ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
  655. ensure_memory_matches("Ensure MVT_S16Array data works in a message copied from legacy to llsd",
  656. (U16*)&v[0], 19, data, 19);
  657. }
  658. template<> template<>
  659. void LLSDMessageBuilderTestObject::test<45>()
  660. {
  661. LLMessageTemplate messageTemplate = defaultTemplate();
  662. messageTemplate.addBlock(defaultTemplateBlock(MVT_U8, 1));
  663. U8 inValue = 2;
  664. LLTemplateMessageBuilder* template_builder = defaultTemplateBuilder(messageTemplate);
  665. template_builder->addU8(_PREHASH_Test0, inValue);
  666. LLSDMessageBuilder builder;
  667. builder.copyFromMessageData(*template_builder->getCurrentMessage());
  668. LLSD output = builder.getMessage();
  669. ensure_equals(output["Test0"][0]["Test0"].asInteger(), 2);
  670. }
  671. template<> template<>
  672. void LLSDMessageBuilderTestObject::test<46>()
  673. {
  674. LLMessageTemplate messageTemplate = defaultTemplate();
  675. messageTemplate.addBlock(defaultTemplateBlock(MVT_VARIABLE, 1));
  676. std::string inValue = "testing";
  677. LLTemplateMessageBuilder* builder = defaultTemplateBuilder(messageTemplate);
  678. builder->addString(_PREHASH_Test0, inValue.c_str());
  679. LLSDMessageBuilder sd_builder;
  680. sd_builder.copyFromMessageData(*builder->getCurrentMessage());
  681. LLSD output = sd_builder.getMessage();
  682. ensure_equals(output["Test0"][0]["Test0"].asString(), std::string("testing"));
  683. }
  684. }