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

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

游戏引擎

开发平台：

C++ Builder

llsdmessagebuilder_tut.cpp：源码内容
  1. /** 
  2.  * @file llsdmessagebuilder_tut.cpp
  3.  * @date   February 2006
  4.  * @brief LLSDMessageBuilder 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>
  36. #include "linden_common.h"
  37. #include "lltut.h"
  38. #include "llmessagetemplate.h"
  39. #include "llsdmessagebuilder.h"
  40. #include "llsdmessagereader.h"
  41. #include "llsdtraits.h"
  42. #include "llquaternion.h"
  43. #include "u64.h"
  44. #include "v3dmath.h"
  45. #include "v3math.h"
  46. #include "v4math.h"
  47. #include "llsdutil.h"
  48. //#include "llsdutil.cpp"
  49. #include "llsdutil_math.cpp"
  50. #include "lltemplatemessagebuilder.h"
  52. namespace tut
  53. {
  54. static LLTemplateMessageBuilder::message_template_name_map_t templateNameMap;
  56.     LLMsgData* messageData = NULL;
  57.     LLMsgBlkData* messageBlockData = NULL;
  59. struct LLSDMessageBuilderTestData {
  61. LLSDMessageBuilderTestData()
  62. {
  63. messageData = new LLMsgData("testMessage");
  64. messageBlockData = new LLMsgBlkData("testBlock", 0);
  65. }
  67. static LLSDMessageBuilder defaultBuilder()
  68. {
  69. LLSDMessageBuilder builder;
  70. builder.newMessage("name");
  71. builder.nextBlock("block");
  72. return builder;
  73. }
  75. static LLSDMessageReader setReader(const LLSDMessageBuilder& builder)
  76. {
  77. LLSDMessageReader reader;
  78. reader.setMessage("name", builder.getMessage());
  79. return reader;
  80. }
  82. static void addValue(LLMsgBlkData* mbd, char* name, void* v, EMsgVariableType type, int size, int data_size = -1)
  83. {
  84. LLMsgVarData tmp(name, type);
  85. tmp.addData(v, size, type, data_size);
  86. mbd->mMemberVarData[name] = tmp;
  87. }
  90. static LLMessageBlock* defaultTemplateBlock(const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
  91. {
  92. return createTemplateBlock(_PREHASH_Test0, type, size, block);
  93. }
  95. static LLMessageBlock* createTemplateBlock(char* name, const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
  96. {
  97. LLMessageBlock* result = new LLMessageBlock(name, block);
  98. if(type != MVT_NULL)
  99. {
  100. result->addVariable(_PREHASH_Test0, type, size);
  101. }
  102. return result;
  103. }
  105. static LLTemplateMessageBuilder* defaultTemplateBuilder(LLMessageTemplate& messageTemplate, char* name = _PREHASH_Test0)
  106. {
  107. templateNameMap[_PREHASH_TestMessage] = &messageTemplate;
  108. LLTemplateMessageBuilder* builder = new LLTemplateMessageBuilder(templateNameMap);
  109. builder->newMessage(_PREHASH_TestMessage);
  110. builder->nextBlock(name);
  111. return builder;
  112. }
  114. static LLMessageTemplate defaultTemplate()
  115. {
  116. return LLMessageTemplate(_PREHASH_TestMessage, 1, MFT_HIGH);
  117. }
  118. };
  120. typedef test_group<LLSDMessageBuilderTestData> LLSDMessageBuilderTestGroup;
  121. typedef LLSDMessageBuilderTestGroup::object LLSDMessageBuilderTestObject;
  122. LLSDMessageBuilderTestGroup llsdMessageBuilderTestGroup("LLSDMessageBuilder");
  124. template<> template<>
  125. void LLSDMessageBuilderTestObject::test<1>()
  126. // construction and test of undefined
  127. {
  128.   LLSDMessageBuilder builder = defaultBuilder();
  129.   LLSDMessageReader reader = setReader(builder);
  130. }
  132. template<> template<>
  133. void LLSDMessageBuilderTestObject::test<2>()
  134.  // BOOL
  135. {
  136.   BOOL outValue, inValue = TRUE;
  137.   LLSDMessageBuilder builder = defaultBuilder();
  138.   builder.addBOOL("var", inValue);
  139.   LLSDMessageReader reader = setReader(builder);
  140.   reader.getBOOL("block", "var", outValue);
  141.   ensure_equals("Ensure BOOL", inValue, outValue);
  142. }
  144. template<> template<>
  145. void LLSDMessageBuilderTestObject::test<3>()
  146.  // U8
  147. {
  148.   U8 outValue, inValue = 2;
  149.   LLSDMessageBuilder builder = defaultBuilder();
  150.   builder.addU8("var", inValue);
  151.   LLSDMessageReader reader = setReader(builder);
  152.   reader.getU8("block", "var", outValue);
  153.   ensure_equals("Ensure U8", inValue, outValue);
  154. }
  156. template<> template<>
  157. void LLSDMessageBuilderTestObject::test<4>()
  158.  // S16
  159. {
  160.   S16 outValue, inValue = 90;
  161.   LLSDMessageBuilder builder = defaultBuilder();
  162.   builder.addS16("var", inValue);
  163.   LLSDMessageReader reader = setReader(builder);
  164.   reader.getS16("block", "var", outValue);
  165.   ensure_equals("Ensure S16", inValue, outValue);
  166. }
  168. template<> template<>
  169. void LLSDMessageBuilderTestObject::test<5>()
  170.  // U16
  171. {
  172.   U16 outValue, inValue = 3;
  173.   LLSDMessageBuilder builder = defaultBuilder();
  174.   builder.addU16("var", inValue);
  175.   LLSDMessageReader reader = setReader(builder);
  176.   reader.getU16("block", "var", outValue);
  177.   ensure_equals("Ensure U16", inValue, outValue);
  178. }
  180. template<> template<>
  181. void LLSDMessageBuilderTestObject::test<6>()
  182.  // S32
  183. {
  184.   S32 outValue, inValue = 44;
  185.   LLSDMessageBuilder builder = defaultBuilder();
  186.   builder.addS32("var", inValue);
  187.   LLSDMessageReader reader = setReader(builder);
  188.   reader.getS32("block", "var", outValue);
  189.   ensure_equals("Ensure S32", inValue, outValue);
  190. }
  192. template<> template<>
  193. void LLSDMessageBuilderTestObject::test<7>()
  194.  // F32
  195. {
  196.   F32 outValue, inValue = 121.44f;
  197.   LLSDMessageBuilder builder = defaultBuilder();
  198.   builder.addF32("var", inValue);
  199.   LLSDMessageReader reader = setReader(builder);
  200.   reader.getF32("block", "var", outValue);
  201.   ensure_equals("Ensure F32", inValue, outValue);
  202. }
  204. template<> template<>
  205. void LLSDMessageBuilderTestObject::test<8>()
  206.  // U32
  207. {
  208.   U32 outValue, inValue = 88;
  209.   LLSDMessageBuilder builder = defaultBuilder();
  210.   builder.addU32("var", inValue);
  211.   LLSDMessageReader reader = setReader(builder);
  212.   reader.getU32("block", "var", outValue);
  213.   ensure_equals("Ensure U32", inValue, outValue);
  214. }
  216. template<> template<>
  217. void LLSDMessageBuilderTestObject::test<9>()
  218.  // U64
  219. {
  220.   U64 outValue, inValue = 121;
  221.   LLSDMessageBuilder builder = defaultBuilder();
  222.   builder.addU64("var", inValue);
  223.   LLSDMessageReader reader = setReader(builder);
  224.   reader.getU64("block", "var", outValue);
  225.   ensure_equals("Ensure U64", inValue, outValue);
  226. }
  228. template<> template<>
  229. void LLSDMessageBuilderTestObject::test<10>()
  230.  // F64
  231. {
  232.   F64 outValue, inValue = 3232143.33;
  233.   LLSDMessageBuilder builder = defaultBuilder();
  234.   builder.addF64("var", inValue);
  235.   LLSDMessageReader reader = setReader(builder);
  236.   reader.getF64("block", "var", outValue);
  237.   ensure_equals("Ensure F64", inValue, outValue);
  238. }
  240. template<> template<>
  241. void LLSDMessageBuilderTestObject::test<11>()
  242.  // Vector3
  243. {
  244.   LLVector3 outValue, inValue = LLVector3(1,2,3);
  245.   LLSDMessageBuilder builder = defaultBuilder();
  246.   builder.addVector3("var", inValue);
  247.   LLSDMessageReader reader = setReader(builder);
  248.   reader.getVector3("block", "var", outValue);
  249.   ensure_equals("Ensure Vector3", inValue, outValue);
  250. }
  252. template<> template<>
  253. void LLSDMessageBuilderTestObject::test<12>()
  254.  // Vector4
  255. {
  256.   LLVector4 outValue, inValue = LLVector4(1,2,3,4);
  257.   LLSDMessageBuilder builder = defaultBuilder();
  258.   builder.addVector4("var", inValue);
  259.   LLSDMessageReader reader = setReader(builder);
  260.   reader.getVector4("block", "var", outValue);
  261.   ensure_equals("Ensure Vector4", inValue, outValue);
  262. }
  264. template<> template<>
  265. void LLSDMessageBuilderTestObject::test<13>()
  266.  // Vector3d
  267. {
  268.   LLVector3d outValue, inValue = LLVector3d(1,2,3);
  269.   LLSDMessageBuilder builder = defaultBuilder();
  270.   builder.addVector3d("var", inValue);
  271.   LLSDMessageReader reader = setReader(builder);
  272.   reader.getVector3d("block", "var", outValue);
  273.   ensure_equals("Ensure Vector3d", inValue, outValue);
  274. }
  276. template<> template<>
  277. void LLSDMessageBuilderTestObject::test<14>()
  278.  // Quaternion
  279. {
  280.   LLQuaternion outValue, inValue = LLQuaternion(1,2,3,4);
  281.   LLSDMessageBuilder builder = defaultBuilder();
  282.   builder.addQuat("var", inValue);
  283.   LLSDMessageReader reader = setReader(builder);
  284.   reader.getQuat("block", "var", outValue);
  285.   ensure_equals("Ensure Quaternion", inValue, outValue);
  286. }
  288. template<> template<>
  289. void LLSDMessageBuilderTestObject::test<15>()
  290.  // UUID
  291. {
  292.   LLUUID outValue, inValue;
  293.   inValue.generate();
  294.   LLSDMessageBuilder builder = defaultBuilder();
  295.   builder.addUUID("var", inValue);
  296.   LLSDMessageReader reader = setReader(builder);
  297.   reader.getUUID("block", "var", outValue);
  298.   ensure_equals("Ensure UUID", inValue, outValue);
  299. }
  301. template<> template<>
  302. void LLSDMessageBuilderTestObject::test<16>()
  303.  // IPAddr
  304. {
  305.   U32 outValue, inValue = 12344556;
  306.   LLSDMessageBuilder builder = defaultBuilder();
  307.   builder.addIPAddr("var", inValue);
  308.   LLSDMessageReader reader = setReader(builder);
  309.   reader.getIPAddr("block", "var", outValue);
  310.   ensure_equals("Ensure IPAddr", inValue, outValue);
  311. }
  313.  template<> template<>
  314. void LLSDMessageBuilderTestObject::test<17>()
  315.  // IPPort
  316. {
  317.  U16 outValue, inValue = 80;
  318.   LLSDMessageBuilder builder = defaultBuilder();
  319.   builder.addIPPort("var", inValue);
  320.   LLSDMessageReader reader = setReader(builder);
  321.   reader.getIPPort("block", "var", outValue);
  322.   ensure_equals("Ensure IPPort", inValue, outValue);
  323. }
  325. template<> template<>
  326. void LLSDMessageBuilderTestObject::test<18>()
  327. {
  328.  std::string outValue, inValue = "testing";
  329.   LLSDMessageBuilder builder = defaultBuilder();
  330.   builder.addString("var", inValue.c_str());
  331.   LLSDMessageReader reader = setReader(builder);
  332.   char buffer[MAX_STRING];
  333.   reader.getString("block", "var", MAX_STRING, buffer);
  334.   outValue = buffer;
  335.   ensure_equals("Ensure String", inValue, outValue);
  336. }
  338. template<> template<>
  339. void LLSDMessageBuilderTestObject::test<19>()
  340. {
  341.   LLMsgBlkData* mbd = new LLMsgBlkData("testBlock", 0);
  342.   LLMsgData* md = new LLMsgData("testMessage");
  343.   md->addBlock(mbd);
  344.   LLSDMessageBuilder builder = defaultBuilder();
  345.   
  346.   builder.copyFromMessageData(*md);
  347.   LLSD output = builder.getMessage();
  349.   ensure("Ensure message block created when copied from legacy message to llsd", output["testBlock"].isDefined());
  350. }
  352. // MVT_FIXED
  353. template<> template<>
  354. void LLSDMessageBuilderTestObject::test<20>()
  355. {
  356.   char binData[] = "abcdefghijklmnop";
  358.   addValue(messageBlockData, (char *)"testBinData", &binData, MVT_FIXED, sizeof(binData));
  359.   messageData->addBlock(messageBlockData);
  360.   LLSDMessageBuilder builder = defaultBuilder();
  361.   
  362.   builder.copyFromMessageData(*messageData);
  363.   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);
  368.   ensure_memory_matches("Ensure fixed binary data works in a message copied from legacy to llsd",
  369.   &v[0], sizeof(binData), binData, sizeof(binData));
  370. }
  372. // MVT_VARIABLE data_size 1 (U8's)
  373. template<> template<>
  374. void LLSDMessageBuilderTestObject::test<21>()
  375. {
  376.  /* U8 binData[] = "abcdefghijklmnop";
  378.   addValue(messageBlockData, "testBinData", &binData, MVT_VARIABLE, sizeof(binData), 1);
  379.   messageData->addBlock(messageBlockData);
  380.   LLSDMessageBuilder builder = defaultBuilder();
  381.   
  382.   builder.copyFromMessageData(*messageData);
  383.   LLSD output = builder.getMessage();
  385.   std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  386.   ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
  388.   ensure_memory_matches("Ensure MVT_VARIABLE U8 binary data works in a message copied from legacy to llsd",
  389.   &v[0], sizeof(binData), binData, sizeof(binData));*/
  390. }
  392. // MVT_VARIABLE data_size 2 (U16's)
  393. template<> template<>
  394. void LLSDMessageBuilderTestObject::test<22>()
  395. {
  396.   U16 binData[] = {1,2,3,4,5,6,7,8,9}; //9 shorts
  398.   addValue(messageBlockData, (char *)"testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 1, 2);
  399.   messageData->addBlock(messageBlockData);
  400.   LLSDMessageBuilder builder = defaultBuilder();
  401.   
  402.   builder.copyFromMessageData(*messageData);
  403.   LLSD output = builder.getMessage();
  405.   std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  406.   ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
  408.   ensure_memory_matches("Ensure MVT_VARIABLE U16 binary data works in a message copied from legacy to llsd",
  409.   &v[0], sizeof(binData) >> 1, binData, sizeof(binData) >> 1);
  410. }
  412. // MVT_VARIABLE data_size 4 (S32's)
  413. template<> template<>
  414. void LLSDMessageBuilderTestObject::test<23>()
  415. {
  416.   U32 binData[] = {9,8,7,6,5,4,3,2,1};
  418.   addValue(messageBlockData, (char *)"testBinData", &binData, MVT_VARIABLE, sizeof(binData) >> 2, 4);
  419.   messageData->addBlock(messageBlockData);
  420.   LLSDMessageBuilder builder = defaultBuilder();
  421.   
  422.   builder.copyFromMessageData(*messageData);
  423.   LLSD output = builder.getMessage();
  425.   std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  426.   ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
  428.   ensure_memory_matches("Ensure MVT_VARIABLE S32 binary data works in a message copied from legacy to llsd",
  429.   &v[0], sizeof(binData) >> 2, binData, sizeof(binData) >> 2);
  430. }
  432. // MVT_U8
  433. template<> template<>
  434. void LLSDMessageBuilderTestObject::test<24>()
  435. {
  436.   U8 data = 0xa5;
  438.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_U8, sizeof(data));
  439.   messageData->addBlock(messageBlockData);
  440.   LLSDMessageBuilder builder = defaultBuilder();
  441.   
  442.   builder.copyFromMessageData(*messageData);
  443.   LLSD output = builder.getMessage();
  445.   ensure_equals("Ensure MVT_U8 data works in a message copied from legacy to llsd",
  446.   output["testBlock"][0]["testBinData"].asInteger(), data);
  447. }
  449. // MVT_U16
  450. template<> template<>
  451. void LLSDMessageBuilderTestObject::test<25>()
  452. {
  453.   U16 data = 0xa55a;
  455.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16, sizeof(data));
  456.   messageData->addBlock(messageBlockData);
  457.   LLSDMessageBuilder builder = defaultBuilder();
  458.   
  459.   builder.copyFromMessageData(*messageData);
  460.   LLSD output = builder.getMessage();
  462.   ensure_equals("Ensure MVT_U16 data works in a message copied from legacy to llsd",
  463.   output["testBlock"][0]["testBinData"].asInteger(), data);
  464. }
  466. // MVT_U32
  467. template<> template<>
  468. void LLSDMessageBuilderTestObject::test<26>()
  469. {
  470.   U32 data = 0xa55a7117;
  472.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_U32, sizeof(data));
  473.   messageData->addBlock(messageBlockData);
  474.   LLSDMessageBuilder builder = defaultBuilder();
  475.   
  476.   builder.copyFromMessageData(*messageData);
  477.   LLSD output = builder.getMessage();
  479.   ensure_equals("Ensure MVT_U32 data works in a message copied from legacy to llsd",
  480.   ll_U32_from_sd(output["testBlock"][0]["testBinData"]), data);
  481. }
  483. // MVT_U64 - crush into an s32: LLSD does not support 64 bit values
  484. template<> template<>
  485. void LLSDMessageBuilderTestObject::test<27>()
  486. {
  487.   U64 data = U64L(0xa55a711711223344);
  488.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_U64, sizeof(data));
  489.   messageData->addBlock(messageBlockData);
  490.   LLSDMessageBuilder builder = defaultBuilder();
  491.   
  492.   builder.copyFromMessageData(*messageData);
  493.   LLSD output = builder.getMessage();
  495.   ensure_equals("Ensure MVT_U64 data works in a message copied from legacy to llsd",
  496.   ll_U64_from_sd(output["testBlock"][0]["testBinData"]), data);
  497. }
  499. // MVT_S8
  500. template<> template<>
  501. void LLSDMessageBuilderTestObject::test<28>()
  502. {
  503.   S8 data = -31;
  505.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_S8, sizeof(data));
  506.   messageData->addBlock(messageBlockData);
  507.   LLSDMessageBuilder builder = defaultBuilder();
  508.   
  509.   builder.copyFromMessageData(*messageData);
  510.   LLSD output = builder.getMessage();
  512.   ensure_equals("Ensure MVT_S8 data works in a message copied from legacy to llsd",
  513.   output["testBlock"][0]["testBinData"].asInteger(), data);
  514. }
  516. // MVT_S16
  517. template<> template<>
  518. void LLSDMessageBuilderTestObject::test<29>()
  519. {
  520.   S16 data = -31;
  522.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_S16, sizeof(data));
  523.   messageData->addBlock(messageBlockData);
  524.   LLSDMessageBuilder builder = defaultBuilder();
  525.   
  526.   builder.copyFromMessageData(*messageData);
  527.   LLSD output = builder.getMessage();
  529.   ensure_equals("Ensure MVT_S16 data works in a message copied from legacy to llsd",
  530.   output["testBlock"][0]["testBinData"].asInteger(), data);
  531. }
  533. // MVT_S32
  534. template<> template<>
  535. void LLSDMessageBuilderTestObject::test<30>()
  536. {
  537.   S32 data = -3100;
  539.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_S32, sizeof(data));
  540.   messageData->addBlock(messageBlockData);
  541.   LLSDMessageBuilder builder = defaultBuilder();
  542.   
  543.   builder.copyFromMessageData(*messageData);
  544.   LLSD output = builder.getMessage();
  546.   ensure_equals("Ensure MVT_S32 data works in a message copied from legacy to llsd",
  547.   output["testBlock"][0]["testBinData"].asInteger(), data);
  548. }
  550. // MVT_S64 - crush into an s32: LLSD does not support 64 bit values
  551. template<> template<>
  552. void LLSDMessageBuilderTestObject::test<31>()
  553. {
  554.   S64 data = -31003100;
  556.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_S64, sizeof(data));
  557.   messageData->addBlock(messageBlockData);
  558.   LLSDMessageBuilder builder = defaultBuilder();
  559.   
  560.   builder.copyFromMessageData(*messageData);
  561.   LLSD output = builder.getMessage();
  563.   ensure_equals("Ensure MVT_S64 data works in a message copied from legacy to llsd",
  564.   output["testBlock"][0]["testBinData"].asInteger(), (S32)data);
  565. }
  567. // MVT_F32
  568. template<> template<>
  569. void LLSDMessageBuilderTestObject::test<32>()
  570. {
  571.   F32 data = 1234.1234f;
  573.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_F32, sizeof(data));
  574.   messageData->addBlock(messageBlockData);
  575.   LLSDMessageBuilder builder = defaultBuilder();
  576.   
  577.   builder.copyFromMessageData(*messageData);
  578.   LLSD output = builder.getMessage();
  580.   ensure_equals("Ensure MVT_F32 data works in a message copied from legacy to llsd",
  581.   output["testBlock"][0]["testBinData"].asReal(), data);
  582. }
  584. // MVT_F64
  585. template<> template<>
  586. void LLSDMessageBuilderTestObject::test<33>()
  587. {
  588.   F64 data = 1234.1234;
  590.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_F64, sizeof(data));
  591.   messageData->addBlock(messageBlockData);
  592.   LLSDMessageBuilder builder = defaultBuilder();
  593.   
  594.   builder.copyFromMessageData(*messageData);
  595.   LLSD output = builder.getMessage();
  597.   ensure_equals("Ensure MVT_F64 data works in a message copied from legacy to llsd",
  598.   output["testBlock"][0]["testBinData"].asReal(), data);
  599. }
  601. // MVT_LLVector3
  602. template<> template<>
  603. void LLSDMessageBuilderTestObject::test<34>()
  604. {
  605.   LLVector3 data(1,2,3);
  607.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector3, sizeof(data));
  608.   messageData->addBlock(messageBlockData);
  609.   LLSDMessageBuilder builder = defaultBuilder();
  610.   
  611.   builder.copyFromMessageData(*messageData);
  612.   LLSD output = builder.getMessage();
  614.   ensure_equals("Ensure MVT_LLVector3 data works in a message copied from legacy to llsd",
  615.   ll_vector3_from_sd(output["testBlock"][0]["testBinData"]), data);
  616. }
  618. // MVT_LLVector3d
  619. template<> template<>
  620. void LLSDMessageBuilderTestObject::test<35>()
  621. {
  622.   LLVector3d data(1,2,3);
  624.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector3d, sizeof(data));
  625.   messageData->addBlock(messageBlockData);
  626.   LLSDMessageBuilder builder = defaultBuilder();
  627.   
  628.   builder.copyFromMessageData(*messageData);
  629.   LLSD output = builder.getMessage();
  631.   ensure_equals("Ensure MVT_LLVector3 data works in a message copied from legacy to llsd",
  632.   ll_vector3d_from_sd(output["testBlock"][0]["testBinData"]), data);
  633. }
  635. // MVT_LLVector4
  636. template<> template<>
  637. void LLSDMessageBuilderTestObject::test<36>()
  638. {
  639.   LLVector4 data(1,2,3,4);
  640.   LLSD v = ll_sd_from_vector4(data);
  642.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLVector4, sizeof(data));
  643.   messageData->addBlock(messageBlockData);
  644.   LLSDMessageBuilder builder = defaultBuilder();
  645.   
  646.   builder.copyFromMessageData(*messageData);
  647.   LLSD output = builder.getMessage();
  649.   ensure_equals("Ensure MVT_LLVector4 data works in a message copied from legacy to llsd",
  650.   output["testBlock"][0]["testBinData"], v);
  651. }
  653. // MVT_LLQuaternion
  654. template<> template<>
  655. void LLSDMessageBuilderTestObject::test<37>()
  656. {
  657.   LLQuaternion data(1,2,3,0);
  659.   //we send a quaternion packed into a vec3 (w is infered) - so sizeof(vec) == 12 bytes not 16.
  660.   LLVector3 vec = data.packToVector3();
  662.   addValue(messageBlockData, (char *)"testBinData", &vec, MVT_LLQuaternion, sizeof(vec));
  663.   messageData->addBlock(messageBlockData);
  664.   LLSDMessageBuilder builder = defaultBuilder();
  665.   
  666.   builder.copyFromMessageData(*messageData);
  667.   LLSD output = builder.getMessage();
  669.   ensure_equals("Ensure MVT_LLQuaternion data works in a message copied from legacy to llsd",
  670.   ll_quaternion_from_sd(output["testBlock"][0]["testBinData"]), data);
  671. }
  673. // MVT_LLUUID
  674. template<> template<>
  675. void LLSDMessageBuilderTestObject::test<38>()
  676. {
  677.   LLUUID data("01234567-0123-0123-0123-234567abcdef");
  679.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_LLUUID, sizeof(data));
  680.   messageData->addBlock(messageBlockData);
  681.   LLSDMessageBuilder builder = defaultBuilder();
  682.   
  683.   builder.copyFromMessageData(*messageData);
  684.   LLSD output = builder.getMessage();
  685.  
  686.   std::string v = output["testBlock"][0]["testBinData"].asUUID().asString();
  688.   ensure_equals("Ensure MVT_LLUUID data works in a message copied from legacy to llsd",
  689.   output["testBlock"][0]["testBinData"].asUUID(), data);
  690. }
  692. // MVT_BOOL
  693. template<> template<>
  694. void LLSDMessageBuilderTestObject::test<39>()
  695. {
  696.   BOOL valueTrue = true;
  697.   BOOL valueFalse = false;
  699.   LLMsgData* md = new LLMsgData("testMessage");
  700.   LLMsgBlkData* mbd = new LLMsgBlkData("testBlock", 0);
  701.   addValue(mbd, (char *)"testBoolFalse", &valueFalse, MVT_BOOL, sizeof(BOOL));
  702.   addValue(mbd, (char *)"testBoolTrue", &valueTrue, MVT_BOOL, sizeof(BOOL));
  703.   md->addBlock(mbd);
  704.   LLSDMessageBuilder builder = defaultBuilder();
  705.   
  706.   builder.copyFromMessageData(*md);
  707.   LLSD output = builder.getMessage();
  709.   ensure("Ensure bools work in a message copied from legacy to llsd",
  710.   output["testBlock"][0]["testBoolTrue"].asBoolean() && !output["testBlock"][0]["testBoolFalse"].asBoolean());
  711. }
  713. // MVT_IP_ADDR
  714. template<> template<>
  715. void LLSDMessageBuilderTestObject::test<40>()
  716. {
  717.   U32 data(0xff887766);
  718.   LLSD v = ll_sd_from_ipaddr(data);
  720.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_IP_ADDR, sizeof(data));
  721.   messageData->addBlock(messageBlockData);
  722.   LLSDMessageBuilder builder = defaultBuilder();
  723.   
  724.   builder.copyFromMessageData(*messageData);
  725.   LLSD output = builder.getMessage();
  727.   ensure_equals("Ensure MVT_IP_ADDR data works in a message copied from legacy to llsd",
  728.   output["testBlock"][0]["testBinData"], v);
  729. }
  731. // MVT_IP_PORT
  732. template<> template<>
  733. void LLSDMessageBuilderTestObject::test<41>()
  734. {
  735.   U16 data = 0xff88;
  737.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_IP_PORT, sizeof(data));
  738.   messageData->addBlock(messageBlockData);
  739.   LLSDMessageBuilder builder = defaultBuilder();
  740.   
  741.   builder.copyFromMessageData(*messageData);
  742.   LLSD output = builder.getMessage();
  744.   ensure_equals("Ensure MVT_IP_PORT data works in a message copied from legacy to llsd",
  745.   output["testBlock"][0]["testBinData"].asInteger(), data);
  746. }
  748. // MVT_U16Vec3
  749. template<> template<>
  750. void LLSDMessageBuilderTestObject::test<42>()
  751. {
  752.   U16 data[3] = {0,1,2};
  754.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16Vec3, sizeof(data));
  755.   messageData->addBlock(messageBlockData);
  756.   LLSDMessageBuilder builder = defaultBuilder();
  757.   
  758.   builder.copyFromMessageData(*messageData);
  759.   LLSD output = builder.getMessage();
  761.   std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  762.   ensure("Ensure MVT_U16Vec3 data copied from legacy to llsd give a valid vector", v.size() > 0);
  764.   ensure_memory_matches("Ensure MVT_U16Vec3 data works in a message copied from legacy to llsd",
  765.   (U16*)&v[0], 6, data, 6);
  766. }
  768. // MVT_U16Quat
  769. template<> template<>
  770. void LLSDMessageBuilderTestObject::test<43>()
  771. {
  772.   U16 data[4] = {0,1,2,4};
  774.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_U16Quat, sizeof(data));
  775.   messageData->addBlock(messageBlockData);
  776.   LLSDMessageBuilder builder = defaultBuilder();
  777.   
  778.   builder.copyFromMessageData(*messageData);
  779.   LLSD output = builder.getMessage();
  781.   std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  782.   ensure("Ensure MVT_U16Quat data copied from legacy to llsd give a valid vector", v.size() > 0);
  784.   ensure_memory_matches("Ensure MVT_U16Quat data works in a message copied from legacy to llsd",
  785.   (U16*)&v[0], 8, data, 8);
  786. }
  788. // MVT_S16Array
  789. template<> template<>
  790. void LLSDMessageBuilderTestObject::test<44>()
  791. {
  792.   S16 data[19] = {0,-1,2,-4,5,-6,7,-8,9,-10,11,-12,13,-14,15,16,17,18};
  794.   addValue(messageBlockData, (char *)"testBinData", &data, MVT_S16Array, sizeof(data));
  795.   messageData->addBlock(messageBlockData);
  796.   LLSDMessageBuilder builder = defaultBuilder();
  797.   
  798.   builder.copyFromMessageData(*messageData);
  799.   LLSD output = builder.getMessage();
  801.   std::vector<U8> v = output["testBlock"][0]["testBinData"].asBinary();
  802.   ensure("Ensure MVT_S16Array data copied from legacy to llsd give a valid vector", v.size() > 0);
  804.   ensure_memory_matches("Ensure MVT_S16Array data works in a message copied from legacy to llsd",
  805.   (U16*)&v[0], 19, data, 19);
  806. }
  808. template<> template<>
  809. void LLSDMessageBuilderTestObject::test<45>()
  810. {
  811. LLMessageTemplate messageTemplate = defaultTemplate();
  812. messageTemplate.addBlock(defaultTemplateBlock(MVT_U8, 1));
  813. U8 inValue = 2;
  814. LLTemplateMessageBuilder* template_builder = defaultTemplateBuilder(messageTemplate);
  815. template_builder->addU8(_PREHASH_Test0, inValue);
  817. LLSDMessageBuilder builder;
  818. builder.copyFromMessageData(*template_builder->getCurrentMessage());
  819. LLSD output = builder.getMessage();
  821. ensure_equals(output["Test0"][0]["Test0"].asInteger(), 2);
  823. }
  825. template<> template<>
  826. void LLSDMessageBuilderTestObject::test<46>()
  827. {
  828. LLMessageTemplate messageTemplate = defaultTemplate();
  829. messageTemplate.addBlock(defaultTemplateBlock(MVT_VARIABLE, 1));
  830. std::string inValue = "testing";
  831. LLTemplateMessageBuilder* builder = defaultTemplateBuilder(messageTemplate);
  832. builder->addString(_PREHASH_Test0, inValue.c_str());
  834. LLSDMessageBuilder sd_builder;
  835. sd_builder.copyFromMessageData(*builder->getCurrentMessage());
  836. LLSD output = sd_builder.getMessage();
  838. ensure_equals(output["Test0"][0]["Test0"].asString(), std::string("testing"));
  839. }
  841. }