diff -r e8e63152f320 -r 2a9601315dfc javacommons/comms/tsrc/src/sendreceive.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javacommons/comms/tsrc/src/sendreceive.cpp	Mon May 03 12:27:20 2010 +0300
@@ -0,0 +1,412 @@
+/*
+* 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:  Unit tests for send and sendReceive functionality
+*
+*/
+
+#include <pthread.h>
+#include <unistd.h>
+#include "TestHarness.h"
+#include "monitor.h"
+#include "logger.h"
+
+#include "comms.h"
+#include "commsclientendpoint.h"
+#include "commsendpoint.h"
+#include "echoserver.h"
+
+using namespace java::comms;
+using namespace std;
+using java::util::Monitor;
+
+TEST_GROUP(SendReceive)
+{
+    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 message sending
+ * 1. Sending empty message
+ * 2. Check contents of message (empty message)
+ * 3. Message payload check
+ */
+
+TEST(SendReceive, normal)
+{
+#ifdef __SYMBIAN32__
+    EXPECT_N_LEAKS(1);
+#else
+    EXPECT_N_LEAKS(2);
+#endif
+    CommsMessage msg;
+    msg.setModuleId(MODULE_ID_NO_REPLY);
+
+    // 1. Sending empty message
+    CHECK(client.send(msg) == 0);
+
+    // 2. Check contents of message (empty message)
+    CommsMessage msg2;
+    msg2.setModuleId(MODULE_ID_ECHO);
+    CommsMessage receivedMsg;
+
+    CHECK(client.sendReceive(msg2, receivedMsg, 1) == 0);
+    CHECK(msg2.toString().compare(receivedMsg.toString()) == 0);
+    CHECK(msg2.getModuleId() == receivedMsg.getModuleId());
+
+    // 3. Message payload check
+    CommsMessage msg3;
+    msg3.setModuleId(MODULE_ID_ECHO);
+    CommsMessage receivedMsg2;
+
+    int in = 0xCAFEBABE;
+    int zero = 0;
+    int one = 1;
+    int max = 0xFFFFFFFF;
+    int neg = -12345;
+    string ascii = "abcdefghijklmnopqrstyvwxyzABCDEFGHIJKLMNOPQRSTYVWXYZ0123456789";
+    msg3 << ascii << in << zero << one << max << neg;
+
+    CHECK(client.sendReceive(msg3, receivedMsg2, 1) == 0);
+
+    string s;
+    int i;
+    receivedMsg2 >> s;
+    CHECK(s.compare(ascii) == 0);
+    receivedMsg2 >> i;
+    CHECK(i == in);
+    receivedMsg2 >> i;
+    CHECK(i == zero);
+    receivedMsg2 >> i;
+    CHECK(i == one);
+    receivedMsg2 >> i;
+    CHECK(i == max);
+    receivedMsg2 >> i;
+    CHECK(i == neg);
+
+}
+
+/**
+ * Test message sending with wait for ever flag
+ * 1. Check contents of message (empty message)
+ * 2. Message payload check
+ */
+
+TEST(SendReceive, normalwaitforever)
+{
+#ifdef __SYMBIAN32__
+    EXPECT_N_LEAKS(1);
+#else
+    EXPECT_N_LEAKS(2);
+#endif
+    // 1. Check contents of message (empty message)
+    CommsMessage msg2;
+    msg2.setModuleId(MODULE_ID_ECHO);
+    CommsMessage receivedMsg;
+
+    CHECK(client.sendReceive(msg2, receivedMsg, WAIT_FOR_EVER) == 0);
+    CHECK(msg2.toString().compare(receivedMsg.toString()) == 0);
+    CHECK(msg2.getModuleId() == receivedMsg.getModuleId());
+
+    // 2. Message payload check
+    CommsMessage msg3;
+    msg3.setModuleId(MODULE_ID_ECHO);
+    CommsMessage receivedMsg2;
+
+    int in = 0xCAFEBABE;
+    int zero = 0;
+    int one = 1;
+    int max = 0xFFFFFFFF;
+    int neg = -12345;
+    string ascii = "abcdefghijklmnopqrstyvwxyzABCDEFGHIJKLMNOPQRSTYVWXYZ0123456789";
+    msg3 << ascii << in << zero << one << max << neg;
+
+    CHECK(client.sendReceive(msg3, receivedMsg2, WAIT_FOR_EVER) == 0);
+
+    string s;
+    int i;
+    receivedMsg2 >> s;
+    CHECK(s.compare(ascii) == 0);
+    receivedMsg2 >> i;
+    CHECK(i == in);
+    receivedMsg2 >> i;
+    CHECK(i == zero);
+    receivedMsg2 >> i;
+    CHECK(i == one);
+    receivedMsg2 >> i;
+    CHECK(i == max);
+    receivedMsg2 >> i;
+    CHECK(i == neg);
+
+}
+
+/**
+ * Test message sending with big timeout values
+ * 1. OpenC timeout limit
+ * 2. 1h timeout
+ * 3. 24h timeout
+ */
+
+TEST(SendReceive, bigtimeout)
+{
+    EXPECT_N_LEAKS(1);
+    CommsMessage msg;
+    msg.setModuleId(MODULE_ID_ECHO);
+    CommsMessage receivedMsg;
+
+    // 1. OpenC timeout limit
+    CHECK(client.sendReceive(msg, receivedMsg, 2148) == 0);
+    CHECK(msg.getModuleId() == receivedMsg.getModuleId());
+
+    // 2. 1h timeout
+    CHECK(client.sendReceive(msg, receivedMsg, 3600) == 0);
+    CHECK(msg.getModuleId() == receivedMsg.getModuleId());
+
+    // 3. 24h timeout
+    CHECK(client.sendReceive(msg, receivedMsg, 86400) == 0);
+    CHECK(msg.getModuleId() == receivedMsg.getModuleId());
+}
+
+/**
+ * Test message sending
+ * 1. Sending big message
+ */
+
+TEST(SendReceive, bigmessage)
+{
+#ifdef __SYMBIAN32__
+    EXPECT_N_LEAKS(1);
+#else
+    EXPECT_N_LEAKS(2);
+#endif
+    // 1. Sending big message
+    int SIZE = 60000; // 60k
+    char* array = new char[SIZE];
+    for (int i = 0; i < SIZE; i++)
+    {
+        array[i] = i;
+    }
+    string input(array, SIZE);
+    delete[] array;
+
+    CommsMessage msg;
+    msg.setModuleId(MODULE_ID_ECHO);
+    msg << input;
+
+    CommsMessage receivedMsg;
+    CHECK(client.sendReceive(msg, receivedMsg, 1) == 0);
+
+    string s;
+    receivedMsg >> s;
+    CHECK(s.compare(input) == 0);
+}
+
+
+/**
+ * Test reply from listener
+ * 1. sendReceive and reply from listener
+ */
+
+TEST(SendReceive, listener)
+{
+    // 1. sendReceive and reply from listener
+    int MODULEID = 666;
+    CommsEndpoint* comms = server.getComms();
+    EchoListener listener(comms);
+
+    CHECK(!comms->registerListener(MODULEID, &listener));
+
+    CommsMessage msg;
+    msg.setModuleId(MODULEID);
+    msg << "hello world";
+
+    CommsMessage receivedMsg;
+    CHECK(client.sendReceive(msg, receivedMsg, 1) == 0);
+
+    string s;
+    receivedMsg >> s;
+    CHECK(s.compare("hello world") == 0);
+
+    CHECK(!comms->unregisterListener(MODULEID, &listener));
+}
+
+
+/**
+ * Test sendReceive timeout
+ * 1. sendReceive no timeout
+ * 2. sendReceive timeout
+ */
+
+TEST(SendReceive, timeouts)
+{
+    EXPECT_N_LEAKS(1);
+    // 1. sendReceive no timeout
+    CommsMessage msg;
+    msg.setModuleId(MODULE_ID_SLEEP_1S);
+
+    CommsMessage receivedMsg;
+    CHECK(client.sendReceive(msg, receivedMsg, 2) == 0);
+
+    // 2. sendReceive timeout
+    msg.setModuleId(MODULE_ID_NO_REPLY);
+    CHECK(client.sendReceive(msg, receivedMsg, 1) != 0);
+}
+
+
+/**
+ * Test send error cases
+ * 1. send when not connected
+ * 2. sendReceive when not connected
+ * 3. send to non-existing endpoint
+ * 4. invalid timeout values
+ */
+
+TEST(SendReceive, errors)
+{
+    EXPECT_N_LEAKS(1);
+    CommsClientEndpoint con;
+
+    // 1. send when not connected
+    CommsMessage msg;
+    msg.setModuleId(MODULE_ID_ECHO);
+    CHECK(!con.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+    CHECK(!con.send(msg));
+    CHECK(!con.disconnect());
+    CHECK(con.send(msg)!=0);
+
+    // 2. sendReceive when not connected
+    CommsMessage receivedMsg;
+    CHECK(!con.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+    CHECK(!con.sendReceive(msg, receivedMsg, 2));
+    CHECK(!con.sendReceive(msg, receivedMsg, WAIT_FOR_EVER));
+    CHECK(!con.disconnect());
+    CHECK(con.sendReceive(msg, receivedMsg, 2)!=0);
+
+    // 3. send to non-existing endpoint
+    CommsMessage dummy;
+    dummy.setReceiver(666);
+    CHECK(server.getComms()->send(msg) != 0);
+
+    // 4. invalid timeout values
+    msg.setModuleId(MODULE_ID_ECHO);
+    CHECK(!con.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+    CHECK(con.sendReceive(msg, receivedMsg, 0)!=0);
+    CHECK(con.sendReceive(msg, receivedMsg, -2)!=0);
+    CHECK(!con.disconnect());
+}
+
+/**
+ * Test multithread send (client)
+ * 1. send in multiple threads
+ * 2. sendReceive in multiple threads
+ */
+
+void doSends(CommsClientEndpoint* aComms)
+{
+    CommsMessage msg;
+    msg.setModuleId(MODULE_ID_ECHO);
+    CommsMessage receivedMsg;
+
+    for (int i = 0; i < 5; i++)
+    {
+        CHECK(aComms->send(msg) == 0);
+        CHECK(aComms->sendReceive(msg, receivedMsg, 1) == 0);
+        CHECK(aComms->sendReceive(msg, receivedMsg, WAIT_FOR_EVER) == 0);
+        usleep(300000); //0.3s
+    }
+}
+
+void* clientSendThread(void* aComms)
+{
+    CommsClientEndpoint* comms = reinterpret_cast<CommsClientEndpoint*>(aComms);
+    doSends(comms);
+    return 0;
+}
+
+TEST(SendReceive, multiThreadClient)
+{
+    EXPECT_N_LEAKS(1);
+    CommsClientEndpoint con;
+    CHECK(!con.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+
+    const int NUM_THREADS = 5;
+    pthread_t thread[NUM_THREADS];
+
+    for (int i=0; i<NUM_THREADS; i++)
+    {
+        pthread_create(&thread[i], 0, &clientSendThread, &con);
+    }
+
+    for (int i=0; i<NUM_THREADS; i++)
+    {
+        pthread_join(thread[i], 0);
+    }
+
+    CHECK(!con.disconnect());
+}
+
+
+class ReplyListener : public CommsListener
+{
+public:
+    ReplyListener(CommsEndpoint& aComms, Monitor& aMonitor)
+            : mComms(aComms), mMonitor(aMonitor), mReplyCount(30) {}
+    virtual void processMessage(CommsMessage& aMessage)
+    {
+        CommsMessage reply;
+        reply.replyTo(aMessage);
+        //ELOG1(EJavaComms, "ReplyListener count=%d", mReplyCount);
+        mComms.send(reply);
+
+        if (--mReplyCount < 0)
+        {
+            mMonitor.notify();
+        }
+        //ELOG1(EJavaComms, "ReplyListener after send count=%d", mReplyCount);
+    }
+private:
+    CommsEndpoint& mComms;
+    Monitor& mMonitor;
+    int mReplyCount;
+};
+
+TEST(SendReceive, sendsInProcessMessage)
+{
+    EXPECT_N_LEAKS(1);
+    std::auto_ptr<Monitor> monitor(Monitor::createMonitor());
+
+    CommsClientEndpoint con;
+    ReplyListener listener(con, *monitor);
+
+    CHECK(!con.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+    CHECK(!con.registerDefaultListener(&listener));
+
+    CommsMessage msg;
+    CHECK(!con.send(msg));
+
+    monitor->wait();
+    CHECK(!con.disconnect());
+}