void verifyChange(LLNameValue* changed)
{
std::string str = "";
str += "Expected Value of type: ";
str += NameValueTypeStrings[mExpectedNameValueType];
str += "not equal";
switch(mExpectedNameValueType)
{
case NVT_STRING:
ensure_memory_matches(str.c_str(), changed->getString(), strlen(changed->getString()), mExpectedNameValueReference.string, strlen(mExpectedNameValueReference.string));
break;
case NVT_ASSET:
ensure_memory_matches(str.c_str(), changed->getAsset(), strlen(changed->getAsset()), mExpectedNameValueReference.string, strlen(mExpectedNameValueReference.string));
break;
case NVT_F32:
ensure(str, *(changed->getF32()) == *mExpectedNameValueReference.f32);
break;
case NVT_S32:
ensure(str, *(changed->getS32()) == *mExpectedNameValueReference.s32);
break;
case NVT_U32:
ensure(str, *(changed->getU32()) == *mExpectedNameValueReference.u32);
break;
case NVT_VEC3:
ensure(str, *(changed->getVec3()) == *mExpectedNameValueReference.vec3);
break;
case NVT_U64:
ensure(str, *(changed->getU64()) == *mExpectedNameValueReference.u64);
break;
default:
break;
}
}
void bit_pack_object_t::test<2>()
{
U8 packbuffer[255];
U8 unpackbuffer[255];
int pack_bufsize = 0;
int unpack_bufsize = 0;
LLBitPack bitpack(packbuffer, 255);
char str[] = "SecondLife";
int len = sizeof(str);
pack_bufsize = bitpack.bitPack((U8*) str, len*8);
pack_bufsize = bitpack.flushBitPack();
LLBitPack bitunpack(packbuffer, pack_bufsize*8);
unpack_bufsize = bitunpack.bitUnpack(&unpackbuffer[0], 8);
ensure("bitPack: individual unpack: 0", unpackbuffer[0] == (U8) str[0]);
unpack_bufsize = bitunpack.bitUnpack(&unpackbuffer[0], 8);
ensure("bitPack: individual unpack: 1", unpackbuffer[0] == (U8) str[1]);
unpack_bufsize = bitunpack.bitUnpack(&unpackbuffer[0], 8);
ensure("bitPack: individual unpack: 2", unpackbuffer[0] == (U8) str[2]);
unpack_bufsize = bitunpack.bitUnpack(&unpackbuffer[0], 8);
ensure("bitPack: individual unpack: 3", unpackbuffer[0] == (U8) str[3]);
unpack_bufsize = bitunpack.bitUnpack(&unpackbuffer[0], 8);
ensure("bitPack: individual unpack: 4", unpackbuffer[0] == (U8) str[4]);
unpack_bufsize = bitunpack.bitUnpack(&unpackbuffer[0], 8);
ensure("bitPack: individual unpack: 5", unpackbuffer[0] == (U8) str[5]);
unpack_bufsize = bitunpack.bitUnpack(unpackbuffer, 8*4); // Life
ensure_memory_matches("bitPack: 4 bytes unpack:", unpackbuffer, 4, str+6, 4);
}
void streamtools_object::test<25>()
{
std::string str = "First Line.\nSecond Line\n";
std::istringstream is(str);
char buf[255] = {0};
fullread(is, buf, 255);
ensure_memory_matches("fullread: read with newlines", (void*) buf, str.size()-1, (void*) str.c_str(), str.size()-1);
is.clear();
is.str(str = "First Line.\nSecond Line\n");
memset(buf, 0, 255);
char expected_string[] = "First Line.\nSecond";
int len = sizeof(expected_string)-1;
fullread(is, buf, len);
ensure_memory_matches("fullread: read with newlines", (void*) buf, len, (void*) &expected_string, len);
}
void cipher_object_t::test<4>()
{
const char str[] = "SecondLife";
const S32 str_len = sizeof(str);
U8 encrypted[str_len];
U8 decrypted[str_len];
LLNullCipher nullCipher;
LLNullCipher nullCipher1;
U32 length = nullCipher.requiredEncryptionSpace(50);
ensure("LLNullCipher::requiredEncryptionSpace() function failed", (length == 50));
U32 len1 = nullCipher.encrypt((U8 *) str, str_len, encrypted, str_len);
ensure_memory_matches("LLNullCipher - Source transformed during encryption.", encrypted, len1, str, str_len);
U32 len2 = nullCipher1.decrypt(encrypted, str_len, decrypted, str_len);
ensure_memory_matches("LLNullCipher - Decryption failed", decrypted, len2, str, str_len);
}
void buffer_object_t::test<3>()
{
S32 channel = 30;
const char str[] = "SecondLife";
S32 len = sizeof(str);
LLSegment segment(channel, (U8*)str, len);
ensure("LLSegment get functions failed", (30 == segment.getChannel() && len == segment.size() && (U8*)str == segment.data()));
ensure_memory_matches("LLSegment::data() failed", segment.data(), segment.size(), (U8*)str, len);
ensure("LLSegment isOnChannel() function failed", (TRUE == segment.isOnChannel(channel)));
}
void cipher_object_t::test<3>()
{
U32 padNum = 0x12349087;
const U8* pad = (U8*) &padNum;
const U32 pad_len = sizeof(U32);
char str[] = "To Be Ciphered a long string.........!!!.";
char str1[] = "To Be Ciphered a long string.........!!!."; // same as str
const S32 str_len = sizeof(str);
LLXORCipher xorCipher(pad, pad_len);
LLXORCipher xorCipher1(pad, pad_len);
xorCipher.encrypt((U8 *) str, str_len);
// it should not be the same as original data!
ensure("LLXORCipher: In Place encrypt failed", memcmp(str, str1, str_len) != 0);
xorCipher1.decrypt((U8 *) str, str_len);
// it should not be the same as original data!
ensure_memory_matches("LLXORCipher: In Place decrypt failed", str, str_len, str1, str_len);
}
void bit_pack_object_t::test<1>()
{
U8 packbuffer[255];
U8 unpackbuffer[255];
int pack_bufsize = 0;
int unpack_bufsize = 0;
LLBitPack bitpack(packbuffer, 255);
char str[] = "SecondLife is a 3D virtual world";
int len = sizeof(str);
pack_bufsize = bitpack.bitPack((U8*) str, len*8);
pack_bufsize = bitpack.flushBitPack();
LLBitPack bitunpack(packbuffer, pack_bufsize*8);
unpack_bufsize = bitunpack.bitUnpack(unpackbuffer, len*8);
ensure("bitPack: unpack size should be same as string size prior to pack", len == unpack_bufsize);
ensure_memory_matches("str->bitPack->bitUnpack should be equal to string", str, len, unpackbuffer, unpack_bufsize);
}
void cipher_object_t::test<1>()
{
const U32 len = 3;
const U8 pad[] = "abc";
const char str[] = "SecondLife";
const S32 str_len = sizeof(str);
U8 encrypted[str_len];
U8 decrypted[str_len];
LLXORCipher xorCipher(pad, len);
LLXORCipher xorCipher1(pad, len);
U32 length = xorCipher.requiredEncryptionSpace(50);
ensure("requiredEncryptionSpace() function failed", (length == 50));
U32 lenEncrypted = xorCipher.encrypt((U8 *) str, str_len, encrypted, str_len);
ensure("Encryption failed", (lenEncrypted == str_len));
U32 lenDecrypted = xorCipher1.decrypt(encrypted, str_len, decrypted, str_len);
ensure("Decryption failed", (lenDecrypted == str_len));
ensure_memory_matches("LLXORCipher Encrypt/Decrypt failed", str, str_len, decrypted, lenDecrypted);
}
void cipher_object_t::test<2>()
{
const U8 pad[] = "ABCDEFGHIJKLMNOPQ"; // pad len longer than data to be ciphered
const U32 pad_len = sizeof(pad);
const U8 pad1[] = "SecondLife";
const U32 pad_len1 = sizeof(pad1);
const char str[] = "To Be Ciphered";
const S32 str_len = sizeof(str);
U8 encrypted[str_len];
U8 decrypted[str_len];
LLXORCipher xorCipher(pad, pad_len);
LLXORCipher xorCipher1(pad1, pad_len1);
xorCipher.encrypt((U8 *) str, str_len, encrypted, str_len);
// make xorCipher1 same as xorCipher..so that xorCipher1 can decrypt what was
// encrypted using xorCipher
xorCipher1 = xorCipher;
U32 lenDecrypted = xorCipher1.decrypt(encrypted, str_len, decrypted, str_len);
ensure_memory_matches("LLXORCipher operator= failed", str, str_len, decrypted, lenDecrypted);
}