diff -r f5050f1da672 -r 04becd199f91 javacommons/comms/tsrc/src/commsmessage.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javacommons/comms/tsrc/src/commsmessage.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,638 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  ?Description
+*
+*/
+
+#include "TestHarness.h"
+#include "javauid.h"
+#include "javacommonutils.h"
+#include "exceptionbase.h"
+
+#include "commsmessage.h"
+#include "commspermissions.h"
+#include "commsclientendpoint.h"
+#include "echoserver.h"
+
+using namespace java::comms;
+using namespace std;
+using java::util::Uid;
+using java::util::JavaCommonUtils;
+
+
+class PermissionListener : public CommsListener
+{
+public:
+    CommsMessage msg;
+    CommsEndpoint* comms;
+
+    virtual void processMessage(CommsMessage& aMessage)
+    {
+        msg = aMessage;
+        CommsMessage reply;
+        reply.replyTo(aMessage);
+        comms->send(reply);
+    }
+};
+
+
+
+TEST_GROUP(CommsMessage)
+{
+    EchoServer server;
+    CommsClientEndpoint client;
+
+    TEST_SETUP()
+    {
+        server.start(IPC_ADDRESS_COMMS_MODULE_TEST);
+        client.connect(IPC_ADDRESS_COMMS_MODULE_TEST);
+    }
+
+    TEST_TEARDOWN()
+    {
+        client.disconnect();
+        server.stop();
+    }
+};
+
+/**
+ * Test setters and getters
+ * 1: test header setters and getters
+ * 2: test message body setters and getters
+ * 3: read contents multiple times
+ */
+TEST(CommsMessage, getterSetter)
+{
+#ifdef __SYMBIAN32__
+    EXPECT_N_LEAKS(1);
+#else
+    EXPECT_N_LEAKS(2);
+#endif
+    // 1: test header setters and getters
+    CommsMessage msg;
+    msg.setModuleId(1111);
+    msg.setMessageId(2222);
+    msg.setMessageRef(3333);
+
+    CommsMessage receivedMsg;
+    CHECK(!client.sendReceive(msg, receivedMsg, 1));
+
+    CHECK(msg.getModuleId() == receivedMsg.getModuleId());
+    CHECK(msg.getMessageId() == receivedMsg.getMessageId());
+    CHECK(msg.getMessageRef() == receivedMsg.getMessageRef());
+
+    // 2: test message body setters and getters
+    string sin = "this is a string";
+    wstring win = L"this is a wstring";
+    int in = 1;
+    long long lin = -1LL;
+    Uid uid(L"sampleUid");
+
+    msg << sin << win << in << lin << uid;
+    CHECK(!client.sendReceive(msg, receivedMsg, 1));
+    string sout;
+    wstring wout;
+    int out;
+    long long lout;
+    Uid uidOut;
+    receivedMsg >> sout >> wout >> out >> lout >> uidOut;
+
+    CHECK(0 == sin.compare(sout));
+    CHECK(0 == win.compare(wout));
+    CHECK(in == out);
+    CHECK(lin == lout);
+    CHECK(uid == uidOut);
+
+    // 3: read contents multiple times
+    CommsMessage m;
+    m << "test" << 1;
+    CommsMessage r;
+    CHECK(!client.sendReceive(m, r, 1));
+    string s, s2;
+    int i, i2;
+    r >> s >> i;
+    r.begin();
+    r >> s2 >> i2;
+    CHECK(0 == s.compare(s));
+    CHECK(i == i2);
+}
+
+
+/**
+ * Test CommsMessage streaming
+ * 1: check ascii chars
+ */
+TEST(CommsMessage, ascii)
+{
+    CommsMessage msg;
+    const int len = 0xff;
+    char chars[len];
+    for (int i=0; i < len; i++)
+    {
+        chars[i] = i;
+    }
+    string ascii(chars, len);
+    msg << ascii;
+    string result;
+    msg >> result;
+    CHECK(0 == ascii.compare(result));
+
+    char* arr = msg.toByteArray();
+    CommsMessage msg2(reinterpret_cast<ipcMessage_t*>(arr));
+
+    msg2 >> result;
+    CHECK(0 == ascii.compare(result));
+}
+
+
+/**
+ * Test CommsMessage streaming
+ * 1: check special cases: space, '\n' and empty string
+ */
+TEST(CommsMessage, SpecialChars)
+{
+    CommsMessage msg;
+    string a = "";
+    string b = "\n";
+    string c;
+    string d = " ";
+    string e = "  ";
+    string f = "\n\n";
+    string g = "\n ";
+    string h = " \r\n";
+    int i = 0;
+    int j = 0xffffffff;
+    long long k = -1LL;
+    long long l = 0LL;
+    Uid m;
+
+    msg << a << i << k << b << c << j << d << e << l << f << g << h << m;
+    string ao, bo, co, doo, eo, fo, go, ho;
+    int io, jo;
+    long long ko, lo;
+    Uid mo;
+    msg >> ao >> io >> ko >> bo >> co >> jo >> doo >> eo >> lo >> fo >> go >> ho >> mo;
+
+    CHECK(0 == a.compare(ao));
+    CHECK(0 == b.compare(bo));
+    CHECK(0 == c.compare(co));
+    CHECK(0 == d.compare(doo));
+    CHECK(0 == e.compare(eo));
+    CHECK(0 == f.compare(fo));
+    CHECK(0 == g.compare(go));
+    CHECK(0 == h.compare(ho));
+    CHECK(i == io);
+    CHECK(j == jo);
+    CHECK(k == ko);
+    CHECK(l == lo);
+    CHECK(m == mo);
+    // make copy
+    char* arr = msg.toByteArray();
+    CommsMessage msg2(reinterpret_cast<ipcMessage_t*>(arr));
+
+    msg2 >> ao >> io >> ko >> bo >> co >> jo >> doo >> eo >> lo >> fo >> go >> ho >> mo;
+
+    CHECK(0 == a.compare(ao));
+    CHECK(0 == b.compare(bo));
+    CHECK(0 == c.compare(co));
+    CHECK(0 == d.compare(doo));
+    CHECK(0 == e.compare(eo));
+    CHECK(0 == f.compare(fo));
+    CHECK(0 == g.compare(go));
+    CHECK(0 == h.compare(ho));
+    CHECK(i == io);
+    CHECK(j == jo);
+    CHECK(k == ko);
+    CHECK(l == lo);
+    CHECK(m == mo);
+}
+
+/**
+ * Test CommsMessage streaming
+ * 1: empty message
+ */
+TEST(CommsMessage, empty)
+{
+    CommsMessage msg;
+
+    char* arr = msg.toByteArray();
+    CommsMessage msg2(reinterpret_cast<ipcMessage_t*>(arr));
+
+    CommsMessage msg3(msg);
+    CommsMessage msg4 = msg;
+    CommsMessage msg5 = msg;
+
+    CHECK(0 == msg.toString().compare(msg2.toString()));
+    CHECK(0 == msg.toString().compare(msg3.toString()));
+    CHECK(0 == msg.toString().compare(msg4.toString()));
+
+    // check that content can be added ok
+    string s = "hello world";
+    int i = 3;
+    msg5 << i << s;
+
+    string so;
+    int io;
+
+    msg5 >> io >> so;
+    CHECK(0 == s.compare(so));
+    CHECK(i == io);
+}
+
+/**
+ * Test CommsMessage streaming
+ * 1: copy constructor and assingment test
+ * 2: copy constructor and assingment test (bytearray)
+ * 3: self-assingment test
+ */
+TEST(CommsMessage, constuctor)
+{
+    // 1: copy constructor and assingment test
+    CommsMessage msg;
+
+    msg << "hello" << "world" << "this is test #" << 4;
+
+    CommsMessage msg2(msg);
+    CommsMessage msg3 = msg;
+
+    CHECK(0 == msg.toString().compare(msg2.toString()));
+    CHECK(0 == msg.toString().compare(msg3.toString()));
+
+    // 2: copy constructor and assingment test (bytearray)
+    CommsMessage m;
+
+    m << "hello" << "world" << "this is test #" << 4;
+
+    char* arr = m.toByteArray();
+    CommsMessage m2(reinterpret_cast<ipcMessage_t*>(arr));
+
+    CHECK(0 == m.toString().compare(m2.toString()));
+
+    // 3: self-assingment test
+    CommsMessage self;
+
+    self << "hello";
+    CHECK((self = self) == &self)
+    string s;
+    self >> s;
+    CHECK(0 == s.compare("hello"));
+}
+
+/**
+ * Test CommsMessage streaming
+ * 1: read same value multiple times
+ */
+TEST(CommsMessage, multipleReads)
+{
+    CommsMessage msg;
+
+    msg << "string 1" << "string 2" << "string 3" << "string 4";
+    string a, b, c, temp;
+
+    msg >> a;
+    msg.begin();
+
+    msg >> b;
+
+    while (!(msg>>temp))
+    {
+        // read everything
+    };
+
+    msg.begin();
+    msg >> c;
+
+    CHECK(0 == a.compare(b));
+    CHECK(0 == a.compare(c));
+}
+
+/**
+ * Test CommsMessage streaming
+ * 1: read in wrong order
+ */
+TEST(CommsMessage, readOrder)
+{
+    CommsMessage msg;
+
+    msg << "string 1" << 1 << 2 << "string 2";
+    string a, b;
+    int i, j;
+
+    msg >> i >> a >> b >> j;
+    CHECK(0 == i);
+
+    CommsMessage msg2;
+    msg2 >> i >> a;
+    CHECK(0 == i);
+    CHECK(0 == a.compare(""));
+}
+
+/**
+ * Test resetting CommsMessage
+ * 1: reset message with payload
+ * 2: reset empty message
+ */
+TEST(CommsMessage, reset)
+{
+    CommsMessage empty;
+
+    // 1: reset message with payload
+    CommsMessage msg;
+    msg.setModuleId(1111);
+    msg.setMessageId(2222);
+    msg.setMessageRef(3333);
+    msg.setSender(4444);
+    msg.setReceiver(5555);
+    msg << "string 1" << 1;
+    msg.reset();
+
+    CHECK(0 == msg.toString().compare(empty.toString()));
+    CHECK(msg.getModuleId() == empty.getModuleId());
+    CHECK(msg.getMessageId() == empty.getMessageId());
+    CHECK(msg.getMessageRef() == empty.getMessageRef());
+    CHECK(msg.getSender() == empty.getSender());
+    CHECK(msg.getReceiver() == empty.getReceiver());
+
+    // 2: reset empty message
+    CommsMessage msg2;
+    msg2.reset();
+
+    CHECK(0 == msg2.toString().compare(empty.toString()));
+    CHECK(msg2.getModuleId() == empty.getModuleId());
+    CHECK(msg2.getMessageId() == empty.getMessageId());
+    CHECK(msg2.getMessageRef() == empty.getMessageRef());
+    CHECK(msg2.getSender() == empty.getSender());
+    CHECK(msg2.getReceiver() == empty.getReceiver());
+}
+
+/**
+ * Test replyTo method
+ * 1: test replyTo method
+ */
+TEST(CommsMessage, replyTo)
+{
+    // 1: test replyTo method
+    CommsMessage msg;
+    msg.setModuleId(1111);
+    msg.setMessageId(2222);
+    msg.setMessageRef(3333);
+    msg.setSender(4444);
+    msg.setReceiver(5555);
+
+    CommsMessage reply;
+    reply.replyTo(msg);
+
+    CHECK(msg.getModuleId() == reply.getModuleId());
+    CHECK(msg.getMessageId() == reply.getMessageId());
+    CHECK(msg.getMessageRef() == reply.getMessageRef());
+    CHECK(msg.getSender() == reply.getReceiver());
+    CHECK(msg.getReceiver() == reply.getSender());
+}
+
+/**
+ * Test CommsMessage with different character encodings
+ * 1: write and read UTF16 / UTF8 strings
+ * 2: read-write mismatch cases string / wstring
+ */
+TEST(CommsMessage, charEncoding)
+{
+    // 1: write and read UTF16 / UTF8 strings
+    CommsMessage msg;
+
+    // devanagari letter A, tibetan digit zero, katakana letter YA
+    wstring w1 = L"\u0905\u0F20\u30E4";
+    string w1_in_utf8 = wstringToUtf8(w1);
+
+    // latin small letter a with diaeresis, latin small letter a with ring above,
+    // latin small letter o with diaeresis, Euro symbol
+    wstring w2 = L"\u00E4\u00E5\u00F6\u20AC";
+    string w2_in_utf8 = wstringToUtf8(w1);
+
+    // Japanese Yen symbol, Roman AE with acute accent, Greek Capital Alpha, Greek Capital Omega,
+    // Euro symbol, Rupee symbol, Cyrillic capital letter DZHE, Arabic letter TEH
+    wstring w3 = L"\u00a5\u01FC\u0391\u03A9\u20ac\u20a8\u040F\u062A";
+    string w3_in_utf8 = wstringToUtf8(w3);
+
+    msg << w1 << w1_in_utf8 << w2 << w2_in_utf8 << w3 << w3_in_utf8;
+    wstring wo1, wo2, wo3;
+    string so1, so2, so3;
+    msg >> wo1 >> so1 >> wo2 >> so2 >> wo3 >> so3;
+
+    CHECK(0 == wo1.compare(w1));
+    CHECK(0 == wo2.compare(w2));
+    CHECK(0 == wo3.compare(w3));
+    CHECK(0 == so1.compare(w1_in_utf8));
+    CHECK(0 == so2.compare(w2_in_utf8));
+    CHECK(0 == so3.compare(w3_in_utf8));
+
+    // 2: read-write mismatch cases string / wstring
+    msg.reset();
+    string s4 = "hello world";
+    wstring w4 = L"hello world";
+
+    // devanagari letter A, tibetan digit zero, katakana letter YA
+    string utf8 = "\xE0\xA4\x85\xE0\xBC\xA0\xE3\x83\xA4";
+    wstring utf16 = L"\u0905\u0F20\u30E4";
+
+    msg << s4 << w4 << utf8 << utf16;
+    string so4, utf8_out;
+    wstring wo4, utf16_out;
+    // read in wrong order string as wstring and wstrings as string
+    msg >> wo4 >> so4 >> utf16_out >> utf8_out;
+
+    CHECK(0 == so4.compare(s4));
+    CHECK(0 == wo4.compare(w4));
+
+    CHECK(0 == utf8_out.compare(utf8));
+    CHECK(0 == utf16_out.compare(utf16));
+
+}
+
+
+/**
+ * Test hasPermission method
+ * 1: test hasPermission method when used without client
+ */
+TEST(CommsMessage, hasPermission)
+{
+    // 1: test hasPermission method
+    CommsMessage msg;
+    CommsMessage msg2 = msg;
+    CommsMessage msg3(msg);
+
+    CHECK(msg.hasPermission(MANAGE_CERTIFICATES) == false);
+    CHECK(msg2.hasPermission(MANAGE_CERTIFICATES) == false);
+    CHECK(msg3.hasPermission(MANAGE_CERTIFICATES) == false);
+}
+
+
+/**
+ * Test hasPermission method with all permissions
+ * 1: check trust in client and server side
+ */
+TEST(CommsMessage, hasPermissionAll)
+{
+    // 1: check trust in client and server side
+    CommsMessage msg;
+    CommsMessage msg2;
+
+    CommsServerEndpoint server;
+    CommsClientEndpoint client;
+
+    PermissionListener listener;
+    listener.comms = &server;
+
+    CHECK(!server.registerDefaultListener(&listener));
+    CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+
+    CommsPermission permissions = (CommsPermission)((int)MANAGE_CERTIFICATES |
+                                  (int)INSTALL_APPLICATION |
+                                  (int)LAUNCH_APPLICATION |
+                                  (int)STOP_APPLICATION);
+
+    CHECK(client.sendReceive(msg, msg2, 2) == 0);
+
+    CHECK(msg2.hasPermission(permissions) == true);
+    CHECK(listener.msg.hasPermission(permissions) == true);
+
+    CHECK(!client.disconnect());
+    CHECK(!server.stop());
+}
+
+/**
+ * Test hasPermission method with manage certificates permission
+ * 1: check trust in client and server side
+ */
+TEST(CommsMessage, hasPermissionManageCerts)
+{
+    // 1: check trust in client and server side
+    CommsMessage msg;
+    CommsMessage msg2;
+
+    CommsServerEndpoint server;
+    CommsClientEndpoint client;
+
+    PermissionListener listener;
+    listener.comms = &server;
+
+    CHECK(!server.registerDefaultListener(&listener));
+    CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+
+    CommsPermission permissions = MANAGE_CERTIFICATES;
+
+    CHECK(client.sendReceive(msg, msg2, 2) == 0);
+
+    CHECK(msg2.hasPermission(permissions) == true);
+    CHECK(listener.msg.hasPermission(permissions) == true);
+
+    CHECK(!client.disconnect());
+    CHECK(!server.stop());
+}
+
+/**
+ * Test hasPermission method with install app permission
+ * 1: check trust in client and server side
+ */
+TEST(CommsMessage, hasPermissionInstallApp)
+{
+    // 1: check trust in client and server side
+    CommsMessage msg;
+    CommsMessage msg2;
+
+    CommsServerEndpoint server;
+    CommsClientEndpoint client;
+
+    PermissionListener listener;
+    listener.comms = &server;
+
+    CHECK(!server.registerDefaultListener(&listener));
+    CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+
+    CommsPermission permissions = INSTALL_APPLICATION;
+
+    CHECK(client.sendReceive(msg, msg2, 2) == 0);
+
+    CHECK(msg2.hasPermission(permissions) == true);
+    CHECK(listener.msg.hasPermission(permissions) == true);
+
+    CHECK(!client.disconnect());
+    CHECK(!server.stop());
+}
+
+/**
+ * Test hasPermission method with launch app permission
+ * 1: check trust in client and server side
+ */
+TEST(CommsMessage, hasPermissionLaunchApp)
+{
+    // 1: check trust in client and server side
+    CommsMessage msg;
+    CommsMessage msg2;
+
+    CommsServerEndpoint server;
+    CommsClientEndpoint client;
+
+    PermissionListener listener;
+    listener.comms = &server;
+
+    CHECK(!server.registerDefaultListener(&listener));
+    CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+
+    CommsPermission permissions = LAUNCH_APPLICATION;
+
+    CHECK(client.sendReceive(msg, msg2, 2) == 0);
+
+    CHECK(msg2.hasPermission(permissions) == true);
+    CHECK(listener.msg.hasPermission(permissions) == true);
+
+    CHECK(!client.disconnect());
+    CHECK(!server.stop());
+}
+
+/**
+ * Test hasPermission method with stop app permission
+ * 1: check trust in client and server side
+ */
+TEST(CommsMessage, hasPermissionStopApp)
+{
+    // 1: check trust in client and server side
+    CommsMessage msg;
+    CommsMessage msg2;
+
+    CommsServerEndpoint server;
+    CommsClientEndpoint client;
+
+    PermissionListener listener;
+    listener.comms = &server;
+
+    CHECK(!server.registerDefaultListener(&listener));
+    CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+    CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+
+    CommsPermission permissions = STOP_APPLICATION;
+
+    CHECK(client.sendReceive(msg, msg2, 2) == 0);
+
+    CHECK(msg2.hasPermission(permissions) == true);
+    CHECK(listener.msg.hasPermission(permissions) == true);
+
+    CHECK(!client.disconnect());
+    CHECK(!server.stop());
+}
+
+