/*

* 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:

*

*/

package com.nokia.mj.test.comms;

import j2meunit.framework.Test;

import j2meunit.framework.TestCase;

import j2meunit.framework.TestSuite;

import j2meunit.framework.TestMethod;

import com.nokia.mj.impl.comms.CommsMessage;

import com.nokia.mj.impl.comms.CommsEndpoint;

import com.nokia.mj.impl.comms.CommsListener;

import com.nokia.mj.impl.comms.exception.CommsException;

import java.io.IOException;

public class TestCommsEndpoint extends TestCase

{

    private final int MODULE_ID_A           = 900;

    private final int MODULE_ID_B           = 901;

    private final int MODULE_ID_DATA_CHECK  = 902;

    private final int MODULE_ID_NO_REPLY    = 903;      // no reply is sent

    private final int MODULE_ID_SLEEP_1S    = 1000;     // reply msg is delayed by 1s

    private final int MODULE_ID_SLEEP_5S    = 5000;

    private final int MODULE_ID_SLEEP_10S   = 10000;

    private final int PLUGIN_ID_JAVACAPTAIN_COMMS_TESTER_C = 101; // see comms.h

    private final int SERVER_ADDRESS = CommsEndpoint.JAVA_CAPTAIN;

    private final String SERVER_NAME = "InstallerJavaCaptain";

    private final int TIMEOUT = 10;

    public TestCommsEndpoint()

    {

    }

    public TestCommsEndpoint(String sTestName, TestMethod rTestMethod)

    {

        super(sTestName, rTestMethod);

    }

    public Test suite()

    {

        TestSuite aSuite = new TestSuite();

        aSuite.addTest(new TestCommsEndpoint("testLoadCommsExtensionPlugin", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testLoadCommsExtensionPlugin();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testConstructor", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testConstructor();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testFind", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testFind();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testRegisterListener", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testRegisterListener();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testNoUnregisterListener", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testNoUnregisterListener();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testRegisterListenerInListener", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testRegisterListenerInListener();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testSend", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testSend();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testSendReceive", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testSendReceive();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testSendReceiveWithWaitForEver", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testSendReceiveWithWaitForEver();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testSendReceiveBigTimeout", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testSendReceiveBigTimeout();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testSendReceiveTimeout", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testSendReceiveTimeout();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testSendReceiveMultiThread", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testSendReceiveMultiThread();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testExitWhileSendReceivePending", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testExitWhileSendReceivePending();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testSendAndSendReceiveMultiThread", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testSendAndSendReceiveMultiThread();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testSendWhenNotConnected", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testSendWhenNotConnected();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testCheckMessageInListener", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testCheckMessageInListener();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testCheckNativePayload", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testCheckNativePayload();

            }

        }));

        aSuite.addTest(new TestCommsEndpoint("testDestroy", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestCommsEndpoint) tc).testDestroy();

            }

        }));

        return aSuite;

    }

    public void assertEquals(byte[] a, byte[] b)

    {

        assertEquals(a.length, b.length);

        for (int i = 0; i < a.length; i++)

        {

            assertEquals(a[i], b[i]);

        }

    }

    public void testLoadCommsExtensionPlugin()

    {

        System.out.println("TestCommsEndpoint.testLoadCommsExtensionPlugin()");

        CommsEndpoint comms = null;

        try

        {

            comms = new CommsEndpoint();

            comms.connect(SERVER_ADDRESS);

            // loads comms extension plugin in JavaCaptain

            CommsMessage message = new CommsMessage();

            message.setModuleId(PLUGIN_ID_JAVACAPTAIN_COMMS_TESTER_C);

            CommsMessage msg = comms.sendReceive(message, TIMEOUT);

        }

        catch (Exception e)

        {

            String error = "\n\nError !!!!!!!!!!!!!!!!!!!!!!\n\n"+

                           "Loading comms extension plugin failed.\n"+

                           "Check that comms extension plugin is built (make).\n"+

                           "This failure causes other tests to fail also.\n\n";

            System.out.println(error);

            fail(error);

        }

        finally

        {

            comms.destroy();

        }

    }

    public void testConstructor()

    {

        System.out.println("TestCommsEndpoint.testConstructor()");

        CommsEndpoint comms = null;

        // ok case

        try

        {

            comms = new CommsEndpoint();

            comms.connect(SERVER_ADDRESS);

            comms.disconnect();

        }

        catch (CommsException e)

        {

            fail("ctor(SERVER_NAME) failed");

        }

        finally

        {

            comms.destroy();

            comms = null;

        }

        // multiple endpoints

        CommsEndpoint comms1 = null;

        CommsEndpoint comms2 = null;

        CommsEndpoint comms3 = null;

        try

        {

            comms1 = new CommsEndpoint();

            comms2 = new CommsEndpoint();

            comms3 = new CommsEndpoint();

            comms1.connect(SERVER_ADDRESS);

            comms2.connect(SERVER_ADDRESS);

            comms3.connect(SERVER_ADDRESS);

        }

        catch (CommsException e)

        {

            fail(" multiple endpoints failed");

        }

        finally

        {

            comms1.destroy();

            comms2.destroy();

            comms3.destroy();

        }

        // multiple connect/disconnect calls

        try

        {

            comms = new CommsEndpoint();

            comms.disconnect();

            comms.connect(SERVER_ADDRESS);

            comms.connect(SERVER_ADDRESS);

            comms.disconnect();

            comms.disconnect();

        }

        catch (CommsException e)

        {

            fail("multiple start/stop calls failed");

        }

        finally

        {

            comms.destroy();

            comms = null;

        }

        // connect fails

        try

        {

            comms = new CommsEndpoint();

            comms.connect(666313);

            fail("connect to non-existing server did not fail");

        }

        catch (CommsException e)

        {

        }

        finally

        {

            comms.destroy();

            comms = null;

        }

    }

    public void testFind()

    {

        System.out.println("TestCommsEndpoint.testFind()");

        CommsEndpoint comms = null;

        // ok case

        try

        {

            comms = CommsEndpoint.find(SERVER_NAME);

            assertNotNull(comms);

            comms.send(new CommsMessage());

        }

        catch (CommsException e)

        {

            fail("ok case");

        }

        finally

        {

            comms.destroy();

            comms = null;

        }

        // not existing

        comms = CommsEndpoint.find("not existing");

        assertEquals(comms, null);

        comms = null;

        // multiple endpoints

        CommsEndpoint comms1 = null;

        CommsEndpoint comms2 = null;

        CommsEndpoint comms3 = null;

        try

        {

            comms1 = CommsEndpoint.find(SERVER_NAME);

            comms2 = CommsEndpoint.find(SERVER_NAME);

            comms3 = CommsEndpoint.find(SERVER_NAME);

            assertNotNull(comms1);

            assertNotNull(comms2);

            assertNotNull(comms3);

            comms1.send(new CommsMessage());

            comms2.send(new CommsMessage());

            comms3.send(new CommsMessage());

        }

        catch (CommsException e)

        {

            fail(" multiple endpoints failed");

        }

        finally

        {

            comms1.destroy();

            comms2.destroy();

            comms3.destroy();

        }

    }

    private void testRegisterListener()

    {

        System.out.println("TestCommsEndpoint.testRegisterListener()");

        class TestListener implements CommsListener

        {

            public void processMessage(CommsMessage message) {}

        }

        CommsEndpoint comms = null;

        try

        {

            comms = new CommsEndpoint();

            // register listener

            try

            {

                comms.registerListener(MODULE_ID_A, new TestListener());

                comms.unregisterListener(MODULE_ID_A);

            }

            catch (CommsException e)

            {

                fail("register listener");

            }

            // register multiple listeners

            try

            {

                int i = 100;

                for (; i < 300; i++)

                {

                    comms.registerListener(i, new TestListener());

                }

                for (i--; i > 99; i--)

                {

                    comms.unregisterListener(i);

                }

            }

            catch (CommsException e)

            {

                fail("register multiple listeners");

            }

            // listener already exists

            try

            {

                comms.registerListener(MODULE_ID_A, new TestListener());

                comms.registerListener(MODULE_ID_A, new TestListener());

                fail("registerListener did not fail");

            }

            catch (CommsException e) {}

            // listener doesn't exists

            try

            {

                comms.unregisterListener(MODULE_ID_A);

                comms.unregisterListener(MODULE_ID_A);

                fail("unregisterListener did not fail");

            }

            catch (CommsException e) {}

            // listener null

            try

            {

                comms.registerListener(MODULE_ID_A, null);

                fail("registerListener did not fail with null");

            }

            catch (Exception e) {}

            // register default listener

            try

            {

                comms.registerDefaultListener(new TestListener());

                comms.unregisterDefaultListener();

            }

            catch (Exception e)

            {

                fail("registerDefaultListener");

            }

            // default listener already exists

            try

            {

                comms.registerDefaultListener(new TestListener());

                comms.registerDefaultListener(new TestListener());

                fail("registerListener did not fail");

            }

            catch (CommsException e) {}

            // default listener doesn't exists

            try

            {

                comms.unregisterDefaultListener();

                comms.unregisterDefaultListener();

                fail("unregisterDefaultListener did not fail");

            }

            catch (CommsException e) {}

            // default listener null

            try

            {

                comms.registerDefaultListener(null);

                fail("registerDefaultListener did not fail with null");

            }

            catch (Exception e) {}

        }

        finally

        {

            comms.destroy();

        }

    }

    private void testNoUnregisterListener()

    {

        System.out.println("TestCommsEndpoint.testNoUnregisterListener()");

        class TestListener implements CommsListener

        {

            public void processMessage(CommsMessage message) {}

        }

        CommsEndpoint comms = null;

        try

        {

            comms = new CommsEndpoint();

            comms.connect(SERVER_ADDRESS);

            // register multiple listeners but no unregister

            try

            {

                comms.registerDefaultListener(new TestListener());

                for (int i = 0; i < 300; i++)

                {

                    comms.registerListener(i, new TestListener());

                }

            }

            catch (CommsException e)

            {

                fail("register multiple listeners");