/*

* Copyright (c) 2010 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.impl.rt.support;

import com.nokia.mj.impl.rt.test.UnitTestSuiteCreator;

import com.nokia.mj.impl.rt.test.JvmPortTest;

import com.nokia.mj.impl.rt.support.Jvm;

import com.nokia.mj.impl.rt.support.JvmInternal;

import j2meunit.framework.Test;

import j2meunit.framework.TestCase;

import j2meunit.framework.TestMethod;

import j2meunit.framework.TestSuite;

/**

 * JvmPort basic unit tests. Testing that the delegation works.

 */

public class JvmPortBasicTest extends TestCase implements UnitTestSuiteCreator

{

    // Begin j2meunit test framework setup

    public TestSuite createTestSuite(String[] args)

    {

        TestSuite suite = new TestSuite(this.getClass().getName());

        suite.addTest(new JvmPortBasicTest("testJvm", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((JvmPortBasicTest)tc).testJvm();

            }

        }));

        suite.addTest(new JvmPortBasicTest("testVmPortNotExist", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((JvmPortBasicTest)tc).testVmPortNotExist();

            }

        }));

        return suite;

    }

    public JvmPortBasicTest()

    {

    }

    public JvmPortBasicTest(String aTestName, TestMethod aTestMethod)

    {

        super(aTestName, aTestMethod);

    }

    // End j2meunit test framework setup

    protected void setUp()

    {

    }

    protected void tearDown()

    {

    }

    private void checkCallCounts(String info, int ind)

    {

        assertTrue(info + " failed " + JvmPortTest.print(),

                   JvmPortTest.checkCalls(ind));

    }

    private void checkObjects(String info, Object obj1, Object obj2, Object res)

    {

        boolean ok = JvmPortTest.mObj1 == obj1;

        if (!ok && obj1 != null)

        {

            ok = obj1.equals(JvmPortTest.mObj1);

        }

        assertTrue(info + " failed. obj1 " + obj1 + " != " + " mObj1 " + JvmPortTest.mObj1, ok);

        ok = JvmPortTest.mObj2 == obj2;

        if (!ok && obj2 != null)

        {

            ok = obj2.equals(JvmPortTest.mObj2);

        }

        assertTrue(info + " failed. obj2 " + obj2 + " != " + " mObj2 " + JvmPortTest.mObj2, ok);

        ok = JvmPortTest.mReturnObj == res;

        if (!ok && res != null)

        {

            ok = res.equals(JvmPortTest.mReturnObj);

        }

        assertTrue(info + " failed. res " + res + " != " + " mReturnObj " + JvmPortTest.mReturnObj, ok);

    }

    // Test cases

    private static final String sysProp = "com.nokia.jvm.port";

    private void setPort(String port)

    {

        JvmPortTest.setSystemPropertyImpl(sysProp, port);

        JvmPortTest.resetInstance();

    }

    private void testJvm()

    {

        final String testProp = "test.JvmPortTest";

        String origPort = System.getProperty(sysProp);

        try

        {

            Object testObject1 = new String("testlib");

            Object testObject2 = null;

            Object returnObject = null;

            String methodName;

            //************ Jvm.loadSystemLibrary ***************************

            setPort(testProp);

            Jvm.loadSystemLibrary((String)testObject1);

            setPort(origPort);

            methodName = "Jvm.loadSystemLibrary()";

            checkCallCounts(methodName, JvmPortTest.LOADSYSTEMLIBRARY_CALL);

            checkObjects(methodName, testObject1, null, null);

            JvmPortTest.clear();

            //************ Jvm.loadApplicationClass ***************************

            testObject1 = new String("testClass");

            JvmPortTest.mReturnObj = getClass();

            setPort(testProp);

            returnObject = Jvm.loadApplicationClass((String)testObject1);

            methodName = "Jvm.loadApplicationClass()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.LOADAPPLICATIONCLASS_CALL);

            checkObjects(methodName, testObject1, null, returnObject);

            JvmPortTest.clear();

            JvmPortTest.mThrowable = new ClassNotFoundException();

            setPort(testProp);

            try

            {

                returnObject = Jvm.loadApplicationClass((String)testObject1);

                setPort(origPort);

                assertTrue(methodName + ", no Excpetion", false);

            }

            catch (ClassNotFoundException cnfe)

            {

                setPort(origPort);

                assertTrue(methodName + ", wrong exception: " + cnfe,

                           cnfe == JvmPortTest.mThrowable);

            }

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.LOADAPPLICATIONCLASS_CALL);

            JvmPortTest.clear();

            //************ Jvm.setThreadAsDaemon ***************************

            testObject1 = new Thread(new Runnable()

            {

                public void run() {}

            });

            testObject2 = new Boolean(true);

            setPort(testProp);

            Jvm.setThreadAsDaemon((Thread)testObject1, ((Boolean)testObject2).booleanValue());

            methodName = "Jvm.setThreadAsDaemon()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.SETTHREADASDAEMON_CALL);

            checkObjects(methodName, testObject1, testObject2, null);

            JvmPortTest.clear();

            JvmPortTest.mThrowable = new IllegalThreadStateException();

            setPort(testProp);

            try

            {

                Jvm.setThreadAsDaemon((Thread)testObject1, ((Boolean)testObject2).booleanValue());

                setPort(origPort);

                assertTrue(methodName + ", no Excpetion", false);

            }

            catch (IllegalThreadStateException itse)

            {

                setPort(origPort);

                assertTrue(methodName + ", wrong exception: " + itse,

                           itse == JvmPortTest.mThrowable);

            }

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.SETTHREADASDAEMON_CALL);

            JvmPortTest.clear();

            JvmPortTest.mThrowable = new SecurityException();

            setPort(testProp);

            try

            {

                Jvm.setThreadAsDaemon((Thread)testObject1, ((Boolean)testObject2).booleanValue());

                setPort(origPort);

                assertTrue(methodName + ", no Excpetion", false);

            }

            catch (SecurityException se)

            {

                setPort(origPort);

                assertTrue(methodName + ", wrong exception: " + se,

                           se == JvmPortTest.mThrowable);

            }

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.SETTHREADASDAEMON_CALL);

            JvmPortTest.clear();

            //************ Jvm.getResourceAsNativeMemory ***************************

            setPort(testProp);

            testObject1 = new String("jarPath");

            testObject2 = new String("resName");

            JvmPortTest.mReturnObj = new NativeMemoryBlock()

            {

                public long getPointer()

                {

                    return 0;

                }

                public int getSize()

                {

                    return 0;

                }

                public void freeMemory() {}

            };

            returnObject = Jvm.getResourceAsNativeMemory((String)testObject1, (String)testObject2);

            methodName = "Jvm.getResourceAsNativeMemory()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.GETRESOURCEASNATIVEMEMORY_CALL);

            checkObjects(methodName, testObject1, testObject2, returnObject);

            JvmPortTest.clear();

            //************ JvmInternal.enableRuntimeExit ***************************

            setPort(testProp);

            JvmInternal.enableRuntimeExit();

            methodName = "JvmInternal.enableRuntimeExit()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.ENABLERUNTIMEEXIT_CALL);

            checkObjects(methodName, null, null, null);

            JvmPortTest.clear();

            //************ JvmInternal.disableRuntimeExit ***************************

            setPort(testProp);

            JvmInternal.disableRuntimeExit();

            methodName = "JvmInternal.disableRuntimeExit()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.DISABLERUNTIMEEXIT_CALL);

            checkObjects(methodName, null, null, null);

            JvmPortTest.clear();

            //************ JvmInternal.exitVm ***************************

            setPort(testProp);

            testObject1 = new Integer(42);

            JvmInternal.exitVm(((Integer)testObject1).intValue());

            methodName = "JvmInternal.exitVm()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.EXITVM_CALL);

            checkObjects(methodName, testObject1, null, null);

            JvmPortTest.clear();

            //************ JvmInternal.enableFinalization ***************************

            setPort(testProp);

            testObject1 = getClass();

            JvmInternal.enableFinalization((Class)testObject1);

            methodName = "JvmInternal.enableFinalization()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.ENABLEFINALIZATION_CALL);

            checkObjects(methodName, testObject1, null, null);

            JvmPortTest.clear();

            //************ JvmInternal.runFinalization ***************************

            setPort(testProp);

            JvmInternal.runFinalization();

            methodName = "JvmInternal.runFinalization()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.RUNFINALIZATION_CALL);

            checkObjects(methodName, null, null, null);

            JvmPortTest.clear();

            //************ JvmInternal.runYoungGenerationGc ***************************

            setPort(testProp);

            JvmPortTest.mReturnObj = new Boolean(true);

            boolean res = JvmInternal.runYoungGenerationGc();

            returnObject = new Boolean(res);

            methodName = "JvmInternal.runYoungGenerationGc()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.RUNYOUNGGENERATIONGC_CALL);

            checkObjects(methodName, null, null, returnObject);

            JvmPortTest.clear();

            //************ JvmInternal.setThreadEventListener ***************************

            setPort(testProp);

            testObject1 = new ThreadEventListener()

            {

                public void threadStarting(Thread newThread, Thread parentThread) {}

                public void threadDied(Thread thread) {}

                public void uncaughtException(Thread thread, Throwable e) {}

            };

            JvmInternal.setThreadEventListener((ThreadEventListener)testObject1);

            methodName = "JvmInternal.setThreadEventListener()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.SETTHREADEVENTLISTENER_CALL);

            checkObjects(methodName, testObject1, null, null);

            JvmPortTest.clear();

            //************ JvmInternal.addRestrictedPackagePrefixes ***************************

            setPort(testProp);

            testObject1 = new String[] {"package1, package2, package3"};

            JvmInternal.addRestrictedPackagePrefixes((String[])testObject1);

            methodName = "JvmInternal.addRestrictedPackagePrefixes()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.ADDRESTRICTEDPACKAGEPREFIXES_CALL);

            checkObjects(methodName, testObject1, null, null);

            JvmPortTest.clear();

            JvmPortTest.mThrowable = new SecurityException();

            setPort(testProp);

            try

            {

                JvmInternal.addRestrictedPackagePrefixes((String[])testObject1);

                setPort(origPort);

                assertTrue(methodName + ", no Excpetion", false);

            }

            catch (SecurityException se)

            {

                setPort(origPort);

                assertTrue(methodName + ", wrong exception: " + se,

                           se == JvmPortTest.mThrowable);

            }

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.ADDRESTRICTEDPACKAGEPREFIXES_CALL);

            JvmPortTest.clear();

            //************ JvmInternal.addProtectedPackagePrefixes ***************************

            setPort(testProp);

            testObject1 = new String[] {"package4, package5, package6"};

            JvmInternal.addProtectedPackagePrefixes((String[])testObject1);

            methodName = "JvmInternal.addProtectedPackagePrefixes()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.ADDPROTECTEDPACKAGEPREFIXES_CALL);

            checkObjects(methodName, testObject1, null, null);

            JvmPortTest.clear();

            JvmPortTest.mThrowable = new SecurityException();

            setPort(testProp);

            try

            {

                JvmInternal.addProtectedPackagePrefixes((String[])testObject1);

                setPort(origPort);

                assertTrue(methodName + ", no Excpetion", false);

            }

            catch (SecurityException se)

            {

                setPort(origPort);

                assertTrue(methodName + ", wrong exception: " + se,

                           se == JvmPortTest.mThrowable);

            }

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.ADDPROTECTEDPACKAGEPREFIXES_CALL);

            JvmPortTest.clear();

            //************ JvmInternal.appendToClassPath ***************************

            setPort(testProp);

            testObject1 = new String("class to append");

            JvmInternal.appendToClassPath((String)testObject1);

            methodName = "JvmInternal.appendToClassPath()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.APPENDTOCLASSPATH_CALL);

            checkObjects(methodName, testObject1, null, null);

            JvmPortTest.clear();

            //************ JvmInternal.shrinkJavaHeapToMinimum ***************************

            setPort(testProp);

            JvmPortTest.mReturnObj = new Integer(22);

            int res2 = JvmInternal.shrinkJavaHeapToMinimum();

            returnObject = new Integer(res2);

            methodName = "JvmInternal.shrinkJavaHeapToMinimum()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.SHRINKJAVAHEAPTOMINIMUM_CALL);

            checkObjects(methodName, null, null, returnObject);

            JvmPortTest.clear();

            //************ JvmInternal.expandJavaHeap ***************************

            setPort(testProp);

            testObject1 = new Integer(33);

            JvmPortTest.mReturnObj = new Integer(44);

            int res3 = JvmInternal.expandJavaHeap(((Integer)testObject1).intValue());

            returnObject = new Integer(res3);

            methodName = "JvmInternal.expandJavaHeap()";

            setPort(origPort);

            checkCallCounts(methodName, JvmPortTest.EXPANDJAVAHEAP_CALL);

            checkObjects(methodName, testObject1, null, returnObject);

            JvmPortTest.clear();

            //************ END***************************

            assertTrue("Calls missed", JvmPortTest.allCalled());

        }

        catch (Throwable t)

        {

            setPort(origPort);

            t.printStackTrace();

            assertTrue(t.toString(), false);

        }

        setPort(origPort);

    }

    private void testVmPortNotExist()

    {

        System.out.println("NOTE!! IT IS EXPECTED THAT THIS TEST WILL LEAD TO SOME ERROR LOGS.");

        final String testProp = "test.JvmPortTest";

        String origPort = System.getProperty(sysProp);

        try

        {

            setPort("TestPort");

            JvmInternal.enableRuntimeExit();

            setPort(origPort);

            assertTrue("No exception.", false);

        }

        catch (RuntimeException re)

        {

            setPort(origPort);

            int ind = re.toString().indexOf("Not able to instantiate class com.nokia.mj.impl.rt.TestPort");

            boolean ok = ind >= 0;

            if (!ok)

            {

                // Accept also java.lang.ExceptionInInitializerError.

                ok = re.toString().equals("java.lang.ExceptionInInitializerError");

            }

            assertTrue(re.toString(),  ok);

        }

        catch (Throwable t)

        {

            t.printStackTrace();

            assertTrue(t.toString(), false);

        }

        try

        {

            setPort(origPort);

        }

        catch (Throwable t)

        {

        }

    }

}