void checkNotStartWith(const Sid::String& test, const Sid::String& prefix)
{
const char* origData = test.data();
CPPUNIT_ASSERT_PRINTF(!test.startWith(prefix),
"startsWith() did not return false for "
"\n%s\n%s\n",
prefix.isNull() ? "(NULL)" : prefix.data(),
test.isNull() ? "(NULL)" : test.data());
CPPUNIT_ASSERT_MESSAGE("startWith() causes object to relinquish its reference!",
origData == test.data());
}
void checkUnescaping(const Sid::String& test, const Sid::String& expected)
{
const char* origData = test.data();
Sid::String unescaped=test.unescape();
CPPUNIT_ASSERT_PRINTF(unescaped == expected,
"Unescaping \"%s\" did not yield \"%s\" as "
"expected, instead yielded \"%s\"\n",
!test.isNull() ? test.data() : "(NULL)",
!expected.isNull() ? expected.data() : "(NULL)",
!unescaped.isNull() ? unescaped.data() : "(NULL)");
CPPUNIT_ASSERT_MESSAGE("unescape() causes object to relinquish its reference!",
origData == test.data());
}
void checkHexRepresentation(const Sid::String& test, const Sid::String& expected)
{
const char* origData = test.data();
Sid::String res = test.getHexRepresentation();
CPPUNIT_ASSERT_PRINTF(res == expected,
"getHexRepresentation() yielded unexpected result for value "
"\"%s\", should have been \"%s\", instead got \"%s\"\n",
test.isNull() ? "(NULL)" : test.data(),
expected.isNull() ? "(NULL)" : expected.data(),
res.isNull() ? "(NULL)" : res.data());
CPPUNIT_ASSERT_MESSAGE("getHexRepresentation() causes object to relinquish its reference!",
origData == test.data());
}
void checkFrom(bool b, const Sid::String& expected)
{
Sid::String from = Sid::String::from(b);
CPPUNIT_ASSERT_PRINTF(from == expected,
"from((bool)%s) yielded unexpected result \"%s\"\n",
b ? "true" : "false",
from.isNull() ? "(NULL)" : from.data());
}
void checkFrom(char c, const Sid::String& expected)
{
Sid::String from = Sid::String::from(c);
CPPUNIT_ASSERT_PRINTF(from == expected,
"from((char)%c) yielded unexpected result \"%s\"\n",
c,
from.isNull() ? "(NULL)" : from.data());
}
void checkFrom(uint64 n, const Sid::String& expected)
{
Sid::String from = Sid::String::from(n);
CPPUNIT_ASSERT_PRINTF(from == expected,
"from((uint64)%llu) yielded unexpected result \"%s\"\n",
n,
from.isNull() ? "(NULL)" : from.data());
}
void checkRight(const Sid::String& test,
unsigned int len,
const Sid::String& expected)
{
const char* origData = test.data();
Sid::String right = test.right(len);
CPPUNIT_ASSERT_PRINTF(right == expected,
"right(%d) did not yield expected result for:\n"
"%s\n%*s (got)\n%*s (expected)\n",
len,
test.isNull() ? "(NULL)" : test.data(),
test.size(),
right.isNull() ? "(NULL)" : right.data(),
test.size(),
expected.isNull() ? "(NULL)" : expected.data());
CPPUNIT_ASSERT_MESSAGE("right() causes object to relinquish its reference!",
origData == test.data());
}
void checkFrom(unsigned int u, unsigned int base, const Sid::String& expected)
{
Sid::String from = Sid::String::from(u, base);
CPPUNIT_ASSERT_PRINTF(from == expected,
"from((unsigned int)%u, (unsigned int)%u) yielded unexpected result \"%s\"\n",
u,
base,
from.isNull() ? "(NULL)" : from.data());
}
void checkKeyValue(const Sid::String& key,
const Sid::String& value,
const Sid::String& expected)
{
const char* keyData = key.data();
const char* valueData = value.data();
Sid::String keyValue=Sid::String::keyValue(key, value);
CPPUNIT_ASSERT_PRINTF(keyValue == expected,
"keyValue(\"%s\", \"%s\") did not yield \"%s\","
" instead got \"%s\"\n",
key.isNull() ? "(NULL)" : key.data(),
value.isNull() ? "(NULL)" : value.data(),
expected.isNull() ? "(NULL)" : expected.data(),
keyValue.isNull() ? "(NULL)" : keyValue.data());
CPPUNIT_ASSERT_MESSAGE("keyValue() causes key to relinquish its reference!",
keyData == key.data());
CPPUNIT_ASSERT_MESSAGE("keyValue() causes value to relinquish its reference!",
valueData == value.data());
}
void checkAssignment(const Sid::String& test,
const Sid::String& rhs,
const Sid::String& expected)
{
Sid::String copy(test);
const char* rhsData = rhs.data();
copy = rhs;
CPPUNIT_ASSERT_PRINTF(copy == expected,
"Assignment operator yielded unexpected result:\n"
"\"%s\" (lhs)\n"
"\"%s\" (rhs)\n"
"\"%s\" (expected)\n"
"\"%s\" (got)\n",
test.isNull() ? "(NULL)" : test.data(),
rhs.isNull() ? "(NULL)" : rhs.data(),
expected.isNull() ? "(NULL)" : rhs.data(),
copy.isNull() ? "(NULL)" : copy.data());
CPPUNIT_ASSERT_MESSAGE("Assignment operator caused rhs to relinquish its reference!",
rhs.data() == rhsData);
}
void checkConversion(const Sid::String& test, const char* expected)
{
const char* origData = test.data();
CPPUNIT_ASSERT_PRINTF(!strcmp(test, expected),
"operator const char* did not yield \"%s\" as "
"expected, got \"%s\" instead.\n",
test.isNull() ? "(NULL)" : (const char*)test,
expected);
CPPUNIT_ASSERT_MESSAGE("operator const char*() causes object to relinquish its reference!",
origData == test.data());
}
void checkAppend(const Sid::String& lhs,
const char* rhs,
const Sid::String& expected)
{
Sid::String test(lhs);
CPPUNIT_ASSERT(test == lhs);
test += rhs;
CPPUNIT_ASSERT_PRINTF(test == expected,
"operator+=(const char*) yielded unexpected"
" result:\n"
"lhs was \"%s\"\n"
"rhs was \"%s\"\n"
"expected \"%s\"\n"
"got \"%s\"\n",
lhs.isNull() ? "(NULL)" : lhs.data(),
rhs ? rhs : "(NULL)",
expected.isNull() ? "(NULL)" : expected.data(),
test.isNull() ? "(NULL)" : test.data());
checkAppend(lhs, Sid::String(rhs), expected);
}
void checkAppend(const Sid::String& lhs,
const Sid::String& rhs,
const Sid::String& expected)
{
const char* origData = rhs.data();
Sid::String test(lhs);
test += rhs;
CPPUNIT_ASSERT_PRINTF(test == expected,
"operator+=(const Sid::String&) yielded unexpected"
" result:\n"
"lhs was \"%s\"\n"
"rhs was \"%s\"\n"
"expected \"%s\"\n"
"got \"%s\"\n",
lhs.isNull() ? "(NULL)" : lhs.data(),
rhs.isNull() ? "(NULL)" : rhs.data(),
expected.isNull() ? "(NULL)" : expected.data(),
test.isNull() ? "(NULL)" : test.data());
CPPUNIT_ASSERT_MESSAGE("operator+=() causes rhs to relinquish its reference!",
origData == rhs.data());
}
void checkToBool(const Sid::String& test, bool expected)
{
const char* origData = test.data();
bool res = test.toBool();
CPPUNIT_ASSERT_PRINTF(res == expected,
"toBool() yielded unexpected result for value "
"\"%s\", should have been %s\n",
test.isNull() ? "(NULL)" : test.data(),
expected ? "true" : "false");
CPPUNIT_ASSERT_MESSAGE("toBool() causes object to relinquish its reference!",
origData == test.data());
}
void StringListTestCase::appendEmptyStringTest()
{
Sid::List_String test1;
Sid::String string;
CPPUNIT_ASSERT(string.isNull());
test1.append(string);
CPPUNIT_ASSERT(test1.size() == 1);
CPPUNIT_ASSERT(!test1[0].isNull());
CPPUNIT_ASSERT(test1[0] == "");
}
void checkToUInt64(const Sid::String& test, uint64 expected)
{
const char* origData = test.data();
uint64 res = test.toUInt64();
CPPUNIT_ASSERT_PRINTF(res == expected,
"toUInt64() yielded unexpected result for value "
"\"%s\", should have been %ull, instead got %ull\n",
test.isNull() ? "(NULL)" : test.data(),
expected,
res);
CPPUNIT_ASSERT_MESSAGE("toUInt64() causes object to relinquish its reference!",
origData == test.data());
}
void checkTrim(const Sid::String& test,
const Sid::String& toTrim,
const Sid::String& expected)
{
const char* origData = test.data();
Sid::String trimmed = test.trim(toTrim);
CPPUNIT_ASSERT_PRINTF(trimmed == expected,
"trim(\"%s\") did not yield expected result:\n"
"%s (prefix to remove)\n"
"%*s (expected result)\n"
"%s (string to trim)\n"
"%*s (instead got)\n",
toTrim.isNull() ? "(NULL)" : toTrim.data(),
toTrim.isNull() ? "(NULL)" : toTrim.data(),
test.size(),
expected.isNull() ? "(NULL)" : expected.data(),
test.isNull() ? "(NULL)" : test.data(),
test.size(),
trimmed.isNull() ? "(NULL)" : trimmed.data());
CPPUNIT_ASSERT_MESSAGE("trim() causes object to relinquish its reference!",
origData == test.data());
}
void checkFind(const Sid::String& test,
char toFind,
int expected)
{
int res = test.find(toFind);
CPPUNIT_ASSERT_PRINTF(res == expected,
"find(%u) yielded unexpected result %d for string:\n"
"%s\n"
"expected %d\n",
toFind,
res,
test.isNull() ? "(NULL)" : test.data(),
expected);
}
void checkToBinary(const Sid::String& test, const char* expected, size_t expectedSize, const Sid::String& hex)
{
const char* origData = test.data();
checkToBinary(test, expected, expectedSize);
Sid::String expHex(hex);
Sid::String resHex = test.getHexRepresentation();
CPPUNIT_ASSERT_PRINTF(expHex == resHex,
"getHexRepresentation() yielded unexpected "
"result:\n"
"\"%s\" (expected)\n"
"\"%s\" (result)\n",
expHex.isNull() ? "(NULL)" : expHex.data(),
resHex.isNull() ? "(NULL)" : resHex.data());
CPPUNIT_ASSERT_MESSAGE("toBinary() causes object to relinquish its reference!",
origData == test.data());
}
void StringTestCase::substrTest()
{
// Sunny day
{
Sid::String str("foobajooba");
Sid::String sub = str.substr(0,0);
CPPUNIT_ASSERT_PRINTF( sub == "f",
"Basic substr logic is broken (input was %s, 0, 0)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(0, 9);
CPPUNIT_ASSERT_PRINTF( sub == "foobajooba",
"Basic substr logic is broken (input was %s, 0, 9)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(0, 8);
CPPUNIT_ASSERT_PRINTF( sub == "foobajoob",
"Basic substr logic is broken (input was %s, 0, 8)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(1, 9);
CPPUNIT_ASSERT_PRINTF( sub == "oobajooba",
"Basic substr logic is broken (input was %s, 1, 9)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(1, 8);
CPPUNIT_ASSERT_PRINTF( sub == "oobajoob",
"Basic substr logic is broken (input was %s, 1, 8)\nSubstring was %s\n",
str.data(),
sub.data());
}
// Null string
{
Sid::String str;
Sid::String sub = str.substr(0,0);
CPPUNIT_ASSERT_MESSAGE("Substring (0,0) of a null string somehow is not null. Fascinating!\n",
sub.isNull());
sub = str.substr(0, -1);
CPPUNIT_ASSERT_MESSAGE( "Substring (0,-1) of a null string somehow is not null. Fascinating!\n",
sub.isNull());
}
// Empty string
{
Sid::String str("");
Sid::String sub = str.substr(0,0);
CPPUNIT_ASSERT_MESSAGE("Substring (0,0) of an empty string somehow is not empty. Fascinating!\n",
sub.isEmpty() && !sub.isNull());
sub = str.substr(0, -1);
CPPUNIT_ASSERT_MESSAGE( "Substring (0,-1) of an empty string somehow is not empty. Fascinating!\n",
sub.isEmpty() && !sub.isNull());
}
// boundary fixup
{
Sid::String str("foobajooba");
Sid::String sub = str.substr(0, -1);
CPPUNIT_ASSERT_PRINTF( sub == "foobajoob",
"Negative index code is somehow broken (input was %s, 0, -1)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(0, -9);
CPPUNIT_ASSERT_PRINTF( sub == "f",
"Negative index code is somehow broken (input was %s, 0, -9)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(0, -9999999);
CPPUNIT_ASSERT_PRINTF( sub == "f",
"Negative index modulus code is somehow broken (input was %s, 0, -9999999)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(-5, 2);
CPPUNIT_ASSERT_PRINTF( sub == "foo",
"Negative leading bound fixup seems to not be working (input was %s, -5, 2)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(5, 2);
CPPUNIT_ASSERT_PRINTF( sub == "obaj",
"Bound swapping fixup seems to not be working (input was %s, 5, 2)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(5, 900);
CPPUNIT_ASSERT_PRINTF( sub == "jooba",
"Large upper bound fixup seems to not be working (input was %s, 5, 900)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(9, 900);
CPPUNIT_ASSERT_PRINTF( sub == "a",
"Large upper bound fixup seems to not be working (input was %s, 9, 900)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(10, 9);
CPPUNIT_ASSERT_PRINTF( sub == "foobajooba",
"Large lower bound fixup seems to not be working (input was %s, 10, 900)\nSubstring was %s\n",
str.data(),
sub.data());
sub = str.substr(400, 9);
CPPUNIT_ASSERT_PRINTF( sub == "foobajooba",
"Large lower bound fixup seems to not be working (input was %s, 400, 900)\nSubstring was %s\n",
str.data(),
sub.data());
}
}