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

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

游戏引擎

开发平台：

C++ Builder

llsdmessagereader_tut.cpp：源码内容
  1. /** 
  2.  * @file llsdmessagereader_tut.cpp
  3.  * @date   February 2006
  4.  * @brief LLSDMessageReader 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"
  37. #include "v3dmath.h"
  38. #include "v3math.h"
  39. #include "v4math.h"
  40. #include "llquaternion.h"
  42. #include "message.h"
  43. #include "llsdmessagereader.h"
  44. #include "llsdutil.h"
  45. #include "llsdutil_math.h"
  47. namespace tut
  48. {
  49. struct LLSDMessageReaderTestData {
  50. static void ensureMessageName(const std::string& msg_name,
  51. const LLSD& msg_data,
  52. const std::string& expected_name)
  53. {
  54. LLSDMessageReader msg;
  55. msg.setMessage(LLMessageStringTable::getInstance()->getString(msg_name.c_str()), msg_data);
  56. ensure_equals("Ensure name", std::string(msg.getMessageName()), 
  57.   expected_name);
  58. }
  60. static void ensureNumberOfBlocks(const LLSD& msg_data,
  61. const std::string& block,
  62. S32 expected_number)
  63. {
  64. LLSDMessageReader msg;
  65. msg.setMessage("fakename", msg_data);
  66. ensure_equals("Ensure number of blocks", msg.getNumberOfBlocks(block.c_str()), 
  67.   expected_number);
  68. }
  70. static void ensureMessageSize(const LLSD& msg_data,
  71. S32 expected_size)
  72. {
  73. LLSDMessageReader msg;
  74. msg.setMessage("fakename", msg_data);
  75. ensure_equals( "Ensure size", msg.getMessageSize(), expected_size);
  76. }
  78. static void ensureBool(const LLSD& msg_data,
  79. const std::string& block,
  80. const std::string& var,
  81. S32 blocknum,
  82. BOOL expected)
  83. {
  84. LLSDMessageReader msg;
  85. msg.setMessage("fakename", msg_data);
  86. BOOL test_data;
  87. msg.getBOOL(block.c_str(), var.c_str(), test_data, blocknum);
  88.   ensure_equals( "Ensure bool field", test_data, expected);
  89.   }
  90.   };
  92.   typedef test_group<LLSDMessageReaderTestData> LLSDMessageReaderTestGroup;
  93.   typedef LLSDMessageReaderTestGroup::object LLSDMessageReaderTestObject;
  94.   LLSDMessageReaderTestGroup llsdMessageReaderTestGroup("LLSDMessageReader");
  96.   template<> template<>
  97.   void LLSDMessageReaderTestObject::test<1>()
  98.   // construction and test of empty LLSD
  99.   {
  100.   LLSD message = LLSD::emptyMap();
  102.   ensureMessageName("", message, "");
  103.   ensureNumberOfBlocks(message, "Fakeblock", 0);
  104.   ensureMessageSize(message, 0);
  105.   }
  107.   template<> template<>
  108.   void LLSDMessageReaderTestObject::test<2>()
  109.   // construction and test of simple message with one block
  110.   {
  111.   LLSD message = LLSD::emptyMap();
  112.   message["block1"] = LLSD::emptyArray();
  113.   message["block1"][0] = LLSD::emptyMap();
  114.   message["block1"][0]["Field1"] = 0;
  116.   ensureMessageName("name2", message, "name2");
  117.   ensureNumberOfBlocks(message, "block1", 1);
  118.   ensureMessageSize(message, 0);
  119.   }
  121.   template<> template<>
  122.   void LLSDMessageReaderTestObject::test<3>()
  123.   // multiple blocks
  124.   {
  125.   LLSD message = LLSD::emptyMap();
  126.   message["block1"] = LLSD::emptyArray();
  127.   BOOL bool_true = TRUE;
  128.   BOOL bool_false = FALSE;
  129.   message["block1"][0] = LLSD::emptyMap();
  130.   message["block1"][0]["BoolField1"] = bool_true;
  131. message["block1"][1] = LLSD::emptyMap();
  132.   message["block1"][1]["BoolField1"] = bool_false;
  133.   message["block1"][1]["BoolField2"] = bool_true;
  135.   ensureMessageName("name3", message, "name3");
  136.   ensureBool(message, "block1", "BoolField1", 0, TRUE);
  137.   ensureBool(message, "block1", "BoolField1", 1, FALSE);
  138.   ensureBool(message, "block1", "BoolField2", 1, TRUE);
  139.   ensureNumberOfBlocks(message, "block1", 2);
  140.   ensureMessageSize(message, 0);
  141.   }
  143.   template<typename T>
  144.   LLSDMessageReader testType(const T& value)
  145.   {
  146.   LLSD message = LLSD::emptyMap();
  147.   message["block"][0]["var"] = value;
  148.   LLSDMessageReader msg;
  149.   msg.setMessage("fakename", message);
  150.   return msg;
  151.   }
  153.   template<> template<>
  154.   void LLSDMessageReaderTestObject::test<4>()
  155.   // S8
  156.   {
  157.   S8 outValue, inValue = -3;
  158.   LLSDMessageReader msg = testType(inValue);
  159.   msg.getS8("block", "var", outValue);
  160.   ensure_equals("Ensure S8", outValue, inValue);
  161.   }
  162.   template<> template<>
  163.   void 
  164. LLSDMessageReaderTestObject::test<5>()
  165. // U8
  166. {
  167. U8 outValue, inValue = 2;
  168. LLSDMessageReader msg = testType(inValue);
  169. msg.getU8("block", "var", outValue);
  170. ensure_equals("Ensure U8", outValue, inValue);
  171. }
  172. template<> template<>
  173. void LLSDMessageReaderTestObject::test<6>()
  174. // S16
  175. {
  176. S16 outValue, inValue = 90;
  177. LLSDMessageReader msg = testType(inValue);
  178. msg.getS16("block", "var", outValue);
  179. ensure_equals("Ensure S16", outValue, inValue);
  180. }
  181. template<> template<>
  182. void LLSDMessageReaderTestObject::test<7>()
  183. // U16
  184. {
  185. U16 outValue, inValue = 3;
  186. LLSDMessageReader msg = testType(inValue);
  187. msg.getU16("block", "var", outValue);
  188. ensure_equals("Ensure S16", outValue, inValue);
  189. }
  190. template<> template<>
  191. void LLSDMessageReaderTestObject::test<8>()
  192. // S32
  193. {
  194. S32 outValue, inValue = 44;
  195. LLSDMessageReader msg = testType(inValue);
  196. msg.getS32("block", "var", outValue);
  197. ensure_equals("Ensure S32", outValue, inValue);
  198. }
  199. template<> template<>
  200. void LLSDMessageReaderTestObject::test<9>()
  201. // F32
  202. {
  203. F32 outValue, inValue = 121.44f;
  204. LLSDMessageReader msg = testType(inValue);
  205. msg.getF32("block", "var", outValue);
  206. ensure_equals("Ensure F32", outValue, inValue);
  207. }
  208. template<> template<>
  209. void LLSDMessageReaderTestObject::test<10>()
  210. // U32
  211. {
  212. U32 outValue, inValue = 88;
  213. LLSD sdValue = ll_sd_from_U32(inValue);
  214. LLSDMessageReader msg = testType(sdValue);
  215. msg.getU32("block", "var", outValue);
  216. ensure_equals("Ensure U32", outValue, inValue);
  217. }
  218. template<> template<>
  219. void LLSDMessageReaderTestObject::test<11>()
  220. // U64
  221. {
  222. U64 outValue, inValue = 121;
  223. LLSD sdValue = ll_sd_from_U64(inValue);
  224. LLSDMessageReader msg = testType(sdValue);
  225. msg.getU64("block", "var", outValue);
  226. ensure_equals("Ensure U64", outValue, inValue);
  227. }
  228. template<> template<>
  229. void LLSDMessageReaderTestObject::test<12>()
  230. // F64
  231. {
  232. F64 outValue, inValue = 3232143.33;
  233. LLSDMessageReader msg = testType(inValue);
  234. msg.getF64("block", "var", outValue);
  235. ensure_equals("Ensure F64", outValue, inValue);
  236. }
  237. template<> template<>
  238. void LLSDMessageReaderTestObject::test<13>()
  239. // String
  240. {
  241.  std::string outValue, inValue = "testing";
  242. LLSDMessageReader msg = testType<std::string>(inValue.c_str());
  244. char buffer[MAX_STRING];
  245. msg.getString("block", "var", MAX_STRING, buffer);
  246. outValue = buffer;
  247. ensure_equals("Ensure String", outValue, inValue);
  248. }
  249. template<> template<>
  250. void LLSDMessageReaderTestObject::test<14>()
  251. // Vector3
  252. {
  253.  LLVector3 outValue, inValue = LLVector3(1,2,3);
  254. LLSD sdValue = ll_sd_from_vector3(inValue);
  255. LLSDMessageReader msg = testType(sdValue);
  256. msg.getVector3("block", "var", outValue);
  257. ensure_equals("Ensure Vector3", outValue, inValue);
  258. }
  259. template<> template<>
  260. void LLSDMessageReaderTestObject::test<15>()
  261. // Vector4
  262. {
  263. LLVector4 outValue, inValue = LLVector4(1,2,3,4);
  264. LLSD sdValue = ll_sd_from_vector4(inValue);
  265. LLSDMessageReader msg = testType(sdValue);
  266. msg.getVector4("block", "var", outValue);
  267. ensure_equals("Ensure Vector4", outValue, inValue);
  268. }
  269. template<> template<>
  270. void LLSDMessageReaderTestObject::test<16>()
  271. // Vector3d
  272. {
  273.  LLVector3d outValue, inValue = LLVector3d(1,2,3);
  274.  LLSD sdValue = ll_sd_from_vector3d(inValue);
  275. LLSDMessageReader msg = testType(sdValue);
  276. msg.getVector3d("block", "var", outValue);
  277. ensure_equals("Ensure Vector3d", outValue, inValue);
  278. }
  279. template<> template<>
  280. void LLSDMessageReaderTestObject::test<17>()
  281. // Quaternion
  282. {
  283.  LLQuaternion outValue, inValue = LLQuaternion(1,2,3,4);
  284. LLSD sdValue = ll_sd_from_quaternion(inValue);
  285. LLSDMessageReader msg = testType(sdValue);
  286. msg.getQuat("block", "var", outValue);
  287. ensure_equals("Ensure Quaternion", outValue, inValue);
  288. }
  289. template<> template<>
  290. void LLSDMessageReaderTestObject::test<18>()
  291. // UUID
  292. {
  293. LLUUID outValue, inValue;
  294. inValue.generate();
  295. LLSDMessageReader msg = testType(inValue);
  296. msg.getUUID("block", "var", outValue);
  297. ensure_equals("Ensure UUID", outValue, inValue);
  298. }
  299. template<> template<>
  300. void LLSDMessageReaderTestObject::test<19>()
  301. // IPAddr
  302. {
  303. U32 outValue, inValue = 12344556;
  304. LLSD sdValue = ll_sd_from_ipaddr(inValue);
  305. LLSDMessageReader msg = testType(sdValue);
  306. msg.getIPAddr("block", "var", outValue);
  307. ensure_equals("Ensure IPAddr", outValue, inValue);
  308. }
  309. template<> template<>
  310. void LLSDMessageReaderTestObject::test<20>()
  311. // IPPort
  312. {
  313. U16 outValue, inValue = 80;
  314. LLSDMessageReader msg = testType(inValue);
  315. msg.getIPPort("block", "var", outValue);
  316. ensure_equals("Ensure IPPort", outValue, inValue);
  317. }
  318. template<> template<>
  319. void LLSDMessageReaderTestObject::test<21>()
  320. // Binary 
  321. {
  322. std::vector<U8> outValue(2), inValue(2);
  323. inValue[0] = 0;
  324. inValue[1] = 1;
  325.   
  326. LLSDMessageReader msg = testType(inValue);
  327. msg.getBinaryData("block", "var", &(outValue[0]), inValue.size());
  328. ensure_equals("Ensure Binary", outValue, inValue);
  329. }
  330. }