Second Life Viewer: llsdmessagereader

00001 
00033 #include <tut/tut.h>
00034 #include "linden_common.h"
00035 #include "lltut.h"
00036 
00037 #include "message.h"
00038 #include "llsdmessagereader.h"
00039 #include "llsdutil.h"
00040 
00041 namespace tut
00042 {       
00043         struct LLSDMessageReaderTestData {
00044                 static void ensureMessageName(const std::string& msg_name,
00045                                                                         const LLSD& msg_data,
00046                                                                         const std::string& expected_name)
00047                 {
00048                         LLSDMessageReader msg;
00049                         msg.setMessage(gMessageStringTable.getString(msg_name.c_str()), msg_data);
00050                         ensure_equals("Ensure name", std::string(msg.getMessageName()), 
00051                                                   expected_name);
00052                 }
00053 
00054                 static void ensureNumberOfBlocks(const LLSD& msg_data,
00055                                                                         const std::string& block,
00056                                                                         S32 expected_number)
00057                 {
00058                         LLSDMessageReader msg;
00059                         msg.setMessage("fakename", msg_data);
00060                         ensure_equals("Ensure number of blocks", msg.getNumberOfBlocks(block.c_str()), 
00061                                                   expected_number);
00062                 }
00063 
00064                 static void ensureMessageSize(const LLSD& msg_data,
00065                                                                         S32 expected_size)
00066                 {
00067                         LLSDMessageReader msg;
00068                         msg.setMessage("fakename", msg_data);
00069                         ensure_equals(  "Ensure size",  msg.getMessageSize(), expected_size);
00070                 }
00071 
00072                 static void ensureBool(const LLSD& msg_data,
00073                                                                 const std::string& block,
00074                                                                 const std::string& var,
00075                                                                 S32 blocknum,
00076                                                                 BOOL expected)
00077                 {
00078                         LLSDMessageReader msg;
00079                         msg.setMessage("fakename", msg_data);
00080                         BOOL test_data;
00081                         msg.getBOOL(block.c_str(), var.c_str(), test_data, blocknum);
00082                         ensure_equals(  "Ensure bool field", test_data, expected);
00083                 }
00084         };
00085         
00086         typedef test_group<LLSDMessageReaderTestData>   LLSDMessageReaderTestGroup;
00087         typedef LLSDMessageReaderTestGroup::object              LLSDMessageReaderTestObject;
00088         LLSDMessageReaderTestGroup llsdMessageReaderTestGroup("LLSDMessageReader");
00089         
00090         template<> template<>
00091         void LLSDMessageReaderTestObject::test<1>()
00092                 // construction and test of empty LLSD
00093         {
00094                 LLSD message = LLSD::emptyMap();
00095 
00096                 ensureMessageName("", message, "");
00097                 ensureNumberOfBlocks(message, "Fakeblock", 0);
00098                 ensureMessageSize(message, 0);
00099         }
00100         
00101         template<> template<>
00102         void LLSDMessageReaderTestObject::test<2>()
00103                 // construction and test of simple message with one block
00104         {
00105                 LLSD message = LLSD::emptyMap();
00106                 message["block1"] = LLSD::emptyArray();
00107                 message["block1"][0] = LLSD::emptyMap();
00108                 message["block1"][0]["Field1"] = 0;
00109 
00110                 ensureMessageName("name2", message, "name2");
00111                 ensureNumberOfBlocks(message, "block1", 1);
00112                 ensureMessageSize(message, 0);
00113         }
00114         
00115         template<> template<>
00116         void LLSDMessageReaderTestObject::test<3>()
00117                 // multiple blocks
00118         {
00119                 LLSD message = LLSD::emptyMap();
00120                 message["block1"] = LLSD::emptyArray();
00121                 BOOL bool_true = TRUE;
00122                 BOOL bool_false = FALSE;
00123                 message["block1"][0] = LLSD::emptyMap();
00124                 message["block1"][0]["BoolField1"] = bool_true;
00125                 message["block1"][1] = LLSD::emptyMap();
00126                 message["block1"][1]["BoolField1"] = bool_false;
00127                 message["block1"][1]["BoolField2"] = bool_true;
00128 
00129                 ensureMessageName("name3", message, "name3");
00130                 ensureBool(message, "block1", "BoolField1", 0, TRUE);
00131                 ensureBool(message, "block1", "BoolField1", 1, FALSE);
00132                 ensureBool(message, "block1", "BoolField2", 1, TRUE);
00133                 ensureNumberOfBlocks(message, "block1", 2);
00134                 ensureMessageSize(message, 0);
00135         }
00136         
00137         template<typename T>
00138         LLSDMessageReader testType(const T& value)
00139         {
00140                 LLSD message = LLSD::emptyMap();
00141                 message["block"][0]["var"] = value;
00142                 LLSDMessageReader msg;
00143                 msg.setMessage("fakename", message);
00144                 return msg;
00145         }
00146 
00147         template<> template<>
00148         void LLSDMessageReaderTestObject::test<4>()
00149                 // S8
00150         {
00151                 S8 outValue, inValue = -3;
00152                 LLSDMessageReader msg = testType(inValue);
00153                 msg.getS8("block", "var", outValue);
00154                 ensure_equals("Ensure S8", outValue, inValue);
00155         }
00156         template<> template<>
00157         void 
00158         LLSDMessageReaderTestObject::test<5>()
00159                 // U8
00160         {
00161                 U8 outValue, inValue = 2;
00162                 LLSDMessageReader msg = testType(inValue);
00163                 msg.getU8("block", "var", outValue);
00164                 ensure_equals("Ensure U8", outValue, inValue);
00165         }
00166         template<> template<>
00167         void LLSDMessageReaderTestObject::test<6>()
00168                 // S16
00169         {
00170                 S16 outValue, inValue = 90;
00171                 LLSDMessageReader msg = testType(inValue);
00172                 msg.getS16("block", "var", outValue);
00173                 ensure_equals("Ensure S16", outValue, inValue);
00174         }
00175         template<> template<>
00176         void LLSDMessageReaderTestObject::test<7>()
00177                 // U16
00178         {
00179                 U16 outValue, inValue = 3;
00180                 LLSDMessageReader msg = testType(inValue);
00181                 msg.getU16("block", "var", outValue);
00182                 ensure_equals("Ensure S16", outValue, inValue);
00183         }
00184         template<> template<>
00185         void LLSDMessageReaderTestObject::test<8>()
00186                 // S32
00187         {
00188                 S32 outValue, inValue = 44;
00189                 LLSDMessageReader msg = testType(inValue);
00190                 msg.getS32("block", "var", outValue);
00191                 ensure_equals("Ensure S32", outValue, inValue);
00192         }
00193         template<> template<>
00194         void LLSDMessageReaderTestObject::test<9>()
00195                 // F32
00196         {
00197                 F32 outValue, inValue = 121.44f;
00198                 LLSDMessageReader msg = testType(inValue);
00199                 msg.getF32("block", "var", outValue);
00200                 ensure_equals("Ensure F32", outValue, inValue);
00201         }
00202         template<> template<>
00203         void LLSDMessageReaderTestObject::test<10>()
00204                 // U32
00205         {
00206                 U32 outValue, inValue = 88;
00207                 LLSD sdValue = ll_sd_from_U32(inValue);
00208                 LLSDMessageReader msg = testType(sdValue);
00209                 msg.getU32("block", "var", outValue);
00210                 ensure_equals("Ensure U32", outValue, inValue);
00211         }
00212         template<> template<>
00213         void LLSDMessageReaderTestObject::test<11>()
00214                 // U64
00215         {
00216                 U64 outValue, inValue = 121;
00217                 LLSD sdValue = ll_sd_from_U64(inValue);
00218                 LLSDMessageReader msg = testType(sdValue);
00219                 msg.getU64("block", "var", outValue);
00220                 ensure_equals("Ensure U64", outValue, inValue);
00221         }
00222         template<> template<>
00223         void LLSDMessageReaderTestObject::test<12>()
00224                 // F64
00225         {
00226                 F64 outValue, inValue = 3232143.33;
00227                 LLSDMessageReader msg = testType(inValue);
00228                 msg.getF64("block", "var", outValue);
00229                 ensure_equals("Ensure F64", outValue, inValue);
00230         }
00231         template<> template<>
00232         void LLSDMessageReaderTestObject::test<13>()
00233                 // String
00234         {
00235                  std::string outValue, inValue = "testing";
00236                 LLSDMessageReader msg = testType<std::string>(inValue.c_str());
00237                 
00238                 char buffer[MAX_STRING];
00239                 msg.getString("block", "var", MAX_STRING, buffer);
00240                 outValue = buffer;
00241                 ensure_equals("Ensure String", outValue, inValue);
00242         }
00243         template<> template<>
00244         void LLSDMessageReaderTestObject::test<14>()
00245                 // Vector3
00246         {
00247                  LLVector3 outValue, inValue = LLVector3(1,2,3);
00248                 LLSD sdValue = ll_sd_from_vector3(inValue);
00249                 LLSDMessageReader msg = testType(sdValue);
00250                 msg.getVector3("block", "var", outValue);
00251                 ensure_equals("Ensure Vector3", outValue, inValue);
00252         }
00253         template<> template<>
00254         void LLSDMessageReaderTestObject::test<15>()
00255                 // Vector4
00256         {
00257                 LLVector4 outValue, inValue = LLVector4(1,2,3,4);
00258                 LLSD sdValue = ll_sd_from_vector4(inValue);
00259                 LLSDMessageReader msg = testType(sdValue);
00260                 msg.getVector4("block", "var", outValue);
00261                 ensure_equals("Ensure Vector4", outValue, inValue);
00262         }
00263         template<> template<>
00264         void LLSDMessageReaderTestObject::test<16>()
00265                 // Vector3d
00266         {
00267                  LLVector3d outValue, inValue = LLVector3d(1,2,3);
00268                  LLSD sdValue = ll_sd_from_vector3d(inValue);
00269                 LLSDMessageReader msg = testType(sdValue);
00270                 msg.getVector3d("block", "var", outValue);
00271                 ensure_equals("Ensure Vector3d", outValue, inValue);
00272         }
00273         template<> template<>
00274         void LLSDMessageReaderTestObject::test<17>()
00275                 // Quaternion
00276         {
00277                  LLQuaternion outValue, inValue = LLQuaternion(1,2,3,4);
00278                 LLSD sdValue = ll_sd_from_quaternion(inValue);
00279                 LLSDMessageReader msg = testType(sdValue);
00280                 msg.getQuat("block", "var", outValue);
00281                 ensure_equals("Ensure Quaternion", outValue, inValue);
00282         }
00283         template<> template<>
00284         void LLSDMessageReaderTestObject::test<18>()
00285                 // UUID
00286         {
00287                 LLUUID outValue, inValue;
00288                 inValue.generate();
00289                 LLSDMessageReader msg = testType(inValue);
00290                 msg.getUUID("block", "var", outValue);
00291                 ensure_equals("Ensure UUID", outValue, inValue);
00292         }
00293         template<> template<>
00294         void LLSDMessageReaderTestObject::test<19>()
00295                 // IPAddr
00296         {
00297                 U32 outValue, inValue = 12344556;
00298                 LLSD sdValue = ll_sd_from_ipaddr(inValue);
00299                 LLSDMessageReader msg = testType(sdValue);
00300                 msg.getIPAddr("block", "var", outValue);
00301                 ensure_equals("Ensure IPAddr", outValue, inValue);
00302         }
00303         template<> template<>
00304         void LLSDMessageReaderTestObject::test<20>()
00305                 // IPPort
00306         {
00307                 U16 outValue, inValue = 80;
00308                 LLSDMessageReader msg = testType(inValue);
00309                 msg.getIPPort("block", "var", outValue);
00310                 ensure_equals("Ensure IPPort", outValue, inValue);
00311         }
00312         template<> template<>
00313         void LLSDMessageReaderTestObject::test<21>()
00314                 // Binary 
00315         {
00316                 std::vector<U8> outValue(2), inValue(2);
00317                 inValue[0] = 0;
00318                 inValue[1] = 1;
00319           
00320                 LLSDMessageReader msg = testType(inValue);
00321                 msg.getBinaryData("block", "var", &(outValue[0]), inValue.size());
00322                 ensure_equals("Ensure Binary", outValue, inValue);
00323         }
00324 }
llsdmessagereader_tut.cpp
