static void BencTestDictAppend()
{
/* test insertion in ascending order */
BencDict *dict = new BencDict();
for (size_t i = 1; i <= ITERATION_COUNT; i++) {
ScopedMem<char> key(str::Format("%04u", i));
utassert(str::Len(key) == 4);
dict->Add(key, i);
utassert(dict->Length() == i);
utassert(dict->GetInt(key));
utassert(!dict->GetString(key));
utassert(!dict->GetArray(key));
utassert(!dict->GetDict(key));
}
BencInt *intObj = dict->GetInt("0123");
utassert(intObj && intObj->Value() == 123);
BencTestRoundtrip(dict);
delete dict;
/* test insertion in descending order */
dict = new BencDict();
for (size_t i = ITERATION_COUNT; i > 0; i--) {
ScopedMem<char> key(str::Format("%04u", i));
utassert(str::Len(key) == 4);
BencObj *obj = new BencInt(i);
dict->Add(key, obj);
utassert(dict->Length() == ITERATION_COUNT + 1 - i);
utassert(dict->GetInt(key));
}
intObj = dict->GetInt("0123");
utassert(intObj && intObj->Value() == 123);
BencTestRoundtrip(dict);
delete dict;
dict = new BencDict();
dict->Add("ab", 1);
dict->Add("KL", 2);
dict->Add("gh", 3);
dict->Add("YZ", 4);
dict->Add("ab", 5);
BencTestSerialization(dict, "d2:KLi2e2:YZi4e2:abi5e2:ghi3ee");
delete dict->Remove("gh");
delete dict->Remove("YZ");
delete dict->Remove("missing");
BencTestSerialization(dict, "d2:KLi2e2:abi5ee");
delete dict;
}
static void BencTestParseDict(const char *benc, size_t expectedLen)
{
BencObj *obj = BencObj::Decode(benc);
assert(obj);
assert(obj->Type() == BT_DICT);
assert(static_cast<BencDict *>(obj)->Length() == expectedLen);
BencTestSerialization(obj, benc);
delete obj;
}
static void BencTestParseArray(const char *benc, size_t expectedLen)
{
BencObj *obj = BencObj::Decode(benc);
utassert(obj);
utassert(obj->Type() == BT_ARRAY);
utassert(static_cast<BencArray *>(obj)->Length() == expectedLen);
BencTestSerialization(obj, benc);
delete obj;
}
static void BencTestParseInt()
{
struct {
const char * benc;
bool valid;
int64_t value;
} testData[] = {
{ NULL, false },
{ "", false },
{ "a", false },
{ "0", false },
{ "i", false },
{ "ie", false },
{ "i0", false },
{ "i1", false },
{ "i23", false },
{ "i-", false },
{ "i-e", false },
{ "i-0e", false },
{ "i23f", false },
{ "i2-3e", false },
{ "i23-e", false },
{ "i041e", false },
{ "i9223372036854775808e", false },
{ "i-9223372036854775809e", false },
{ "i0e", true, 0 },
{ "i1e", true, 1 },
{ "i9823e", true, 9823 },
{ "i-1e", true, -1 },
{ "i-53e", true, -53 },
{ "i123e", true, 123 },
{ "i2147483647e", true, INT_MAX },
{ "i2147483648e", true, (int64_t)INT_MAX + 1 },
{ "i-2147483648e", true, INT_MIN },
{ "i-2147483649e", true, (int64_t)INT_MIN - 1 },
{ "i9223372036854775807e", true, _I64_MAX },
{ "i-9223372036854775808e", true, _I64_MIN },
};
for (int i = 0; i < dimof(testData); i++) {
BencObj *obj = BencObj::Decode(testData[i].benc);
if (testData[i].valid) {
assert(obj);
assert(obj->Type() == BT_INT);
assert(static_cast<BencInt *>(obj)->Value() == testData[i].value);
BencTestSerialization(obj, testData[i].benc);
delete obj;
} else {
assert(!obj);
}
}
}
static void BencTestParseRawStrings()
{
BencArray array;
array.AddRaw("a\x82");
array.AddRaw("a\x82", 1);
BencString *raw = array.GetString(0);
assert(raw && str::Eq(raw->RawValue(), "a\x82"));
BencTestSerialization(raw, "2:a\x82");
raw = array.GetString(1);
assert(raw && str::Eq(raw->RawValue(), "a"));
BencTestSerialization(raw, "1:a");
BencDict dict;
dict.AddRaw("1", "a\x82");
dict.AddRaw("2", "a\x82", 1);
raw = dict.GetString("1");
assert(raw && str::Eq(raw->RawValue(), "a\x82"));
BencTestSerialization(raw, "2:a\x82");
raw = dict.GetString("2");
assert(raw && str::Eq(raw->RawValue(), "a"));
BencTestSerialization(raw, "1:a");
}
static void BencTestParseString()
{
struct {
const char * benc;
WCHAR * value;
} testData[] = {
{ NULL, NULL },
{ "", NULL },
{ "0", NULL },
{ "1234", NULL },
{ "a", NULL },
{ ":", NULL },
{ ":z", NULL },
{ "1:ab", NULL },
{ "3:ab", NULL },
{ "-2:ab", NULL },
{ "2e:ab", NULL },
{ "0:", L"" },
{ "1:a", L"a" },
{ "2::a", L":a" },
{ "4:spam", L"spam" },
{ "4:i23e", L"i23e" },
{ "5:\xC3\xA4\xE2\x82\xAC", L"\u00E4\u20AC" },
};
for (int i = 0; i < dimof(testData); i++) {
BencObj *obj = BencObj::Decode(testData[i].benc);
if (testData[i].value) {
assert(obj);
assert(obj->Type() == BT_STRING);
ScopedMem<WCHAR> value(static_cast<BencString *>(obj)->Value());
assert(str::Eq(value, testData[i].value));
BencTestSerialization(obj, testData[i].benc);
delete obj;
} else {
assert(!obj);
}
}
}
