void testQueryParams()
{
cxxtools::QueryParams q;
q.add("p1", "value1");
q.add("p2", "value2");
q.add("value3");
CXXTOOLS_UNIT_ASSERT(q.has("p1"));
CXXTOOLS_UNIT_ASSERT(q.has("p2"));
CXXTOOLS_UNIT_ASSERT(!q.has("p3"));
CXXTOOLS_UNIT_ASSERT_EQUALS(q["p1"], "value1");
CXXTOOLS_UNIT_ASSERT_EQUALS(q["p2"], "value2");
CXXTOOLS_UNIT_ASSERT_EQUALS(q[0], "value3");
}
void muldiv()
{
cxxtools::Seconds t1(2500);
cxxtools::Timespan d = t1 * 2.0;
CXXTOOLS_UNIT_ASSERT_EQUALS(d, cxxtools::Seconds(5000));
d = 3.0 * t1;
CXXTOOLS_UNIT_ASSERT_EQUALS(d, cxxtools::Seconds(7500));
d = t1 / 2.0;
CXXTOOLS_UNIT_ASSERT_EQUALS(d, cxxtools::Seconds(1250));
}
void testCopy()
{
cxxtools::QueryParams q;
q.add("p1", "value1");
q.add("p2", "value2");
q.add("value3");
cxxtools::QueryParams q2 = q;
CXXTOOLS_UNIT_ASSERT(q2.has("p1"));
CXXTOOLS_UNIT_ASSERT(q2.has("p2"));
CXXTOOLS_UNIT_ASSERT(!q2.has("p3"));
CXXTOOLS_UNIT_ASSERT_EQUALS(q2["p1"], "value1");
CXXTOOLS_UNIT_ASSERT_EQUALS(q2["p2"], "value2");
CXXTOOLS_UNIT_ASSERT_EQUALS(q2[0], "value3");
}
void StringTest::testReserve()
{
const cxxtools::Char c1[] = { 'a', 'b', 'c', 'd', '\0' };
cxxtools::String s(L"abcd");
cxxtools::String s2 = s;
s2.reserve(10);
CXXTOOLS_UNIT_ASSERT( s2.capacity() >= 10 );
CXXTOOLS_UNIT_ASSERT( s2.size() == 4 );
CXXTOOLS_UNIT_ASSERT_EQUALS( std::char_traits<cxxtools::Char>::compare(s2.c_str(), c1, 4) , 0 );
CXXTOOLS_UNIT_ASSERT( s.capacity() >= 4 );
CXXTOOLS_UNIT_ASSERT_EQUALS( s.size(), 4 );
CXXTOOLS_UNIT_ASSERT_EQUALS( std::char_traits<cxxtools::Char>::compare(s.c_str(), c1, 4) , 0 );
}
void testArgChar()
{
int argc = 5;
char* argv[] = { arg("prog"), arg("-D"), arg("A"), arg("-F"), arg("\t"), 0 };
cxxtools::Arg<char> optionA(argc, argv, 'A');
cxxtools::Arg<char> optionD(argc, argv, 'D');
cxxtools::Arg<char> optionF(argc, argv, 'F');
CXXTOOLS_UNIT_ASSERT(!optionA.isSet());
CXXTOOLS_UNIT_ASSERT(optionD.isSet());
CXXTOOLS_UNIT_ASSERT(optionF.isSet());
CXXTOOLS_UNIT_ASSERT_EQUALS(*optionD, 'A');
CXXTOOLS_UNIT_ASSERT_EQUALS(*optionF, '\t');
CXXTOOLS_UNIT_ASSERT_EQUALS(argc, 1);
}
void multipartMessage()
{
cxxtools::MimeMultipart mp;
mp.addObject();
mp.addObject();
CXXTOOLS_UNIT_ASSERT_EQUALS(mp.size(), 2);
}
void bunzip2OstreamTest()
{
// test
std::stringstream bzip2target;
{
zim::Bzip2Stream compressor(bzip2target);
compressor << testtext << std::flush;
compressor.end();
}
{
std::ostringstream msg;
msg << "teststring with " << testtext.size() << " bytes compressed into " << bzip2target.str().size() << " bytes";
reportMessage(msg.str());
}
std::ostringstream bunzip2target;
{
zim::Bunzip2Stream bunzip2(bunzip2target); // bunzip2 is a ostream here
bunzip2 << bzip2target.str() << std::flush;
}
{
std::ostringstream msg;
msg << "teststring uncompressed to " << bunzip2target.str().size() << " bytes";
reportMessage(msg.str());
}
CXXTOOLS_UNIT_ASSERT_EQUALS(testtext, bunzip2target.str());
}
void inflatorOstreamTest()
{
// test
std::stringstream deflatetarget;
zim::DeflateStream deflator(deflatetarget);
deflator << testtext << std::flush;
{
std::ostringstream msg;
msg << "teststring with " << testtext.size() << " bytes compressed into " << deflatetarget.str().size() << " bytes";
reportMessage(msg.str());
}
std::ostringstream inflatetarget;
zim::InflateStream inflator(inflatetarget); // inflator is a ostream here
inflator << deflatetarget.str() << std::flush;
{
std::ostringstream msg;
msg << "teststring uncompressed to " << inflatetarget.str().size() << " bytes";
reportMessage(msg.str());
}
CXXTOOLS_UNIT_ASSERT_EQUALS(testtext, inflatetarget.str());
}
////////////////////////////////////////////////////////////
// Multiple calls
//
void Multiple()
{
_server->registerMethod("multiply", *this, &BinRpcTest::multiplyDouble);
typedef cxxtools::RemoteProcedure<double, double, double> Multiply;
std::vector<cxxtools::bin::RpcClient> clients;
std::vector<Multiply> procs;
clients.reserve(16);
procs.reserve(16);
for (unsigned i = 0; i < 16; ++i)
{
clients.push_back(cxxtools::bin::RpcClient(_loop, "", _port));
procs.push_back(Multiply(clients.back(), "multiply"));
procs.back().begin(i, i);
}
for (unsigned i = 0; i < 16; ++i)
{
CXXTOOLS_UNIT_ASSERT_EQUALS(procs[i].end(2000), i*i);
}
}
void testPlainInt()
{
std::ostringstream out;
cxxtools::JsonSerializer serializer(out);
serializer.serialize(-4711).finish();
CXXTOOLS_UNIT_ASSERT_EQUALS(out.str(), "-4711");
}
void testPlainEmpty()
{
std::ostringstream out;
cxxtools::JsonSerializer serializer(out);
serializer.finish();
CXXTOOLS_UNIT_ASSERT_EQUALS(out.str(), "");
}
void testInt()
{
std::ostringstream out;
cxxtools::JsonSerializer serializer(out);
serializer.serialize(-4711, "value").finish();
CXXTOOLS_UNIT_ASSERT_EQUALS(out.str(), "{\"value\":-4711}");
}
////////////////////////////////////////////////////////////
// Array
//
void Array()
{
_server->registerMethod("multiply", *this, &BinRpcTest::multiplyVector);
cxxtools::bin::RpcClient client(_loop, "", _port);
cxxtools::RemoteProcedure< std::vector<int>, std::vector<int>, std::vector<int> > multiply(client, "multiply");
std::vector<int> vec;
vec.push_back(10);
vec.push_back(20);
multiply.begin(vec, vec);
std::vector<int> r = multiply.end(2000);
CXXTOOLS_UNIT_ASSERT_EQUALS(r.size(), 2);
CXXTOOLS_UNIT_ASSERT_EQUALS(r.at(0), 100);
CXXTOOLS_UNIT_ASSERT_EQUALS(r.at(1), 400);
}
////////////////////////////////////////////////////////////
// Connect
//
void Connect()
{
_server->registerMethod("boolean", *this, &BinRpcTest::boolean);
// test connect using cxxtools::net::AddrInfo
{
cxxtools::bin::RpcClient client(_loop);
cxxtools::RemoteProcedure<bool, bool, bool> boolean(client, "boolean");
client.connect(cxxtools::net::AddrInfo("", _port));
boolean.begin(true, true);
CXXTOOLS_UNIT_ASSERT_EQUALS(boolean.end(2000), true);
}
// test connect using host and port
{
cxxtools::bin::RpcClient client(_loop);
cxxtools::RemoteProcedure<bool, bool, bool> boolean(client, "boolean");
client.connect("", _port);
boolean.begin(true, true);
CXXTOOLS_UNIT_ASSERT_EQUALS(boolean.end(2000), true);
}
// test connect using uri
{
cxxtools::bin::RpcClient client(_loop);
cxxtools::RemoteProcedure<bool, bool, bool> boolean(client, "boolean");
std::ostringstream uri;
uri << "http://localhost:" << _port << '/';
client.connect(cxxtools::net::Uri(uri.str()));
boolean.begin(true, true);
CXXTOOLS_UNIT_ASSERT_EQUALS(boolean.end(2000), true);
}
// test failing connect
{
cxxtools::bin::RpcClient client(_loop);
cxxtools::RemoteProcedure<bool, bool, bool> boolean(client, "boolean");
CXXTOOLS_UNIT_ASSERT_THROW(client.connect("", _port + 1), cxxtools::IOError);
}
}
void testArgBool()
{
int argc = 7;
char* argv[] = { arg("prog"), arg("-i"), arg("-j"), arg("-k"),
arg("-cf"), arg("--foo"), arg("foo"), 0 };
cxxtools::Arg<bool> optionJ(argc, argv, 'j');
cxxtools::Arg<bool> optionL(argc, argv, 'l');
cxxtools::Arg<bool> optionC(argc, argv, 'c');
cxxtools::Arg<bool> optionFoo(argc, argv, "--foo");
cxxtools::Arg<bool> optionBar(argc, argv, "--bar");
CXXTOOLS_UNIT_ASSERT(optionJ);
CXXTOOLS_UNIT_ASSERT(!optionL);
CXXTOOLS_UNIT_ASSERT(optionC);
CXXTOOLS_UNIT_ASSERT(optionFoo);
CXXTOOLS_UNIT_ASSERT(!optionBar);
CXXTOOLS_UNIT_ASSERT_EQUALS(argc, 5);
CXXTOOLS_UNIT_ASSERT_EQUALS(strcmp(argv[0], "prog"), 0);
CXXTOOLS_UNIT_ASSERT_EQUALS(strcmp(argv[1], "-i"), 0);
CXXTOOLS_UNIT_ASSERT_EQUALS(strcmp(argv[2], "-k"), 0);
CXXTOOLS_UNIT_ASSERT_EQUALS(strcmp(argv[3], "-f"), 0);
CXXTOOLS_UNIT_ASSERT_EQUALS(strcmp(argv[4], "foo"), 0);
CXXTOOLS_UNIT_ASSERT_EQUALS(argv[5], static_cast<const char*>(0));
}
void poolTest()
{
{
typedef cxxtools::Pool<Object> PoolType;
PoolType pool;
{
PoolType::Ptr p = pool.get();
CXXTOOLS_UNIT_ASSERT_EQUALS(pool.size(), 0);
CXXTOOLS_UNIT_ASSERT_EQUALS(Object::ctorCount, 1);
}
CXXTOOLS_UNIT_ASSERT_EQUALS(pool.size(), 1);
{
PoolType::Ptr p = pool.get();
CXXTOOLS_UNIT_ASSERT_EQUALS(pool.size(), 0);
}
CXXTOOLS_UNIT_ASSERT_EQUALS(pool.size(), 1);
CXXTOOLS_UNIT_ASSERT_EQUALS(Object::ctorCount, 1);
}
CXXTOOLS_UNIT_ASSERT_EQUALS(Object::instCount, 0);
}
void serialize()
{
cxxtools::Timespan t(1234567);
cxxtools::SerializationInfo si;
si <<= t;
cxxtools::Timespan t2;
si >>= t2;
CXXTOOLS_UNIT_ASSERT_EQUALS(t, t2);
}
void testPlain()
{
std::string src = "<html><body><h1>Hello World!<h1>\n</body></html>";
std::istringstream ecpp(src);
Handler handler;
tnt::ecpp::Parser parser(handler, std::string());
parser.parse(ecpp);
CXXTOOLS_UNIT_ASSERT_EQUALS(handler.result(), "start()onHtml(" + src + ")end()");
}
void testPre()
{
std::string src = "<foo><%pre> #include <iostream> </%pre></foo>";
std::istringstream ecpp(src);
Handler handler;
tnt::ecpp::Parser parser(handler, std::string());
parser.parse(ecpp);
CXXTOOLS_UNIT_ASSERT_EQUALS(handler.result(), "start()onHtml(<foo>)onPre( #include <iostream> )onHtml(</foo>)end()");
}
void testStringArgs()
{
std::string src = "<foo><%args> foo=\"bar\"; </%args></foo>";
std::istringstream ecpp(src);
Handler handler;
tnt::ecpp::Parser parser(handler, std::string());
parser.parse(ecpp);
CXXTOOLS_UNIT_ASSERT_EQUALS(handler.result(), "start()onHtml(<foo>)onArg(foo, \"bar\")onHtml(</foo>)end()");
}
void joinString()
{
std::vector<std::string> d;
d.push_back("Hello");
d.push_back("World");
d.push_back("!");
std::string result = cxxtools::join(d.begin(), d.end(), " ");
CXXTOOLS_UNIT_ASSERT_EQUALS(result, "Hello World !");
}
void testTypedVectorArgs()
{
std::string src = "<foo><%args> int foo[]; </%args></foo>";
std::istringstream ecpp(src);
Handler handler;
tnt::ecpp::Parser parser(handler, std::string());
parser.parse(ecpp);
CXXTOOLS_UNIT_ASSERT_EQUALS(handler.result(), "start()onHtml(<foo>)onArg(int foo[], )onHtml(</foo>)end()");
}
void testHtmlExpression()
{
std::string src = "<foo><$$ a+b $></foo>";
std::istringstream ecpp(src);
Handler handler;
tnt::ecpp::Parser parser(handler, std::string());
parser.parse(ecpp);
CXXTOOLS_UNIT_ASSERT_EQUALS(handler.result(), "start()onHtml(<foo>)onHtmlExpression( a+b )onHtml(</foo>)end()");
}
void joinInt()
{
std::vector<int> d;
d.push_back(4);
d.push_back(17);
d.push_back(-12);
std::string result = cxxtools::join(d.begin(), d.end(), ", ");
CXXTOOLS_UNIT_ASSERT_EQUALS(result, "4, 17, -12");
}
void testAttr()
{
std::string src = "<foo><%attr> method=\"post\"; </%attr></foo>";
std::istringstream ecpp(src);
Handler handler;
tnt::ecpp::Parser parser(handler, std::string());
parser.parse(ecpp);
CXXTOOLS_UNIT_ASSERT_EQUALS(handler.result(), "start()onHtml(<foo>)onAttr(method, \"post\")onHtml(</foo>)end()");
}
void testEmptyObject()
{
std::ostringstream out;
cxxtools::JsonSerializer serializer(out);
serializer.setObject();
serializer.finish();
CXXTOOLS_UNIT_ASSERT_EQUALS(out.str(), "{}");
}
void testGetUrl()
{
cxxtools::QueryParams q;
q.add("first name", "Tommi");
q.add("last name", "M\xa4kitalo");
q.add("some value");
std::string url = q.getUrl();
CXXTOOLS_UNIT_ASSERT_EQUALS(url, "first+name=Tommi&last+name=M%A4kitalo&some+value");
}
void testIniParser()
{
std::istringstream inifile(
"[s1]\n"
"k1=v1\n");
E e;
cxxtools::IniParser p(e);
p.parse(inifile);
CXXTOOLS_UNIT_ASSERT_EQUALS(e.result(), "S(s1)K(k1)V(v1)");
}
void testMultipleObjects()
{
std::ostringstream out;
cxxtools::JsonSerializer serializer(out);
serializer.serialize("Hi", "a")
.serialize(42, "b")
.finish();
CXXTOOLS_UNIT_ASSERT_EQUALS(out.str(), "{\"a\":\"Hi\",\"b\":42}");
}
void istreamunits()
{
{
std::istringstream s("823u");
cxxtools::Timespan ts;
s >> ts;
CXXTOOLS_UNIT_ASSERT(!s.fail());
CXXTOOLS_UNIT_ASSERT_EQUALS(ts, cxxtools::Microseconds(823));
}
{
std::istringstream s("823ms");
cxxtools::Seconds ts;
s >> ts;
CXXTOOLS_UNIT_ASSERT(s);
CXXTOOLS_UNIT_ASSERT_EQUALS(ts, cxxtools::Milliseconds(823));
}
{
std::istringstream s("823s");
cxxtools::Timespan ts;
s >> ts;
CXXTOOLS_UNIT_ASSERT(s);
CXXTOOLS_UNIT_ASSERT_EQUALS(ts, cxxtools::Seconds(823));
}
{
std::istringstream s("823.5m");
cxxtools::Timespan ts;
s >> ts;
CXXTOOLS_UNIT_ASSERT(s);
CXXTOOLS_UNIT_ASSERT_EQUALS(ts, cxxtools::Minutes(823.5));
}
{
std::istringstream s("823mi");
cxxtools::Timespan ts;
s >> ts;
CXXTOOLS_UNIT_ASSERT(s);
CXXTOOLS_UNIT_ASSERT_EQUALS(ts, cxxtools::Minutes(823));
}
{
std::istringstream s("823h");
cxxtools::Timespan ts;
s >> ts;
CXXTOOLS_UNIT_ASSERT(s);
CXXTOOLS_UNIT_ASSERT_EQUALS(ts, cxxtools::Hours(823));
}
{
std::istringstream s("823d");
cxxtools::Timespan ts;
s >> ts;
CXXTOOLS_UNIT_ASSERT(s);
CXXTOOLS_UNIT_ASSERT_EQUALS(ts, cxxtools::Days(823));
}
}
