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;
}
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 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 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 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 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 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 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 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 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 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 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(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 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 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 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 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 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 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 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::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);
}
}