--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javacommons/comms/tsrc/src/sendreceive.cpp Tue Apr 27 16:30:29 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());
+}