--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javacommons/comms/tsrc/src/connect.cpp Mon May 03 12:27:20 2010 +0300
@@ -0,0 +1,424 @@
+/*
+* 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 <errno.h>
+#include "monitor.h"
+#include "TestHarness.h"
+#include "logger.h"
+
+#include "commsserverendpoint.h"
+#include "commsclientendpoint.h"
+#include "commsmessage.h"
+#include "echoserver.h"
+
+using namespace java::comms;
+using java::util::Monitor;
+
+TEST_GROUP(Connect)
+{
+ CommsServerEndpoint comms;
+
+ TEST_SETUP()
+ {
+ comms.start(IPC_ADDRESS_COMMS_MODULE_TEST);
+ }
+
+ TEST_TEARDOWN()
+ {
+ comms.stop();
+ }
+};
+
+/**
+ * Test open connection
+ * 1. Normal connect, disconnect
+ * 2. Multiple connect calls without disconnect
+ * 3. Disconnect before connect
+ * 4. Connect to non-existing host
+ */
+
+TEST(Connect, OpenConnection)
+{
+ CommsClientEndpoint client;
+
+ // 1. Normal connect, disconnect
+ CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!client.disconnect());
+
+ // 2. Multiple connect calls without disconnect
+ CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!client.disconnect());
+
+ // 3. Disconnect before connect
+ CHECK(!client.disconnect());
+ CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!client.disconnect());
+
+ // 4. Connect to non-existing host
+ CHECK(client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+666));
+ CHECK(!client.disconnect());
+}
+
+/**
+ * Test open connection with multiple clients
+ * 1. Normal connect, disconnect
+ * 2. Multiple connect/disconnects
+ */
+
+TEST(Connect, MultiClient)
+{
+ CommsClientEndpoint a, b, c, d, e;
+
+ // 1. Normal connect, disconnect
+ CHECK(!a.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!b.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!c.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!d.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!e.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!e.disconnect());
+ CHECK(!d.disconnect());
+ CHECK(!c.disconnect());
+ CHECK(!b.disconnect());
+ CHECK(!a.disconnect());
+
+ // 2. Multiple connect/disconnects
+ for (int i=0; i<10; i++)
+ {
+ CHECK(!a.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!b.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!c.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!d.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!e.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!e.disconnect());
+ CHECK(!d.disconnect());
+ CHECK(!c.disconnect());
+ CHECK(!b.disconnect());
+ CHECK(!a.disconnect());
+ }
+}
+
+/**
+ * Test server cases
+ * 1. Server exits while client is connected
+ * 2. Address is already in use
+ * 3. Start/Connect using different addresses
+ */
+
+TEST(Connect, Server)
+{
+ CommsServerEndpoint server;
+ CommsClientEndpoint client;
+ int ADDR = IPC_ADDRESS_COMMS_MODULE_TEST + 1;
+
+ // 1. Server exits while client is connected
+ CHECK(!server.start(ADDR));
+ CHECK(!client.connect(ADDR));
+ CHECK(!server.stop());
+ CHECK(!client.disconnect());
+
+ // 2. Address is already in use
+ CHECK(server.start(IPC_ADDRESS_COMMS_MODULE_TEST)!=0);
+ CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!server.stop());
+ CHECK(!client.disconnect());
+
+ // 3. Start/Connect using different addresses
+ CHECK(!server.start(ADDR));
+ CHECK(!client.connect(ADDR));
+ CHECK(!client.disconnect());
+ CHECK(!server.stop());
+
+ CHECK(!server.start(ADDR+1));
+ CHECK(!client.connect(ADDR+1));
+ CHECK(!client.disconnect());
+ CHECK(!server.stop());
+
+}
+
+/**
+ * Test connect/disconnect from separate threads
+ * 1. connect/disconnect from separate threads
+ * 2. start/stop from separate threads
+ */
+
+void doDisconnect(CommsClientEndpoint* aClient)
+{
+ CHECK(!aClient->disconnect());
+}
+void* disconnectThread(void* aComms)
+{
+ CommsClientEndpoint* client = reinterpret_cast<CommsClientEndpoint*>(aComms);
+ doDisconnect(client);
+ return 0;
+}
+
+void doStop(CommsServerEndpoint* aServer)
+{
+ CHECK(!aServer->stop());
+}
+void* stopThread(void* aComms)
+{
+ CommsServerEndpoint* server = reinterpret_cast<CommsServerEndpoint*>(aComms);
+ doStop(server);
+ return 0;
+}
+
+TEST(Connect, separateThread)
+{
+ CommsServerEndpoint server;
+ CommsClientEndpoint client;
+ int ADDR = IPC_ADDRESS_COMMS_MODULE_TEST + 1;
+
+ CommsMessage msg;
+
+ // 1. connect/disconnect from separate threads
+ CHECK(!server.start(ADDR));
+ CHECK(!client.connect(ADDR));
+
+ CHECK(client.send(msg) == 0);
+ pthread_t threadId = 0;
+ pthread_create(&threadId, 0, disconnectThread, &client);
+ pthread_join(threadId, 0);
+ CHECK(client.send(msg) != 0);
+
+ // 2. start/stop from separate threads
+ pthread_create(&threadId, 0, stopThread, &server);
+ pthread_join(threadId, 0);
+
+ CommsServerEndpoint server2;
+ CHECK(!server2.start(ADDR));
+ CHECK(!server2.stop());
+}
+
+/**
+ * Check that onStart and onExit callbacks are done
+ * (ensures that ipc provider implementation is done correctly)
+ * 1. Callbacks are done after connect/disconnect
+ * 2. Callbacks are done after start/stop
+ */
+
+class OnStartExitClient : public CommsClientEndpoint
+{
+public:
+ OnStartExitClient() : mOnStart(false), mOnExit(false) {}
+
+ virtual void onStart()
+ {
+ mOnStart = true;
+ }
+ virtual void onExit()
+ {
+ mOnExit = true;
+ }
+
+ bool mOnStart;
+ bool mOnExit;
+};
+
+class OnStartExitServer : public CommsServerEndpoint
+{
+public:
+ OnStartExitServer() : mOnStart(false), mOnExit(false) {}
+
+ virtual void onStart()
+ {
+ mOnStart = true;
+ }
+ virtual void onExit()
+ {
+ mOnExit = true;
+ }
+
+ bool mOnStart;
+ bool mOnExit;
+};
+
+TEST(Connect, onStartExit)
+{
+ // 1. Callbacks are done after connect/disconnect
+ OnStartExitClient client;
+ CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+ CHECK(!client.disconnect());
+ CHECK(client.mOnStart);
+ CHECK(client.mOnExit);
+
+ // 2. Callbacks are done after start/stop
+ OnStartExitServer server;
+ CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+ CHECK(!server.stop());
+ CHECK(server.mOnStart);
+ CHECK(server.mOnExit);
+}
+
+
+/**
+ * Test disconnect/stop while sendReceive is pending
+ * 1. disconnect while sendReceive is pending in client
+ * 2. stop while sendReceive is pending in client
+ * 3. disconnect while sendReceive is pending in server
+ * 4. stop while sendReceive is pending in server
+ */
+
+void doSendReceive(CommsEndpoint* aComms)
+{
+ CommsMessage msg;
+ msg.setModuleId(MODULE_ID_NO_REPLY);
+ CommsMessage receivedMsg;
+
+ int rc = aComms->sendReceive(msg, receivedMsg, 3);
+ CHECK(rc != 0);
+ CHECK(rc != ETIMEDOUT);
+
+ // check that next send fails as other party is disconnected
+ // (and receive thread may still be running depending on timing)
+ rc = aComms->send(msg);
+ CHECK(rc != 0);
+}
+
+void* sendReceiveThread(void* aComms)
+{
+ CommsEndpoint* comms = reinterpret_cast<CommsEndpoint*>(aComms);
+ doSendReceive(comms);
+ return 0;
+}
+
+class Notifier : public CommsListener
+{
+public:
+ Notifier(Monitor& aMonitor) : mMonitor(aMonitor) {}
+ virtual void processMessage(CommsMessage&)
+ {
+ mMonitor.notify();
+
+ }
+private:
+ Monitor& mMonitor;
+};
+
+struct threadData
+{
+ CommsEndpoint* comms;
+ int clientAddress;
+};
+
+void doServer(CommsEndpoint* aComms, int aAddress)
+{
+ CommsMessage msg;
+ msg.setReceiver(aAddress);
+ CommsMessage receivedMsg;
+
+ int rc = aComms->sendReceive(msg, receivedMsg, 3);
+ CHECK(rc != 0);
+ CHECK(rc != ETIMEDOUT);
+}
+
+void* serverThread(void* aData)
+{
+ threadData* data = reinterpret_cast<threadData*>(aData);
+ doServer(data->comms, data->clientAddress);
+ delete data;
+ return 0;
+}
+
+class ServerListener : public CommsListener
+{
+public:
+ ServerListener(CommsEndpoint& aComms) : mComms(aComms) {}
+ virtual void processMessage(CommsMessage& aMsg)
+ {
+ threadData* data = new threadData;
+ data->comms = &mComms;
+ data->clientAddress = aMsg.getSender();
+ pthread_t threadId = 0;
+ pthread_create(&threadId, 0, serverThread, data);
+ }
+private:
+ CommsEndpoint& mComms;
+};
+
+TEST(Connect, sendReceivePending)
+{
+ std::auto_ptr<Monitor> monitor(Monitor::createMonitor());
+
+ Notifier listener(*monitor);
+ CommsClientEndpoint client;
+
+ // 1. disconnect while sendReceive is pending in client
+ CHECK(!comms.registerDefaultListener(&listener));
+ CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));
+
+ pthread_t threadId = 0;
+ pthread_create(&threadId, 0, sendReceiveThread, &client);
+
+ monitor->wait();
+ CHECK(!client.disconnect());
+
+ pthread_join(threadId, 0);
+ CHECK(!comms.unregisterDefaultListener(&listener));
+
+ // 2. stop while sendReceive is pending in client
+ CommsServerEndpoint server;
+ CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+ CHECK(!server.registerDefaultListener(&listener));
+
+ CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+
+ threadId = 0;
+ pthread_create(&threadId, 0, sendReceiveThread, &client);
+
+ monitor->wait();
+ CHECK(!server.stop());
+
+ pthread_join(threadId, 0);
+ CHECK(!client.disconnect());
+ CHECK(!server.unregisterDefaultListener(&listener));
+
+ // 3. disconnect while sendReceive is pending in server
+ ServerListener serverListener(server);
+
+ CHECK(!server.registerDefaultListener(&serverListener));
+ CHECK(!client.registerDefaultListener(&listener));
+
+ CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+ CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+
+ CommsMessage msg;
+ CHECK(!client.send(msg));
+ monitor->wait();
+ CHECK(!client.disconnect());
+
+ CHECK(!server.stop());
+ CHECK(!server.unregisterDefaultListener(&serverListener));
+ CHECK(!client.unregisterDefaultListener(&listener));
+
+ // 4. stop while sendReceive is pending in server
+ CHECK(!server.registerDefaultListener(&serverListener));
+ CHECK(!client.registerDefaultListener(&listener));
+
+ CHECK(!server.start(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+ CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST+1));
+
+ CHECK(!client.send(msg));
+ monitor->wait();
+ CHECK(!server.stop());
+
+ CHECK(!client.disconnect());
+ CHECK(!server.unregisterDefaultListener(&serverListener));
+ CHECK(!client.unregisterDefaultListener(&listener));
+}
+