test

lltemplatemessagebuilder_tut.cpp

Go to the documentation of this file.
00001 
00033 #include <tut/tut.h>
00034 #include "linden_common.h"
00035 #include "lltut.h"
00036 
00037 #include "llapr.h"
00038 #include "llmessagetemplate.h"
00039 #include "llquaternion.h"
00040 #include "lltemplatemessagebuilder.h"
00041 #include "lltemplatemessagereader.h"
00042 #include "llversionserver.h"
00043 #include "message_prehash.h"
00044 #include "u64.h"
00045 #include "v3dmath.h"
00046 #include "v3math.h"
00047 #include "v4math.h"
00048 
00049 namespace tut
00050 {       
00051         static LLTemplateMessageBuilder::message_template_name_map_t nameMap;
00052         static LLTemplateMessageReader::message_template_number_map_t numberMap;
00053 
00054         struct LLTemplateMessageBuilderTestData 
00055         {
00056                 static LLMessageTemplate defaultTemplate()
00057                 {
00058                         static bool init = false;
00059                         if(! init)
00060                         {
00061                                 ll_init_apr();
00062                                 start_messaging_system("notafile", 13035,
00063                                                                            LL_VERSION_MAJOR,
00064                                                                            LL_VERSION_MINOR,        
00065                                                                            LL_VERSION_PATCH,        
00066                                                                            FALSE,        
00067                                                                            "notasharedsecret");
00068                                 init_prehash_data();
00069                                 init = true;
00070                         }
00071                         return LLMessageTemplate(_PREHASH_TestMessage, 1, MFT_HIGH);
00072                 }
00073 
00074                 static LLMessageBlock* defaultBlock(const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
00075                 {
00076                         return createBlock(_PREHASH_Test0, type, size, block);
00077                 }
00078 
00079                 static LLMessageBlock* createBlock(char* name, const EMsgVariableType type = MVT_NULL, const S32 size = 0, EMsgBlockType block = MBT_VARIABLE)
00080                 {
00081                         LLMessageBlock* result = new LLMessageBlock(name, block);
00082                         if(type != MVT_NULL)
00083                         {
00084                                 result->addVariable(_PREHASH_Test0, type, size);
00085                         }
00086                         return result;
00087                 }
00088 
00089                 static LLTemplateMessageBuilder* defaultBuilder(LLMessageTemplate& messageTemplate, char* name = _PREHASH_Test0)
00090                 {
00091                         nameMap[_PREHASH_TestMessage] = &messageTemplate;
00092                         LLTemplateMessageBuilder* builder = new LLTemplateMessageBuilder(nameMap);
00093                         builder->newMessage(_PREHASH_TestMessage);
00094                         builder->nextBlock(name);
00095                         return builder;
00096                 }
00097 
00099                 static LLTemplateMessageReader* setReader(
00100                         LLMessageTemplate& messageTemplate,
00101                         LLTemplateMessageBuilder* builder,
00102                         U8 offset = 0)
00103                 {
00104                         numberMap[1] = &messageTemplate;
00105                         const U32 bufferSize = 1024;
00106                         U8 buffer[bufferSize];
00107                         // zero out the packet ID field
00108                         memset(buffer, 0, LL_PACKET_ID_SIZE);
00109                         U32 builtSize = builder->buildMessage(buffer, bufferSize, offset);
00110                         delete builder;
00111                         LLTemplateMessageReader* reader = new LLTemplateMessageReader(numberMap);
00112                         reader->validateMessage(buffer, builtSize, LLHost());
00113                         reader->readMessage(buffer, LLHost());
00114                         return reader;
00115                 }
00116 
00117         };
00118         
00119         typedef test_group<LLTemplateMessageBuilderTestData>    LLTemplateMessageBuilderTestGroup;
00120         typedef LLTemplateMessageBuilderTestGroup::object               LLTemplateMessageBuilderTestObject;
00121         LLTemplateMessageBuilderTestGroup templateMessageBuilderTestGroup("LLTemplateMessageBuilder");
00122         
00123         template<> template<>
00124         void LLTemplateMessageBuilderTestObject::test<1>()
00125                 // construction and test of undefined
00126         {
00127                 LLMessageTemplate messageTemplate = defaultTemplate();
00128                 messageTemplate.addBlock(defaultBlock());
00129                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00130                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00131                 delete reader;
00132         }
00133         
00134         template<> template<>
00135         void LLTemplateMessageBuilderTestObject::test<2>()
00136                  // BOOL
00137         {
00138                 LLMessageTemplate messageTemplate = defaultTemplate();
00139                 messageTemplate.addBlock(defaultBlock(MVT_BOOL, 1));
00140                 BOOL outValue, inValue = TRUE;
00141                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00142                 builder->addBOOL(_PREHASH_Test0, inValue);
00143                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00144                 reader->getBOOL(_PREHASH_Test0, _PREHASH_Test0, outValue);
00145                 ensure_equals("Ensure BOOL", inValue, outValue);
00146                 delete reader;
00147         }
00148 
00149         template<> template<>
00150         void LLTemplateMessageBuilderTestObject::test<3>()
00151                  // U8
00152         {
00153                 LLMessageTemplate messageTemplate = defaultTemplate();
00154                 messageTemplate.addBlock(defaultBlock(MVT_U8, 1));
00155                 U8 outValue, inValue = 2;
00156                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00157                 builder->addU8(_PREHASH_Test0, inValue);
00158                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00159                 reader->getU8(_PREHASH_Test0, _PREHASH_Test0, outValue);
00160                 ensure_equals("Ensure U8", inValue, outValue);
00161                 delete reader;
00162         }
00163 
00164         template<> template<>
00165         void LLTemplateMessageBuilderTestObject::test<4>()
00166                  // S16
00167         {
00168                 LLMessageTemplate messageTemplate = defaultTemplate();
00169                 messageTemplate.addBlock(defaultBlock(MVT_S16, 2));
00170                 S16 outValue, inValue = 90;
00171                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00172                 builder->addS16(_PREHASH_Test0, inValue);
00173                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00174                 reader->getS16(_PREHASH_Test0, _PREHASH_Test0, outValue);
00175                 ensure_equals("Ensure S16", inValue, outValue);
00176                 delete reader;
00177         }
00178 
00179         template<> template<>
00180         void LLTemplateMessageBuilderTestObject::test<5>()
00181                  // U16
00182         {
00183                 LLMessageTemplate messageTemplate = defaultTemplate();
00184                 messageTemplate.addBlock(defaultBlock(MVT_U16, 2));
00185                 U16 outValue, inValue = 3;
00186                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00187                 builder->addU16(_PREHASH_Test0, inValue);
00188                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00189                 reader->getU16(_PREHASH_Test0, _PREHASH_Test0, outValue);
00190                 ensure_equals("Ensure U16", inValue, outValue);
00191                 delete reader;
00192         }
00193 
00194         template<> template<>
00195         void LLTemplateMessageBuilderTestObject::test<6>()
00196                  // S32
00197         {
00198                 LLMessageTemplate messageTemplate = defaultTemplate();
00199                 messageTemplate.addBlock(defaultBlock(MVT_S32, 4));
00200                 S32 outValue, inValue = 44;
00201                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00202                 builder->addS32(_PREHASH_Test0, inValue);
00203                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00204                 reader->getS32(_PREHASH_Test0, _PREHASH_Test0, outValue);
00205                 ensure_equals("Ensure S32", inValue, outValue);
00206                 delete reader;
00207         }
00208 
00209         template<> template<>
00210         void LLTemplateMessageBuilderTestObject::test<7>()
00211                  // F32
00212         {
00213                 LLMessageTemplate messageTemplate = defaultTemplate();
00214                 messageTemplate.addBlock(defaultBlock(MVT_F32, 4));
00215                 F32 outValue, inValue = 121.44f;
00216                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00217                 builder->addF32(_PREHASH_Test0, inValue);
00218                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00219                 reader->getF32(_PREHASH_Test0, _PREHASH_Test0, outValue);
00220                 ensure_equals("Ensure F32", inValue, outValue);
00221                 delete reader;
00222         }
00223 
00224         template<> template<>
00225         void LLTemplateMessageBuilderTestObject::test<8>()
00226                  // U32
00227         {
00228                 LLMessageTemplate messageTemplate = defaultTemplate();
00229                 messageTemplate.addBlock(defaultBlock(MVT_U32, 4));
00230                 U32 outValue, inValue = 88;
00231                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00232                 builder->addU32(_PREHASH_Test0, inValue);
00233                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00234                 reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
00235                 ensure_equals("Ensure U32", inValue, outValue);
00236                 delete reader;
00237         }
00238 
00239         template<> template<>
00240         void LLTemplateMessageBuilderTestObject::test<9>()
00241                  // U64
00242         {
00243                 LLMessageTemplate messageTemplate = defaultTemplate();
00244                 messageTemplate.addBlock(defaultBlock(MVT_U64, 8));
00245                 U64 outValue, inValue = 121;
00246                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00247                 builder->addU64(_PREHASH_Test0, inValue);
00248                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00249                 reader->getU64(_PREHASH_Test0, _PREHASH_Test0, outValue);
00250                 ensure_equals("Ensure U64", inValue, outValue);
00251                 delete reader;
00252         }
00253 
00254         template<> template<>
00255         void LLTemplateMessageBuilderTestObject::test<10>()
00256                  // F64
00257         {
00258                 LLMessageTemplate messageTemplate = defaultTemplate();
00259                 messageTemplate.addBlock(defaultBlock(MVT_F64, 8));
00260                 F64 outValue, inValue = 3232143.33;
00261                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00262                 builder->addF64(_PREHASH_Test0, inValue);
00263                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00264                 reader->getF64(_PREHASH_Test0, _PREHASH_Test0, outValue);
00265                 ensure_equals("Ensure F64", inValue, outValue);
00266                 delete reader;
00267         }
00268 
00269         template<> template<>
00270         void LLTemplateMessageBuilderTestObject::test<11>()
00271                  // Vector3
00272         {
00273                 LLMessageTemplate messageTemplate = defaultTemplate();
00274                 messageTemplate.addBlock(defaultBlock(MVT_LLVector3, 12));
00275                 LLVector3 outValue, inValue = LLVector3(1,2,3);
00276                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00277                 builder->addVector3(_PREHASH_Test0, inValue);
00278                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00279                 reader->getVector3(_PREHASH_Test0, _PREHASH_Test0, outValue);
00280                 ensure_equals("Ensure LLVector3", inValue, outValue);
00281                 delete reader;
00282         }
00283 
00284         template<> template<>
00285         void LLTemplateMessageBuilderTestObject::test<12>()
00286                  // Vector4
00287         {
00288                 LLMessageTemplate messageTemplate = defaultTemplate();
00289                 messageTemplate.addBlock(defaultBlock(MVT_LLVector4, 16));
00290                 LLVector4 outValue, inValue = LLVector4(1,2,3,4);
00291                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00292                 builder->addVector4(_PREHASH_Test0, inValue);
00293                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00294                 reader->getVector4(_PREHASH_Test0, _PREHASH_Test0, outValue);
00295                 ensure_equals("Ensure LLVector4", inValue, outValue);
00296                 delete reader;
00297         }
00298 
00299         template<> template<>
00300         void LLTemplateMessageBuilderTestObject::test<13>()
00301                  // Vector3d
00302         {
00303                 LLMessageTemplate messageTemplate = defaultTemplate();
00304                 messageTemplate.addBlock(defaultBlock(MVT_LLVector3d, 24));
00305                 LLVector3d outValue, inValue = LLVector3d(1,2,3);
00306                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00307                 builder->addVector3d(_PREHASH_Test0, inValue);
00308                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00309                 reader->getVector3d(_PREHASH_Test0, _PREHASH_Test0, outValue);
00310                 ensure_equals("Ensure LLVector3d", inValue, outValue);
00311                 delete reader;
00312         }
00313 
00314         template<> template<>
00315         void LLTemplateMessageBuilderTestObject::test<14>()
00316                  // Quaternion
00317         {
00318                 LLMessageTemplate messageTemplate = defaultTemplate();
00319                 messageTemplate.addBlock(defaultBlock(MVT_LLQuaternion, 12));
00320                 LLQuaternion outValue, inValue = LLQuaternion(1,2,3,0);
00321                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00322                 builder->addQuat(_PREHASH_Test0, inValue);
00323                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00324                 reader->getQuat(_PREHASH_Test0, _PREHASH_Test0, outValue);
00325                 ensure_equals("Ensure LLQuaternion", inValue, outValue);
00326                 delete reader;
00327         }
00328 
00329         template<> template<>
00330         void LLTemplateMessageBuilderTestObject::test<15>()
00331                  // UUID
00332         {
00333                 LLMessageTemplate messageTemplate = defaultTemplate();
00334                 messageTemplate.addBlock(defaultBlock(MVT_LLUUID, 16));
00335                 LLUUID outValue, inValue;
00336                 inValue.generate();
00337                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00338                 builder->addUUID(_PREHASH_Test0, inValue);
00339                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00340                 reader->getUUID(_PREHASH_Test0, _PREHASH_Test0, outValue);
00341                 ensure_equals("Ensure UUID", inValue, outValue);
00342                 delete reader;
00343         }
00344 
00345         template<> template<>
00346         void LLTemplateMessageBuilderTestObject::test<16>()
00347                  // IPAddr
00348         {
00349                 LLMessageTemplate messageTemplate = defaultTemplate();
00350                 messageTemplate.addBlock(defaultBlock(MVT_IP_ADDR, 4));
00351                 U32 outValue, inValue = 12344556;
00352                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00353                 builder->addIPAddr(_PREHASH_Test0, inValue);
00354                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00355                 reader->getIPAddr(_PREHASH_Test0, _PREHASH_Test0, outValue);
00356                 ensure_equals("Ensure IPAddr", inValue, outValue);
00357                 delete reader;
00358         }
00359 
00360          template<> template<>
00361         void LLTemplateMessageBuilderTestObject::test<17>()
00362                  // IPPort
00363         {
00364                 LLMessageTemplate messageTemplate = defaultTemplate();
00365                 messageTemplate.addBlock(defaultBlock(MVT_IP_PORT, 2));
00366                 U16 outValue, inValue = 80;
00367                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00368                 builder->addIPPort(_PREHASH_Test0, inValue);
00369                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00370                 reader->getIPPort(_PREHASH_Test0, _PREHASH_Test0, outValue);
00371                 ensure_equals("Ensure IPPort", inValue, outValue);
00372                 delete reader;
00373         }
00374 
00375         template<> template<>
00376         void LLTemplateMessageBuilderTestObject::test<18>()
00377                 // String
00378         {
00379                 LLMessageTemplate messageTemplate = defaultTemplate();
00380                 messageTemplate.addBlock(defaultBlock(MVT_VARIABLE, 1));
00381                 std::string outValue, inValue = "testing";
00382                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00383                 builder->addString(_PREHASH_Test0, inValue.c_str());
00384                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00385                 char buffer[MAX_STRING];
00386                 reader->getString(_PREHASH_Test0, _PREHASH_Test0, MAX_STRING, buffer);
00387                 outValue = buffer;
00388                 ensure_equals("Ensure String", inValue, outValue);
00389                 delete reader;
00390         }
00391 
00392         template<> template<>
00393         void LLTemplateMessageBuilderTestObject::test<19>()
00394                 // block name !-> binary order
00395         {
00396                 U8 buffer1[MAX_BUFFER_SIZE];
00397                 memset(buffer1, 0, MAX_BUFFER_SIZE);
00398                 U8 buffer2[MAX_BUFFER_SIZE];
00399                 memset(buffer2, 0, MAX_BUFFER_SIZE);
00400                 U32 bufferSize1, bufferSize2;
00401 
00402                 // build template: Test0 before Test1
00403                 LLMessageTemplate messageTemplate = defaultTemplate();
00404                 messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
00405                 messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
00406 
00407                 // build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
00408                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
00409                 builder->addU32(_PREHASH_Test0, 0xaaaa);
00410                 builder->nextBlock(_PREHASH_Test1);
00411                 builder->addU32(_PREHASH_Test0, 0xbbbb);
00412                 bufferSize1 = builder->buildMessage(buffer1, MAX_BUFFER_SIZE, 0);
00413                 delete builder;
00414 
00415                 // build template: Test1 before Test0
00416                 messageTemplate = defaultTemplate();
00417                 messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
00418                 messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
00419 
00420                 // build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
00421                 builder = defaultBuilder(messageTemplate, _PREHASH_Test1);
00422                 builder->addU32(_PREHASH_Test0, 0xaaaa);
00423                 builder->nextBlock(_PREHASH_Test0);
00424                 builder->addU32(_PREHASH_Test0, 0xbbbb);
00425                 bufferSize2 = builder->buildMessage(buffer2, MAX_BUFFER_SIZE, 0);
00426                 delete builder;
00427 
00428                 ensure_equals("Ensure Buffer Sizes Equal", bufferSize1, bufferSize2);
00429                 ensure_equals("Ensure Buffer Contents Equal", memcmp(buffer1, buffer2, bufferSize1), 0);
00430         }
00431 
00432         template<> template<>
00433         void LLTemplateMessageBuilderTestObject::test<20>()
00434                 // block build order !-> binary order
00435         {
00436                 U8 buffer1[MAX_BUFFER_SIZE];
00437                 memset(buffer1, 0, MAX_BUFFER_SIZE);
00438                 U8 buffer2[MAX_BUFFER_SIZE];
00439                 memset(buffer2, 0, MAX_BUFFER_SIZE);
00440                 U32 bufferSize1, bufferSize2;
00441 
00442                 // build template: Test0 before Test1
00443                 LLMessageTemplate messageTemplate = defaultTemplate();
00444                 messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
00445                 messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
00446 
00447                 // build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
00448                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
00449                 builder->addU32(_PREHASH_Test0, 0xaaaa);
00450                 builder->nextBlock(_PREHASH_Test1);
00451                 builder->addU32(_PREHASH_Test0, 0xbbbb);
00452                 bufferSize1 = builder->buildMessage(buffer1, MAX_BUFFER_SIZE, 0);
00453                 delete builder;
00454 
00455                 // build message: 1st declared block var == 0xaaaa, 2nd declared block var == 0xbbbb
00456                 builder = defaultBuilder(messageTemplate, _PREHASH_Test1);
00457                 builder->addU32(_PREHASH_Test0, 0xbbbb);
00458                 builder->nextBlock(_PREHASH_Test0);
00459                 builder->addU32(_PREHASH_Test0, 0xaaaa);
00460                 bufferSize2 = builder->buildMessage(buffer2, MAX_BUFFER_SIZE, 0);
00461                 delete builder;
00462 
00463                 ensure_equals("Ensure Buffer Sizes Equal", bufferSize1, bufferSize2);
00464                 ensure_equals("Ensure Buffer Contents Equal", memcmp(buffer1, buffer2, bufferSize1), 0);
00465         }
00466 
00467         template<> template<>
00468         void LLTemplateMessageBuilderTestObject::test<21>()
00469                 // block appended in declaration -> data appended in binary
00470         {
00471                 U8 buffer1[MAX_BUFFER_SIZE];
00472                 memset(buffer1, 0, MAX_BUFFER_SIZE);
00473                 U8 buffer2[MAX_BUFFER_SIZE];
00474                 memset(buffer2, 0, MAX_BUFFER_SIZE);
00475                 U32 bufferSize1, bufferSize2;
00476 
00477                 // Build template: Test0 only
00478                 LLMessageTemplate messageTemplate = defaultTemplate();
00479                 messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
00480 
00481                 // Build message
00482                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
00483                 builder->addU32(_PREHASH_Test0, 0xaaaa);
00484                 bufferSize1 = builder->buildMessage(buffer1, MAX_BUFFER_SIZE, 0);
00485                 delete builder;
00486 
00487                 // Build template: Test0 before Test1
00488                 messageTemplate = defaultTemplate();
00489                 messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
00490                 messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
00491 
00492                 // Build message
00493                 builder = defaultBuilder(messageTemplate, _PREHASH_Test0);
00494                 builder->addU32(_PREHASH_Test0, 0xaaaa);
00495                 builder->nextBlock(_PREHASH_Test1);
00496                 builder->addU32(_PREHASH_Test0, 0xbbbb);
00497                 bufferSize2 = builder->buildMessage(buffer2, MAX_BUFFER_SIZE, 0);
00498                 delete builder;
00499 
00500                 ensure_not_equals("Ensure Buffer Sizes Not Equal", bufferSize1, bufferSize2);
00501                 ensure_equals("Ensure Buffer Prefix Equal", memcmp(buffer1, buffer2, bufferSize1), 0);
00502                 ensure_not_equals("Ensure Buffer Contents Not Equal", memcmp(buffer1, buffer2, bufferSize2), 0);
00503         }
00504 
00505         template<> template<>
00506         void LLTemplateMessageBuilderTestObject::test<22>()
00507                 // repeated penultimate block (crashes when data in LLDynamicArrayIndexed)
00508         {
00509                 U32 inTest00 = 0, inTest01 = 1, inTest1 = 2;
00510                 U32 outTest00, outTest01, outTest1;
00511                 LLMessageTemplate messageTemplate = defaultTemplate();
00512                 messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4));
00513                 messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4));
00514                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00515                 builder->addU32(_PREHASH_Test0, inTest00);
00516                 builder->nextBlock(_PREHASH_Test0);
00517                 builder->addU32(_PREHASH_Test0, inTest01);
00518                 builder->nextBlock(_PREHASH_Test1);
00519                 builder->addU32(_PREHASH_Test0, inTest1);
00520                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00521                 reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outTest00, 0);
00522                 reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outTest01, 1);
00523                 reader->getU32(_PREHASH_Test1, _PREHASH_Test0, outTest1);
00524                 ensure_equals("Ensure Test0[0]", inTest00, outTest00);
00525                 ensure_equals("Ensure Test0[1]", inTest01, outTest01);
00526                 ensure_equals("Ensure Test1", inTest1, outTest1);
00527                 delete reader;
00528         }
00529 
00530         template<> template<>
00531         void LLTemplateMessageBuilderTestObject::test<23>()
00532                 // variable repeated block name never accessed
00533         {
00534                 U32 inTest = 1, outTest;
00535                 LLMessageTemplate messageTemplate = defaultTemplate();
00536                 messageTemplate.addBlock(
00537                         createBlock(_PREHASH_Test0, MVT_U32, 4, MBT_SINGLE));
00538                 messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4));
00539 
00540                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00541                 builder->addU32(_PREHASH_Test0, inTest);
00542 
00543                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00544                 reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outTest);
00545                 S32 blockCount = reader->getNumberOfBlocks(_PREHASH_Test1);
00546                 ensure_equals("Ensure block count", blockCount, 0);
00547                 ensure_equals("Ensure Test0", inTest, outTest);
00548                 delete reader;
00549         }
00550 
00551         template<> template<>
00552         void LLTemplateMessageBuilderTestObject::test<24>()
00553                 // forwarding message
00554         {
00555                 // build template
00556                 LLMessageTemplate messageTemplate = defaultTemplate();
00557                 messageTemplate.addBlock(createBlock(_PREHASH_Test0, MVT_U32, 4));
00558 
00559                 // build message
00560                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00561                 builder->addU32(_PREHASH_Test0, 42);
00562 
00563                 // read message
00564                 LLTemplateMessageReader* reader = setReader(messageTemplate, builder);
00565 
00566                 // forward message
00567                 builder = defaultBuilder(messageTemplate);
00568                 builder->newMessage(_PREHASH_TestMessage);
00569                 reader->copyToBuilder(*builder);
00570                 U8 buffer[MAX_BUFFER_SIZE];
00571                 builder->buildMessage(buffer, MAX_BUFFER_SIZE, 0);
00572 
00573                 delete builder;
00574                 delete reader;
00575         }
00576 
00577         template<> template<>
00578         void LLTemplateMessageBuilderTestObject::test<25>()
00579                 // non-zero offset with undefined
00580         {
00581                 LLMessageTemplate messageTemplate = defaultTemplate();
00582                 messageTemplate.addBlock(defaultBlock());
00583                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00584                 LLTemplateMessageReader* reader = setReader(
00585                         messageTemplate, builder, 10);
00586                 delete reader;
00587         }
00588 
00589         template<> template<>
00590         void LLTemplateMessageBuilderTestObject::test<26>()
00591                  // non-zero offset with BOOL
00592         {
00593                 LLMessageTemplate messageTemplate = defaultTemplate();
00594                 messageTemplate.addBlock(defaultBlock(MVT_BOOL, 1));
00595                 BOOL outValue, inValue = TRUE;
00596                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00597                 builder->addBOOL(_PREHASH_Test0, inValue);
00598                 LLTemplateMessageReader* reader = setReader(
00599                         messageTemplate, builder, 1);
00600                 reader->getBOOL(_PREHASH_Test0, _PREHASH_Test0, outValue);
00601                 ensure_equals("Ensure BOOL", inValue, outValue);
00602                 delete reader;
00603         }
00604 
00605         template<> template<>
00606         void LLTemplateMessageBuilderTestObject::test<27>()
00607                  // non-zero offset with U8
00608         {
00609                 LLMessageTemplate messageTemplate = defaultTemplate();
00610                 messageTemplate.addBlock(defaultBlock(MVT_U8, 1));
00611                 U8 outValue, inValue = 2;
00612                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00613                 builder->addU8(_PREHASH_Test0, inValue);
00614                 LLTemplateMessageReader* reader = setReader(
00615                         messageTemplate, builder, 255);
00616                 reader->getU8(_PREHASH_Test0, _PREHASH_Test0, outValue);
00617                 ensure_equals("Ensure U8", inValue, outValue);
00618                 delete reader;
00619         }
00620 
00621         template<> template<>
00622         void LLTemplateMessageBuilderTestObject::test<28>()
00623                  // non-zero offset with S16
00624         {
00625                 LLMessageTemplate messageTemplate = defaultTemplate();
00626                 messageTemplate.addBlock(defaultBlock(MVT_S16, 2));
00627                 S16 outValue, inValue = 90;
00628                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00629                 builder->addS16(_PREHASH_Test0, inValue);
00630                 LLTemplateMessageReader* reader = setReader(
00631                         messageTemplate, builder, 2);
00632                 reader->getS16(_PREHASH_Test0, _PREHASH_Test0, outValue);
00633                 ensure_equals("Ensure S16", inValue, outValue);
00634                 delete reader;
00635         }
00636 
00637         template<> template<>
00638         void LLTemplateMessageBuilderTestObject::test<29>()
00639                  // non-zero offset with U16
00640         {
00641                 LLMessageTemplate messageTemplate = defaultTemplate();
00642                 messageTemplate.addBlock(defaultBlock(MVT_U16, 2));
00643                 U16 outValue, inValue = 3;
00644                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00645                 builder->addU16(_PREHASH_Test0, inValue);
00646                 LLTemplateMessageReader* reader = setReader(
00647                         messageTemplate, builder, 4);
00648                 reader->getU16(_PREHASH_Test0, _PREHASH_Test0, outValue);
00649                 ensure_equals("Ensure U16", inValue, outValue);
00650                 delete reader;
00651         }
00652 
00653         template<> template<>
00654         void LLTemplateMessageBuilderTestObject::test<30>()
00655                  // non-zero offset with S32
00656         {
00657                 LLMessageTemplate messageTemplate = defaultTemplate();
00658                 messageTemplate.addBlock(defaultBlock(MVT_S32, 4));
00659                 S32 outValue, inValue = 44;
00660                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00661                 builder->addS32(_PREHASH_Test0, inValue);
00662                 LLTemplateMessageReader* reader = setReader(
00663                         messageTemplate, builder, 4);
00664                 reader->getS32(_PREHASH_Test0, _PREHASH_Test0, outValue);
00665                 ensure_equals("Ensure S32", inValue, outValue);
00666                 delete reader;
00667         }
00668 
00669         template<> template<>
00670         void LLTemplateMessageBuilderTestObject::test<31>()
00671                  // non-zero offset with F32
00672         {
00673                 LLMessageTemplate messageTemplate = defaultTemplate();
00674                 messageTemplate.addBlock(defaultBlock(MVT_F32, 4));
00675                 F32 outValue, inValue = 121.44f;
00676                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00677                 builder->addF32(_PREHASH_Test0, inValue);
00678                 LLTemplateMessageReader* reader = setReader(
00679                         messageTemplate, builder, 16);
00680                 reader->getF32(_PREHASH_Test0, _PREHASH_Test0, outValue);
00681                 ensure_equals("Ensure F32", inValue, outValue);
00682                 delete reader;
00683         }
00684 
00685         template<> template<>
00686         void LLTemplateMessageBuilderTestObject::test<32>()
00687                  // non-zero offset with U32
00688         {
00689                 LLMessageTemplate messageTemplate = defaultTemplate();
00690                 messageTemplate.addBlock(defaultBlock(MVT_U32, 4));
00691                 U32 outValue, inValue = 88;
00692                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00693                 builder->addU32(_PREHASH_Test0, inValue);
00694                 LLTemplateMessageReader* reader = setReader(
00695                         messageTemplate, builder, 127);
00696                 reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
00697                 ensure_equals("Ensure U32", inValue, outValue);
00698                 delete reader;
00699         }
00700 
00701         template<> template<>
00702         void LLTemplateMessageBuilderTestObject::test<33>()
00703                  // non-zero offset with U64
00704         {
00705                 LLMessageTemplate messageTemplate = defaultTemplate();
00706                 messageTemplate.addBlock(defaultBlock(MVT_U64, 8));
00707                 U64 outValue, inValue = 121;
00708                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00709                 builder->addU64(_PREHASH_Test0, inValue);
00710                 LLTemplateMessageReader* reader = setReader(
00711                         messageTemplate, builder, 32);
00712                 reader->getU64(_PREHASH_Test0, _PREHASH_Test0, outValue);
00713                 ensure_equals("Ensure U64", inValue, outValue);
00714                 delete reader;
00715         }
00716 
00717         template<> template<>
00718         void LLTemplateMessageBuilderTestObject::test<34>()
00719                  // non-zero offset with F64
00720         {
00721                 LLMessageTemplate messageTemplate = defaultTemplate();
00722                 messageTemplate.addBlock(defaultBlock(MVT_F64, 8));
00723                 F64 outValue, inValue = 3232143.33;
00724                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00725                 builder->addF64(_PREHASH_Test0, inValue);
00726                 LLTemplateMessageReader* reader = setReader(
00727                         messageTemplate, builder, 128);
00728                 reader->getF64(_PREHASH_Test0, _PREHASH_Test0, outValue);
00729                 ensure_equals("Ensure F64", inValue, outValue);
00730                 delete reader;
00731         }
00732 
00733         template<> template<>
00734         void LLTemplateMessageBuilderTestObject::test<35>()
00735                  // non-zero offset with Vector3
00736         {
00737                 LLMessageTemplate messageTemplate = defaultTemplate();
00738                 messageTemplate.addBlock(defaultBlock(MVT_LLVector3, 12));
00739                 LLVector3 outValue, inValue = LLVector3(1,2,3);
00740                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00741                 builder->addVector3(_PREHASH_Test0, inValue);
00742                 LLTemplateMessageReader* reader = setReader(
00743                         messageTemplate, builder, 63);
00744                 reader->getVector3(_PREHASH_Test0, _PREHASH_Test0, outValue);
00745                 ensure_equals("Ensure LLVector3", inValue, outValue);
00746                 delete reader;
00747         }
00748 
00749         template<> template<>
00750         void LLTemplateMessageBuilderTestObject::test<36>()
00751                  // non-zero offset with Vector4
00752         {
00753                 LLMessageTemplate messageTemplate = defaultTemplate();
00754                 messageTemplate.addBlock(defaultBlock(MVT_LLVector4, 16));
00755                 LLVector4 outValue, inValue = LLVector4(1,2,3,4);
00756                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00757                 builder->addVector4(_PREHASH_Test0, inValue);
00758                 LLTemplateMessageReader* reader = setReader(
00759                         messageTemplate, builder, 64);
00760                 reader->getVector4(_PREHASH_Test0, _PREHASH_Test0, outValue);
00761                 ensure_equals("Ensure LLVector4", inValue, outValue);
00762                 delete reader;
00763         }
00764 
00765         template<> template<>
00766         void LLTemplateMessageBuilderTestObject::test<37>()
00767                  // non-zero offset with Vector3d
00768         {
00769                 LLMessageTemplate messageTemplate = defaultTemplate();
00770                 messageTemplate.addBlock(defaultBlock(MVT_LLVector3d, 24));
00771                 LLVector3d outValue, inValue = LLVector3d(1,2,3);
00772                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00773                 builder->addVector3d(_PREHASH_Test0, inValue);
00774                 LLTemplateMessageReader* reader = setReader(
00775                         messageTemplate, builder, 64);
00776                 reader->getVector3d(_PREHASH_Test0, _PREHASH_Test0, outValue);
00777                 ensure_equals("Ensure LLVector3d", inValue, outValue);
00778                 delete reader;
00779         }
00780 
00781         template<> template<>
00782         void LLTemplateMessageBuilderTestObject::test<38>()
00783                  // non-zero offset with Quaternion
00784         {
00785                 LLMessageTemplate messageTemplate = defaultTemplate();
00786                 messageTemplate.addBlock(defaultBlock(MVT_LLQuaternion, 12));
00787                 LLQuaternion outValue, inValue = LLQuaternion(1,2,3,0);
00788                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00789                 builder->addQuat(_PREHASH_Test0, inValue);
00790                 LLTemplateMessageReader* reader = setReader(
00791                         messageTemplate, builder, 12);
00792                 reader->getQuat(_PREHASH_Test0, _PREHASH_Test0, outValue);
00793                 ensure_equals("Ensure LLQuaternion", inValue, outValue);
00794                 delete reader;
00795         }
00796 
00797         template<> template<>
00798         void LLTemplateMessageBuilderTestObject::test<39>()
00799                  // non-zero offset with UUID
00800         {
00801                 LLMessageTemplate messageTemplate = defaultTemplate();
00802                 messageTemplate.addBlock(defaultBlock(MVT_LLUUID, 16));
00803                 LLUUID outValue, inValue;
00804                 inValue.generate();
00805                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00806                 builder->addUUID(_PREHASH_Test0, inValue);
00807                 LLTemplateMessageReader* reader = setReader(
00808                         messageTemplate, builder, 31);
00809                 reader->getUUID(_PREHASH_Test0, _PREHASH_Test0, outValue);
00810                 ensure_equals("Ensure UUID", inValue, outValue);
00811                 delete reader;
00812         }
00813 
00814         template<> template<>
00815         void LLTemplateMessageBuilderTestObject::test<40>()
00816                  // non-zero offset with IPAddr
00817         {
00818                 LLMessageTemplate messageTemplate = defaultTemplate();
00819                 messageTemplate.addBlock(defaultBlock(MVT_IP_ADDR, 4));
00820                 U32 outValue, inValue = 12344556;
00821                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00822                 builder->addIPAddr(_PREHASH_Test0, inValue);
00823                 LLTemplateMessageReader* reader = setReader(
00824                         messageTemplate, builder, 32);
00825                 reader->getIPAddr(_PREHASH_Test0, _PREHASH_Test0, outValue);
00826                 ensure_equals("Ensure IPAddr", inValue, outValue);
00827                 delete reader;
00828         }
00829 
00830          template<> template<>
00831         void LLTemplateMessageBuilderTestObject::test<41>()
00832                  // non-zero offset with IPPort
00833         {
00834                 LLMessageTemplate messageTemplate = defaultTemplate();
00835                 messageTemplate.addBlock(defaultBlock(MVT_IP_PORT, 2));
00836                 U16 outValue, inValue = 80;
00837                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00838                 builder->addIPPort(_PREHASH_Test0, inValue);
00839                 LLTemplateMessageReader* reader = setReader(
00840                         messageTemplate, builder, 6);
00841                 reader->getIPPort(_PREHASH_Test0, _PREHASH_Test0, outValue);
00842                 ensure_equals("Ensure IPPort", inValue, outValue);
00843                 delete reader;
00844         }
00845 
00846         template<> template<>
00847         void LLTemplateMessageBuilderTestObject::test<42>()
00848                 // non-zero offset with String
00849         {
00850                 LLMessageTemplate messageTemplate = defaultTemplate();
00851                 messageTemplate.addBlock(defaultBlock(MVT_VARIABLE, 1));
00852                 std::string outValue, inValue = "testing";
00853                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00854                 builder->addString(_PREHASH_Test0, inValue.c_str());
00855                 LLTemplateMessageReader* reader = setReader(
00856                         messageTemplate, builder, 255);
00857                 char buffer[MAX_STRING];
00858                 reader->getString(_PREHASH_Test0, _PREHASH_Test0, MAX_STRING, buffer);
00859                 outValue = buffer;
00860                 ensure_equals("Ensure String", inValue, outValue);
00861                 delete reader;
00862         }
00863 
00864         template<> template<>
00865         void LLTemplateMessageBuilderTestObject::test<43>()
00866                 // read past end of message -> default values (forward compatibility)
00867         {
00868                 // build message with single block
00869                 LLMessageTemplate messageTemplate = defaultTemplate();
00870                 messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE));
00871                 U32 outValue, outValue2, inValue = 0xbbbbbbbb;
00872                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00873                 builder->addU32(_PREHASH_Test0, inValue);
00874                 const U32 bufferSize = 1024;
00875                 U8 buffer[bufferSize];
00876                 memset(buffer, 0xaa, bufferSize);
00877                 memset(buffer, 0, LL_PACKET_ID_SIZE);
00878                 U32 builtSize = builder->buildMessage(buffer, bufferSize, 0);
00879                 delete builder;
00880 
00881                 // add block to reader template
00882                 messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4, MBT_SINGLE));
00883 
00884                 // read message value and default value
00885                 numberMap[1] = &messageTemplate;
00886                 LLTemplateMessageReader* reader = 
00887                         new LLTemplateMessageReader(numberMap);
00888                 reader->validateMessage(buffer, builtSize, LLHost());
00889                 reader->readMessage(buffer, LLHost());
00890                 reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
00891                 reader->getU32(_PREHASH_Test1, _PREHASH_Test0, outValue2);
00892                 ensure_equals("Ensure present value ", outValue, inValue);
00893                 ensure_equals("Ensure default value ", outValue2, 0);
00894                 delete reader;
00895         }
00896 
00897         template<> template<>
00898         void LLTemplateMessageBuilderTestObject::test<44>()
00899                 // read variable block past end of message -> 0 repeats
00900         {
00901                 // build message with single block
00902                 LLMessageTemplate messageTemplate = defaultTemplate();
00903                 messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE));
00904                 U32 outValue, outValue2, inValue = 0xbbbbbbbb;
00905                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00906                 builder->addU32(_PREHASH_Test0, inValue);
00907                 const U32 bufferSize = 1024;
00908                 U8 buffer[bufferSize];
00909                 memset(buffer, 0xaa, bufferSize);
00910                 memset(buffer, 0, LL_PACKET_ID_SIZE);
00911                 U32 builtSize = builder->buildMessage(buffer, bufferSize, 0);
00912                 delete builder;
00913 
00914                 // add variable block to reader template
00915                 messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_U32, 4));
00916 
00917                 // read message value and check block repeat count
00918                 numberMap[1] = &messageTemplate;
00919                 LLTemplateMessageReader* reader = 
00920                         new LLTemplateMessageReader(numberMap);
00921                 reader->validateMessage(buffer, builtSize, LLHost());
00922                 reader->readMessage(buffer, LLHost());
00923                 reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
00924                 outValue2 = reader->getNumberOfBlocks(_PREHASH_Test1);
00925                 ensure_equals("Ensure present value ", outValue, inValue);
00926                 ensure_equals("Ensure 0 repeats ", outValue2, 0);
00927                 delete reader;
00928         }
00929 
00930         template<> template<>
00931         void LLTemplateMessageBuilderTestObject::test<45>()
00932                 // read variable length data past end of message -> 0 length
00933         {
00934                 // build message with single block
00935                 LLMessageTemplate messageTemplate = defaultTemplate();
00936                 messageTemplate.addBlock(defaultBlock(MVT_U32, 4, MBT_SINGLE));
00937                 U32 outValue, outValue2, inValue = 0xbbbbbbbb;
00938                 LLTemplateMessageBuilder* builder = defaultBuilder(messageTemplate);
00939                 builder->addU32(_PREHASH_Test0, inValue);
00940                 const U32 bufferSize = 1024;
00941                 U8 buffer[bufferSize];
00942                 memset(buffer, 0xaa, bufferSize);
00943                 memset(buffer, 0, LL_PACKET_ID_SIZE);
00944                 U32 builtSize = builder->buildMessage(buffer, bufferSize, 0);
00945                 delete builder;
00946 
00947                 // add variable block to reader template
00948                 messageTemplate.addBlock(createBlock(_PREHASH_Test1, MVT_VARIABLE, 4, 
00949                                                                                          MBT_SINGLE));
00950 
00951                 // read message value and default string
00952                 numberMap[1] = &messageTemplate;
00953                 LLTemplateMessageReader* reader = 
00954                         new LLTemplateMessageReader(numberMap);
00955                 reader->validateMessage(buffer, builtSize, LLHost());
00956                 reader->readMessage(buffer, LLHost());
00957                 reader->getU32(_PREHASH_Test0, _PREHASH_Test0, outValue);
00958                 char outBuffer[bufferSize];
00959                 memset(buffer, 0xcc, bufferSize);
00960                 reader->getString(_PREHASH_Test1, _PREHASH_Test0, bufferSize, 
00961                                                   outBuffer);
00962                 outValue2 = reader->getNumberOfBlocks(_PREHASH_Test1);
00963                 ensure_equals("Ensure present value ", outValue, inValue);
00964                 ensure_equals("Ensure unchanged buffer ", strlen(outBuffer), 0);
00965                 delete reader;
00966         }
00967 }
00968
Generated on Thu Jul 1 06:09:15 2010 for Second Life Viewer by  doxygen 1.4.7