diff -r 71ad690e91f5 -r d6dafc5d983f javacommons/utils/tsrc/javasrc/com/nokia/mj/impl/rt/support/JvmPortTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javacommons/utils/tsrc/javasrc/com/nokia/mj/impl/rt/support/JvmPortTest.java Fri Oct 15 12:29:39 2010 +0300 @@ -0,0 +1,799 @@ +/* +* 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.support.ShutdownListener; +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; + +import com.nokia.mj.impl.rt.support.prot.ProtectedTest; +/** + * JvmPort unit tests. + */ +public class JvmPortTest extends TestCase implements UnitTestSuiteCreator +{ + + // Begin j2meunit test framework setup + public TestSuite createTestSuite(String[] args) + { + TestSuite suite = new TestSuite(this.getClass().getName()); + String testSelector = "0000000000000000"; + if (args.length > 1 && args[1] != null) + { + testSelector = args[1] + "0000000000000000"; + } + + if (testSelector.charAt(0) != '0') + { + suite.addTest(new JvmPortTest("testLoadSystemLibrary", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testLoadSystemLibrary(); + } + })); + } + + + if (testSelector.charAt(0) != '0') + { + suite.addTest(new JvmPortTest("testLoadApplicationClass", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testLoadApplicationClass(); + } + })); + } + + if (testSelector.charAt(1) != '0') + { + suite.addTest(new JvmPortTest("testSetThreadAsDaemon", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testSetThreadAsDaemon(); + } + })); + } + + + if (testSelector.charAt(0) != '0') + { + suite.addTest(new JvmPortTest("testGetResourceAsNativeMemory", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testGetResourceAsNativeMemory(); + } + })); + } + + if (testSelector.charAt(2) != '0') + { + suite.addTest(new JvmPortTest("testEnableRuntimeExit", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testEnableRuntimeExit(); + } + })); + } + + + + if (testSelector.charAt(0) != '0') + { + suite.addTest(new JvmPortTest("testDisableRuntimeExit", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testDisableRuntimeExit(); + } + })); + } + + + if (testSelector.charAt(3) != '0') + { + suite.addTest(new JvmPortTest("testExitVm", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testExitVm(); + } + })); + } + + if (testSelector.charAt(0) != '0') + { + suite.addTest(new JvmPortTest("testYoungGenerationGc", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testYoungGenerationGc(); + } + })); + } + + if (testSelector.charAt(4) != '0') + { + suite.addTest(new JvmPortTest("testFinalization", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testFinalization(); + } + })); + } + + if (testSelector.charAt(0) != '0') + { + suite.addTest(new JvmPortTest("testSetThreadEventListener", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testSetThreadEventListener(); + } + })); + } + + if (testSelector.charAt(8) != '0') + { + suite.addTest(new JvmPortTest("testAddRestrictedPackagePrefixes", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testAddRestrictedPackagePrefixes(); + } + })); + } + + if (testSelector.charAt(0) != '0') + { + suite.addTest(new JvmPortTest("testAddProtectedPackagePrefixes", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testAddProtectedPackagePrefixes(); + } + })); + } + + + if (testSelector.charAt(5) != '0') + { + suite.addTest(new JvmPortTest("testAppendToClassPath", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testAppendToClassPath(); + } + })); + } + + + if (testSelector.charAt(6) != '0') + { + suite.addTest(new JvmPortTest("testShrinkJavaHeapToMinimum", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testShrinkJavaHeapToMinimum(); + } + })); + } + + if (testSelector.charAt(7) != '0') + { + suite.addTest(new JvmPortTest("testExpandJavaHeap", new TestMethod() + { + public void run(TestCase tc) + { + ((JvmPortTest)tc).testExpandJavaHeap(); + } + })); + } + + + return suite; + + } + + public JvmPortTest() + { + } + + public JvmPortTest(String aTestName, TestMethod aTestMethod) + { + super(aTestName, aTestMethod); + } + + // End j2meunit test framework setup + + protected void setUp() + { + } + + protected void tearDown() + { + } + + private static class ShutdownListenerImpl implements ShutdownListener + { + public int mShutDownCallCount = 0; + public void shuttingDown() + { + mShutDownCallCount++; + } + } + // Test cases + + private void testLoadSystemLibrary() + { + try + { + //************ Jvm.loadSystemLibrary *************************** + Jvm.loadSystemLibrary("javacommonutilstest"); + + try + { + Jvm.loadSystemLibrary("nonexisting"); + assertTrue("Call should have failed", false); + } + catch (Error e) + { + int ind = e.toString().indexOf("Not able to load library nonexisting."); + boolean ok = ind >= 0; + if (!ok) + { + // Accept also java.lang.ExceptionInInitializerError. + ok = e.toString().startsWith("java.lang.UnsatisfiedLinkError"); +// ok = e instanceof UnsatisfiedLinkError; + } + assertTrue(e.toString(), ok); + } + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private void testLoadApplicationClass() + { + try + { + //************ Jvm.loadApplicationClass *************************** + javax.microedition.rms.RecordComparator obj = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest.TestClass").newInstance(); + assertTrue("Object was null", obj != null); + int res = obj.compare(null, null); + assertTrue("Incorrect result: " + res, res == 42); + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private boolean isCldc() + { + String cldcProp = System.getProperty("com.nokia.jvm.port"); + if (cldcProp != null && cldcProp.equals("j9.JvmPortCldc")) + { + return true; + } + return false; + + } + private void testSetThreadAsDaemon() + { + try + { + //************ Jvm.setThreadAsDaemon *************************** + Thread th = new Thread(new Runnable() + { + public void run() + { + try + { + Thread.sleep(2000); + } + catch (Exception re) + { + } + } + }); + if (isCldc()) + { + try + { + Jvm.setThreadAsDaemon(th, false); + } + catch (RuntimeException re) + { + assertTrue(re.toString(), re.toString().indexOf("Setting thread as non-daemon not supported") >= 0); + } + } + else + { + Jvm.setThreadAsDaemon(th, false); + } + Jvm.setThreadAsDaemon(th, true); + th.start(); + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private static final String jarFile = "c:\\java\\jvmportapp.jar"; + private static final String jarFile2 = "c:\\java\\jvmportapp2.jar"; + + private void testGetResourceAsNativeMemory() + { + if (!isCldc()) + { + return; + } + try + { + //************ Jvm.getResourceAsNativeMemory *************************** + NativeMemoryBlock nativeMemory = Jvm.getResourceAsNativeMemory(null, "myres/info.txt"); + assertTrue("NativeMemoryBlock was null", nativeMemory != null); + + NativeMemoryBlock nativeMemory2 = Jvm.getResourceAsNativeMemory(null, "myres/info2.txt"); + assertTrue("NativeMemoryBlock2 was null", nativeMemory2 != null); + + String res = _getResource(nativeMemory.getPointer(), nativeMemory.getSize()); + assertTrue("Incorrect content1: " + res, res.equals("jvmPort(info): The quick brown fox jumps over the lazy dog")); + + res = _getResource(nativeMemory2.getPointer(), nativeMemory2.getSize()); + assertTrue("Incorrect content2 " + res, res.equals("jvmPort(info2): The quick brown fox jumps over the lazy dog")); + + nativeMemory.freeMemory(); + nativeMemory2.freeMemory(); + + NativeMemoryBlock nativeMemory3 = Jvm.getResourceAsNativeMemory(jarFile2, "myres/info.txt"); + assertTrue("NativeMemoryBlock3 was null", nativeMemory3 != null); + + NativeMemoryBlock nativeMemory4 = Jvm.getResourceAsNativeMemory(jarFile2, "myres/info2.txt"); + assertTrue("NativeMemoryBlock4 was null", nativeMemory4 != null); + + res = _getResource(nativeMemory3.getPointer(), nativeMemory3.getSize()); + assertTrue("Incorrect content3: " + res, res.equals("jvmPort2(info): The quick brown fox jumps over the lazy dog")); + + res = _getResource(nativeMemory4.getPointer(), nativeMemory4.getSize()); + assertTrue("Incorrect content4 " + res, res.equals("jvmPort2(info2): The quick brown fox jumps over the lazy dog")); + + nativeMemory3.freeMemory(); + nativeMemory4.freeMemory(); + + NativeMemoryBlock nativeMemory5 = Jvm.getResourceAsNativeMemory(jarFile2 + "t", "myres/info.txt"); + assertTrue("NativeMemoryBlock5 was not null", nativeMemory5 == null); + + NativeMemoryBlock nativeMemory6 = Jvm.getResourceAsNativeMemory(jarFile2 + "t", "myres/info2.txt"); + assertTrue("NativeMemoryBlock6 was not null", nativeMemory6 == null); + + + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private void testEnableRuntimeExit() + { + try + { + //************ JvmInternal.enableRuntimeExit *************************** + if (isCldc()) + { + JvmInternal.enableRuntimeExit(); + } + System.exit(40); + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private void testDisableRuntimeExit() + { + if (!isCldc()) + { + return; + } + + try + { + //************ JvmInternal.disableRuntimeExit *************************** + JvmInternal.disableRuntimeExit(); + try + { + System.exit(-123); + assertTrue("System exit should have failed", false); + } + catch (SecurityException se) + { + } + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + JvmInternal.enableRuntimeExit(); + } + + private void testExitVm() + { + try + { + //************ JvmInternal.exitVm *************************** + JvmInternal.exitVm(42); + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private void testYoungGenerationGc() + { + try + { + //************ JvmInternal.runYoungGenerationGc *************************** + Runtime rt = Runtime.getRuntime(); + { + new FinalizeClass(); + new FinalizeClass(); + new FinalizeClass(); + } + long startFree = rt.freeMemory(); + boolean supported = JvmInternal.runYoungGenerationGc(); + long endFree = rt.freeMemory(); + if (supported) + { + assertTrue("endFree (" + endFree + ") <= startFree (" + startFree + ")", startFree < endFree); + } + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private static class FinalizeClass + { + private static boolean mFinalized = false; + + static + { + JvmInternal.enableFinalization(JvmPortTest.FinalizeClass.class); + } + + protected final void finalize() + { + mFinalized = true; + } + } + + private void testFinalization() + { + try + { + //************ JvmInternal.runYoungGenerationGc *************************** + FinalizeClass fClass = new FinalizeClass(); + fClass = null; + System.gc(); + JvmInternal.runFinalization(); + assertTrue("Class was not finalized", FinalizeClass.mFinalized); + + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private class TestListener implements ThreadEventListener + { + private int startCount = 0; + private int diedCount = 0; + private int uncaughtCount = 0; + private Throwable throwable; + private Thread throwngThread; + private Thread newThread; + private Thread parentThread; + private Thread dyingThread; + + public synchronized void threadStarting(Thread newThread, Thread parentThread) + { + startCount++; + this.newThread = newThread; + this.parentThread = parentThread; + } + public synchronized void threadDied(Thread thread) + { + diedCount++; + dyingThread = thread; + } + public synchronized void uncaughtException(Thread thread, Throwable t) + { + throwngThread = thread; + throwable = t; + uncaughtCount++; + } + + } + private void testSetThreadEventListener() + { + try + { + Thread currentThread = Thread.currentThread(); + //************ JvmInternal.setThreadEventListener *************************** + TestListener listener = new TestListener(); + JvmInternal.setThreadEventListener(listener); + Thread th = new Thread(new Runnable() + { + public void run() {} + }); + th.start(); + Thread.sleep(50); + assertTrue("new thread not correct(1)", th == listener.newThread); + assertTrue("parent thread not correct(1)", currentThread == listener.parentThread); + assertTrue("died thread not correct(1)", th == listener.dyingThread); + + th = new Thread(new Runnable() + { + public void run() {} + }); + th.start(); + Thread.sleep(50); + assertTrue("new thread not correct(2)", th == listener.newThread); + assertTrue("parent thread not correct(2)", currentThread == listener.parentThread); + assertTrue("died thread not correct(2)", th == listener.dyingThread); + + th = new Thread(new Runnable() + { + public void run() {} + }); + th.start(); + Thread.sleep(50); + assertTrue("new thread not correct(3)", th == listener.newThread); + assertTrue("parent thread not correct(3)", currentThread == listener.parentThread); + assertTrue("died thread not correct(3)", th == listener.dyingThread); + + final RuntimeException re = new RuntimeException("ex"); + th = new Thread(new Runnable() + { + public void run() + { + throw re; + } + }); + th.start(); + Thread.sleep(150); + assertTrue("new thread not correct(4)", th == listener.newThread); + assertTrue("parent thread not correct(4)", currentThread == listener.parentThread); + assertTrue("died thread not correct(4)", th == listener.dyingThread); + assertTrue("Throwable not correct(4)", re == listener.throwable); + + assertTrue("Start count not correct: " + listener.startCount, listener.startCount == 4); + assertTrue("End count not correct: " + listener.diedCount, listener.diedCount == 4); + assertTrue("Throwable count not correct: " + listener.uncaughtCount, listener.uncaughtCount == 1); + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private void testAddRestrictedPackagePrefixes() + { + if (!isCldc()) + { + return; + } + try + { + //************ JvmInternal.addRestrictedPackagePrefixes *************************** + + javax.microedition.rms.RecordComparator obj0 = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest2.TestClass").newInstance(); + assertTrue("Object was null", obj0 != null); + int res = obj0.compare(null, new byte[1]); + assertTrue("Restricted test failed: " + res, res == 0); + + JvmInternal.addRestrictedPackagePrefixes(new String[] {"com.nokia.mj.impl.rt.support.restricted."}); + + javax.microedition.rms.RecordComparator obj = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest2.TestClass").newInstance(); + assertTrue("Object was null", obj != null); + res = obj.compare(new byte[1], null); + assertTrue("Restricted test failed2: " + res, res == 0); + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private void testAddProtectedPackagePrefixes() + { + if (!isCldc()) + { + return; + } + try + { + //************ JvmInternal.addProtectedPackagePrefixes *************************** + javax.microedition.rms.RecordComparator obj0 = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest.TestClass").newInstance(); + assertTrue("Object was null", obj0 != null); + int res = obj0.compare(null, new byte[1]); + assertTrue("Protected test failed: " + res, res == 0); + + JvmInternal.addProtectedPackagePrefixes(new String[] {"com.nokia.mj.impl.rt.support.prot."}); + + javax.microedition.rms.RecordComparator obj = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest.TestClass").newInstance(); + assertTrue("Object was null", obj != null); + res = obj.compare(new byte[1], null); + assertTrue("Protected test failed2: " + res, res == 0); + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private void testAppendToClassPath() + { + try + { + //************ JvmInternal.appendToClassPath *************************** + javax.microedition.rms.RecordComparator obj = null; + try + { + obj = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest.TestClass").newInstance(); + assertTrue("Shouldn't be found.", false); + } + catch (ClassNotFoundException cnfe) {} + + try + { + obj = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest2.TestClass").newInstance(); + assertTrue("Shouldn't be found2.", false); + } + catch (ClassNotFoundException cnfe) + { + } + + JvmInternal.appendToClassPath(jarFile); + obj = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest.TestClass").newInstance(); + assertTrue("Object was null", obj != null); + int res = obj.compare(null, null); + assertTrue("Incorrect result: " + res, res == 42); + + try + { + obj = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest2.TestClass").newInstance(); + assertTrue("Shouldn't be found3.", false); + } + catch (ClassNotFoundException cnfe) + { + } + + JvmInternal.appendToClassPath(jarFile2); + obj = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest.TestClass").newInstance(); + assertTrue("Object was null 2", obj != null); + res = obj.compare(null, null); + assertTrue("Incorrect result(2): " + res, res == 42); + + obj = (javax.microedition.rms.RecordComparator) + Jvm.loadApplicationClass("com.nokia.mj.impl.test.jvmporttest2.TestClass").newInstance(); + assertTrue("Object was null 3", obj != null); + res = obj.compare(null, null); + assertTrue("Incorrect result(3): " + res, res == 43); + + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + + private void testShrinkJavaHeapToMinimum() + { + try + { + //************ JvmInternal.shrinkJavaHeapToMinimum *************************** + Object[] o = new Object[10000]; + assertTrue("Alocation failed: " + o.length, o.length > 0); + + Runtime rt = Runtime.getRuntime(); + long startTotal = rt.totalMemory(); + o = null; + int shrinkAmount = JvmInternal.shrinkJavaHeapToMinimum(); + long endTotal = rt.totalMemory(); + assertTrue("Heap shrink failed: " + shrinkAmount, shrinkAmount > 0); + assertTrue("Heap shrink failed, total mem was not reduced. endTotal: " + endTotal + ", startTotal: " + startTotal, endTotal < startTotal); + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private void testExpandJavaHeap() + { + try + { + //************ JvmInternal.expandJavaHeap *************************** + Runtime rt = Runtime.getRuntime(); + long startTotal = rt.totalMemory(); + final int expandSize = 1024 * 1024; + int expanded = JvmInternal.expandJavaHeap(expandSize); + assertTrue("Didn't expand as expected: " + expanded, expandSize == expanded); + long endTotal = rt.totalMemory(); + assertTrue("Runtime.totalMemory not what expected. startTotal: " + startTotal + ", endTotal: " + endTotal, (endTotal - startTotal) == expandSize); + } + catch (Throwable t) + { + t.printStackTrace(); + assertTrue(t.toString(), false); + } + } + + private native String _getResource(long ptr, int size); + +} + +