bool SkypekitTestEngine::CustomCommand(const Sid::String &cmd, Sid::String &result_str) {
TI_FUNCLOG;
result_str = "Hi! I got your ";
result_str += cmd;
TI_DBG("CustomCommand: got %s, answer: %s", cmd.data(), result_str.data());
return true;
}
bool iMX27RtpInterface::CustomCommand(const Sid::String& cmd, Sid::String& result_str) {
RTP_FUNCLOG;
result_str = "Hi! I got your ";
result_str += cmd;
RTP_DBG("CustomCommand: got %s, answer: %s", cmd.data(), result_str.data());
return true;
}
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 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());
}
int main(int argc, const char **argv) {
OptionsParser parser;
if (parser.ParseOptions(argc, argv) < 0 || parser.m_Help) {
parser.Usage(argv[0]);
return -1;
}
Sid::SkypePCMInterfaceServer *pcmif_server = new Sid::SkypePCMInterfaceServer();
Sid::SkypePCMCallbackInterfaceClient *pcmif_cb_client = new Sid::SkypePCMCallbackInterfaceClient();
SkypePCMInterface* pcmif = SkypePCMInterfaceGet(pcmif_cb_client);
pcmif_server->set_if(pcmif);
Sid::String fromskypekitkey;
Sid::String toskypekitkey;
fromskypekitkey.Format( "%spcm_from_skypekit_key", parser.m_IpcPrefix);
toskypekitkey.Format( "%spcm_to_skypekit_key", parser.m_IpcPrefix);
pcmif_server->Connect(fromskypekitkey.data(), 0);
pcmif_cb_client->Connect(toskypekitkey.data(), 500);
if(parser.m_OutFile)
{
Sid::String cmd;
Sid::String response;
cmd.Format("OUT:%s",parser.m_OutFile);
pcmif->CustomCommand(cmd, response);
}
if(parser.m_InFile)
{
Sid::String cmd;
Sid::String response;
cmd.Format("IN:%s",parser.m_InFile);
pcmif->CustomCommand(cmd,response);
}
if(parser.m_Loop)
{
Sid::String cmd = "LOOP:1";
Sid::String response;
pcmif->CustomCommand("LOOP:1", response);
}
Sid::Protocol::Status status;
do {
status =pcmif_server->ProcessCommands();
} while (status == Sid::Protocol::OK);
SkypePCMInterfaceRelease(pcmif);
pcmif_server->Disconnect();
pcmif_cb_client->Disconnect();
delete pcmif_server;
delete pcmif_cb_client;
printf("PCMServerTransport disconnected, exiting from pcmtesthost\n");
}
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 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 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 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 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 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 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 char* origData = test.data();
char* res = new char[test.size()+1];
size_t size = test.toBinary(res);
CPPUNIT_ASSERT_PRINTF(size == expectedSize,
"toBinary() yielded a result that was too long, "
"expected %u, got %u\n",
expectedSize,
size);
CPPUNIT_ASSERT_PRINTF(!memcmp(expected, res, size),
"%s",
"toBinary() yielded unexpected result\n");
CPPUNIT_ASSERT_MESSAGE("toBinary() causes object to relinquish its reference!",
origData == test.data());
}
void StringTestCase::testHash()
{
CPPUNIT_ASSERT(Sid::String().hash() == 0);
CPPUNIT_ASSERT(Sid::String().hash(16) == 0);
CPPUNIT_ASSERT(Sid::String("").hash() == 0);
CPPUNIT_ASSERT(Sid::String("").hash(16) == 0);
CPPUNIT_ASSERT(Sid::String("fOo").hash(1024) != Sid::String("Foo").hash(1024));
{
Sid::String test = Sid::String::from("\xff\xf0\x00\x90",4);
Sid::String test2 = Sid::String::from("\xfb\xf0\x00\x90",4);
// !bwc! This hash seems to fare poorly with small differences, this is the
// smallest modulus (that is a power of two) that yields different results.
// The 19 least significant bits are identical. Might be worth considering
// updating the hash function with something a little nicer.
CPPUNIT_ASSERT(test.hash(0x080000) != test2.hash(0x080000));
}
}
void checkFrom(int n, const Sid::String& expected)
{
Sid::String from=Sid::String::from(n);
CPPUNIT_ASSERT_PRINTF(from == expected,
"from((int)%d) did not yield expected result:\n"
"got %s\n",
expected.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 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 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 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 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 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());
}
}
void StringTestCase::escapingAndUnescapingTest()
{
checkEscaping(Sid::String(), Sid::String());
checkEscaping(Sid::String(4), "");
checkEscaping("", "");
checkEscaping(",", "\\,");
checkEscaping("\"", "\\\"");
checkEscaping("\\", "\\\\");
checkEscaping("foobar", "foobar");
checkEscaping("foo,bar", "foo\\,bar");
checkEscaping("foo\"bar", "foo\\\"bar");
checkEscaping("foo\\bar", "foo\\\\bar");
checkEscaping(",,", "\\,\\,");
checkEscaping("\"\"", "\\\"\\\"");
checkEscaping("\\\\", "\\\\\\\\");
checkUnescaping("\\", "");
checkUnescaping("foo\\bar", "foobar");
checkUnescaping("\\foobar", "foobar");
checkUnescaping("foobar\\", "foobar");
// .bwc. This code came from an #ifdef SE_STRING_TEST_PROGRAM block in
// skype_string.cpp.
int i;
Sid::String strings[] = {
"Hello World!",
"Hel,lo\\ World!",
"Hel\"lo Wo\\9rld!",
"Hel,lo Wo\\0rld!",
Sid::String()
};
for (i = 0; !strings[i].isNull(); i++) {
Sid::String escaped = strings[i].escape();
Sid::String unescaped = escaped.unescape();
CPPUNIT_ASSERT_PRINTF( !strcmp((const char*)strings[i], (const char*)unescaped),
"String Failed:\n%s\n%s\n%s\n\n",
(const char*)strings[i],
(const char*)escaped,
(const char*)unescaped);
}
// 0x5c = '\\', 0x30 = '0', 0x00 = 0, 0x22 = '"'
const char bins[] = {
'1', '2', '3', '4', '5', '6', '7', '8' ,
'1', '2', 0x5c, 0x30, '5', '6', '7', '8' ,
'1', '2', 0x5c, 0x30, 0x5c, 0x5c, 0x5c, '8' ,
'1', '2', 0x5c, 0x30, '5', '6', '7', '8' ,
'1', '2', 0x00, '4', '5', '6', '7', '8' ,
'1', 0x5c, 0x00, 0x5c, '5', '6', 0x5c, 0x5c ,
'1', 0x5c, 0x00, 0x00, '5', 0x00, 0x5c, '8' ,
0x00, '2', 0x5c, 0x30, '5', 0x22, 0x22, '8' ,
0x5c, '2', 0x5c, 0x30, '5', 0x22, 0x22, 0x00 ,
0x00, 0x00, 0x5c, 0x30, '5', 0x22, 0x22, 0x5c ,
'E'
};
size_t bins_len = 8;
for (i = 0; bins[i] != 'E'; i += bins_len) {
Sid::String escaped = Sid::String::from((char*)(bins + i), bins_len);
char *unescaped = (char *)malloc(escaped.length());
size_t unescaped_len = escaped.toBinary(unescaped);
//printf("%d, escaped.length()=%d unescaped_len=%d\n", i/bins_len, escaped.length(), unescaped_len);
CPPUNIT_ASSERT_PRINTF ( !memcmp((char*)(bins + i), unescaped, bins_len) && (unescaped_len == bins_len),
"Binary Failed: index %d\n",
i/bins_len);
//printf("%s\n", (const char*)escaped.getHexRepresentation());
free(unescaped);
}
{
Sid::String test("foo");
test.markAsBinary();
CPPUNIT_ASSERT_PRINTF(test.isBinary(),
"%s", "markAsBinary() seems "
"to have no effect.\n");
}
}
void StringTestCase::testOwnership()
{
// Test shallow copy semantics
{
Sid::String orig("foo bar");
Sid::String shallowCopy(orig);
CPPUNIT_ASSERT_MESSAGE("Shallow copy semantics for copy c'tor not working!",
orig.data() == shallowCopy.data());
Sid::String assigned;
assigned = orig;
CPPUNIT_ASSERT_MESSAGE("Shallow copy semantics for assignment operator"
" not working!",
orig.data() == assigned.data());
}
// Test copy-on-write semantics
{
Sid::String orig("foo bar");
{
Sid::String copy(orig);
copy+=" baz";
CPPUNIT_ASSERT_MESSAGE("Copy-on-write semantics not working for "
"operator+=(const char*).",
copy != orig);
}
{
Sid::String copy(orig);
copy+=Sid::String("baz");
CPPUNIT_ASSERT_MESSAGE("Copy-on-write semantics not working for "
"operator+=(const Sid::String&).",
copy != orig);
}
{
Sid::String copy(orig);
copy=Sid::String("baz");
CPPUNIT_ASSERT_MESSAGE("Copy-on-write semantics not working for "
"operator=(const Sid::String&).",
copy != orig);
}
{
Sid::String copy(orig);
copy="baz";
CPPUNIT_ASSERT_MESSAGE("Copy-on-write semantics not working for "
"operator=(const char*).",
copy != orig);
}
}
// Test deepCopy()
{
Sid::String orig("foobar");
const char* origData = orig.data();
Sid::String dCopy = orig.deepCopy();
CPPUNIT_ASSERT_MESSAGE("deepCopy() yielded a shallow copy!",
orig.data() != dCopy.data());
CPPUNIT_ASSERT_MESSAGE("deepCopy() caused original to relinquish its reference!",
orig.data() == origData);
Sid::String copy(orig);
CPPUNIT_ASSERT_MESSAGE("deepCopy() caused original to relinquish its reference!",
orig.data() == origData);
}
}
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 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());
}
