| /******************************************************************************* |
| * Copyright (c) 2000, 2012 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.debug.jdi.tests; |
| |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.ListIterator; |
| import java.util.Vector; |
| |
| import junit.framework.Test; |
| |
| import com.sun.jdi.BooleanValue; |
| import com.sun.jdi.ByteValue; |
| import com.sun.jdi.CharValue; |
| import com.sun.jdi.DoubleValue; |
| import com.sun.jdi.FloatValue; |
| import com.sun.jdi.IntegerValue; |
| import com.sun.jdi.LongValue; |
| import com.sun.jdi.ReferenceType; |
| import com.sun.jdi.ShortValue; |
| import com.sun.jdi.StringReference; |
| import com.sun.jdi.ThreadGroupReference; |
| import com.sun.jdi.ThreadReference; |
| |
| /** |
| * Tests for JDI com.sun.jdi.VirtualMachine |
| * and JDWP VM command set. |
| * |
| * Example of arguments: |
| * -launcher SunVMLauncher -address c:\jdk1.2.2\ -classpath d:\target |
| */ |
| public class VirtualMachineTest extends AbstractJDITest { |
| |
| /** |
| * Creates a new test . |
| */ |
| public VirtualMachineTest() { |
| super(); |
| } |
| /** |
| * Init the fields that are used by this test only. |
| */ |
| @Override |
| public void localSetUp() { |
| } |
| /** |
| * Run all tests and output to standard output. |
| * @param args |
| */ |
| public static void main(java.lang.String[] args) { |
| new VirtualMachineTest().runSuite(args); |
| } |
| /** |
| * Gets the name of the test case. |
| * @see junit.framework.TestCase#getName() |
| */ |
| @Override |
| public String getName() { |
| return "com.sun.jdi.VirtualMachine"; |
| } |
| /** |
| * Don't start the program yet, so that the testNotStarted* tests can run before. |
| */ |
| @Override |
| protected void setUp() { |
| launchTargetAndConnectToVM(); |
| } |
| /** |
| * Starts the target program. |
| * NB: This method is copied in this class only so that it can be invoked |
| * dynamically. |
| */ |
| @Override |
| public void startProgram() { |
| super.startProgram(); |
| } |
| /** |
| * Returns all tests |
| */ |
| @Override |
| protected Test suite() { |
| JDITestSuite suite = new JDITestSuite(this); |
| |
| // Tests that run before the program is started |
| Vector<?> testNames = getAllMatchingTests("testNotStarted"); |
| Iterator<?> iterator = testNames.iterator(); |
| while (iterator.hasNext()) { |
| String name = (String) iterator.next(); |
| suite.addTest(new JDITestCase(this, name)); |
| } |
| |
| // The method that starts the program |
| suite.addTest(new JDITestCase(this, "startProgram")); |
| |
| // Tests that run after the program has started |
| testNames = getAllMatchingTests("testStarted"); |
| iterator = testNames.iterator(); |
| while (iterator.hasNext()) { |
| String name = (String) iterator.next(); |
| suite.addTest(new JDITestCase(this, name)); |
| } |
| |
| // All other tests |
| testNames = getAllMatchingTests("testJDI"); |
| iterator = testNames.iterator(); |
| while (iterator.hasNext()) { |
| String name = (String) iterator.next(); |
| suite.addTest(new JDITestCase(this, name)); |
| } |
| |
| return suite; |
| } |
| /** |
| * Test JDI canGetBytecodes(). |
| */ |
| public void testJDICanGetBytecodes() { |
| fVM.canGetBytecodes(); |
| } |
| /** |
| * Test JDI canGetCurrentContendedMonitor(). |
| */ |
| public void testJDICanGetCurrentContendedMonitor() { |
| fVM.canGetCurrentContendedMonitor(); |
| } |
| /** |
| * Test JDI canGetMonitorInfo(). |
| */ |
| public void testJDICanGetMonitorInfo() { |
| fVM.canGetMonitorInfo(); |
| } |
| /** |
| * Test JDI canGetOwnedMonitorInfo(). |
| */ |
| public void testJDICanGetOwnedMonitorInfo() { |
| fVM.canGetOwnedMonitorInfo(); |
| } |
| /** |
| * Test JDI canGetSyntheticAttribute(). |
| */ |
| public void testJDICanGetSyntheticAttribute() { |
| // This is optional functionality, thus this is not a failure |
| fVM.canGetSyntheticAttribute(); |
| } |
| /** |
| * Test JDI canWatchFieldAccess(). |
| */ |
| public void testJDICanWatchFieldAccess() { |
| // This is optional functionality, thus this is not a failure |
| fVM.canWatchFieldAccess(); |
| } |
| /** |
| * Test JDI canWatchFieldModification(). |
| */ |
| public void testJDICanWatchFieldModification() { |
| // This is optional functionality, thus this is not a failure |
| fVM.canWatchFieldModification(); |
| } |
| /** |
| * Test JDI eventQueue(). |
| */ |
| public void testJDIEventQueue() { |
| assertNotNull("1", fVM.eventQueue()); |
| } |
| /** |
| * Test JDI eventRequestManager(). |
| */ |
| public void testJDIEventRequestManager() { |
| assertNotNull("1", fVM.eventRequestManager()); |
| } |
| /** |
| * Test JDI mirrorOf(boolean). |
| */ |
| public void testJDIMirrorOfBoolean() { |
| boolean value = true; |
| BooleanValue mirror = fVM.mirrorOf(value); |
| assertTrue("1", value == mirror.value()); |
| } |
| /** |
| * Test JDI mirrorOf(byte). |
| */ |
| public void testJDIMirrorOfByte() { |
| byte value = 1; |
| ByteValue mirror = fVM.mirrorOf(value); |
| assertEquals("1", value, mirror.value()); |
| } |
| /** |
| * Test JDI mirrorOf(char). |
| */ |
| public void testJDIMirrorOfChar() { |
| char value = 'a'; |
| CharValue mirror = fVM.mirrorOf(value); |
| assertEquals("1", value, mirror.value()); |
| } |
| /** |
| * Test JDI mirrorOf(double). |
| */ |
| public void testJDIMirrorOfDouble() { |
| double value = 12345.6789; |
| DoubleValue mirror = fVM.mirrorOf(value); |
| assertEquals("1", value, mirror.value(), 0); |
| } |
| /** |
| * Test JDI mirrorOf(float). |
| */ |
| public void testJDIMirrorOfFloat() { |
| float value = 12345.6789f; |
| FloatValue mirror = fVM.mirrorOf(value); |
| assertEquals("1", value, mirror.value(), 0); |
| } |
| /** |
| * Test JDI mirrorOf(int). |
| */ |
| public void testJDIMirrorOfInt() { |
| int value = 12345; |
| IntegerValue mirror = fVM.mirrorOf(value); |
| assertEquals("1", value, mirror.value()); |
| } |
| /** |
| * Test JDI mirrorOf(long). |
| */ |
| public void testJDIMirrorOfLong() { |
| long value = 1234567890l; |
| LongValue mirror = fVM.mirrorOf(value); |
| assertEquals("1", value, mirror.value()); |
| } |
| /** |
| * Test JDI mirrorOf(short). |
| */ |
| public void testJDIMirrorOfShort() { |
| short value = (short) 12345; |
| ShortValue mirror = fVM.mirrorOf(value); |
| assertEquals("1", value, mirror.value()); |
| } |
| /** |
| * Test JDI mirrorOf(String) and JDWP 'VM - Create String'. |
| */ |
| public void testJDIMirrorOfString() { |
| String testString = "Test"; |
| StringReference newString = null; |
| newString = fVM.mirrorOf(testString); |
| assertEquals("1", newString.value(), testString); |
| } |
| /** |
| * Test JDI setDebugTraceMode(int). |
| */ |
| public void testJDISetDebugTraceMode() { |
| fVM.setDebugTraceMode(com.sun.jdi.VirtualMachine.TRACE_ALL); |
| fVM.setDebugTraceMode(com.sun.jdi.VirtualMachine.TRACE_SENDS); |
| fVM.setDebugTraceMode(com.sun.jdi.VirtualMachine.TRACE_RECEIVES); |
| fVM.setDebugTraceMode(com.sun.jdi.VirtualMachine.TRACE_NONE); |
| |
| // restore original value |
| fVM.setDebugTraceMode(fVMTraceFlags); |
| } |
| /** |
| * Test JDI getVersion(). |
| */ |
| public void testJDIVersion() { |
| String version = fVM.version(); |
| assertTrue("1", version != null); |
| } |
| /** |
| * Test JDI allClasses() and JDWP 'VM - Get all classes' |
| * while the test program has not been started. |
| */ |
| public void testNotStartedAllClasses() { |
| List<?> classes = fVM.allClasses(); |
| Iterator<?> iterator = classes.listIterator(); |
| int i = 0; |
| while (iterator.hasNext()) |
| assertTrue(Integer.toString(i++), iterator.next() instanceof ReferenceType); |
| } |
| /** |
| * Test JDI allThreads() and JDWP 'VM - Get all threads' |
| * while the test program has not been started. |
| */ |
| public void testNotStartedAllThreads() { |
| List<?> threads = fVM.allThreads(); |
| Iterator<?> iterator = threads.listIterator(); |
| int i = 0; |
| while (iterator.hasNext()) |
| assertTrue(Integer.toString(i++), iterator.next() instanceof ThreadReference); |
| } |
| /** |
| * Test JDI classesByName() while the test program has not been started. |
| */ |
| public void testNotStartedClassesByName() { |
| List<?> classes = fVM.classesByName("java.lang.Object"); |
| assertEquals("1", 1, classes.size()); |
| } |
| /** |
| * Test JDI allClasses() and JDWP 'VM- Get all classes' |
| * once the test program has been started. |
| */ |
| public void testStartedAllClasses() { |
| |
| // The test program has started, the number of classes is != 0 |
| List<?> classes = fVM.allClasses(); |
| assertTrue("1", classes.size() != 0); |
| |
| // Collect names of received classes |
| String[] names = new String[classes.size()]; |
| ListIterator<?> iterator = classes.listIterator(); |
| int i = 0; |
| while (iterator.hasNext()) { |
| ReferenceType type = (ReferenceType) iterator.next(); |
| names[i++] = type.name(); |
| } |
| |
| // Check that they are the expected names |
| String[] expected = |
| new String[] { |
| "java.lang.Object", |
| "java.util.Date", |
| "org.eclipse.debug.jdi.tests.program.Printable", |
| "org.eclipse.debug.jdi.tests.program.MainClass" }; |
| for (int j = 0; j < expected.length; j++) { |
| boolean isIncluded = false; |
| iteration : for (int k = 0; k < names.length; k++) { |
| if (names[k].equals(expected[j])) { |
| isIncluded = true; |
| break iteration; |
| } |
| } |
| assertTrue("2." + j, isIncluded); |
| } |
| } |
| /** |
| * Test JDI allThreads() and JDWP 'VM - Get all threads' |
| * once the test program has been started. |
| */ |
| public void testStartedAllThreads() { |
| |
| // The test program has started, the number of threads is != 0 |
| List<?> threads = fVM.allThreads(); |
| assertTrue("1", threads.size() != 0); |
| |
| // Collect names of received threads |
| String[] names = new String[threads.size()]; |
| ListIterator<?> iterator = threads.listIterator(); |
| int i = 0; |
| while (iterator.hasNext()) { |
| ThreadReference thread = (ThreadReference) iterator.next(); |
| names[i++] = thread.name(); |
| } |
| |
| // Check that they contain at least the expected names |
| String[] expected = new String[] { "Test Thread" }; |
| boolean isIncluded = false; |
| iteration : for (int j = 0; j < expected.length; j++) { |
| for (int k = 0; k < names.length; k++) { |
| if (expected[j].equals(names[k])) { |
| isIncluded = true; |
| break iteration; |
| } |
| } |
| } |
| assertTrue("2", isIncluded); |
| } |
| /** |
| * Test JDI classesByName() once the test program has been started. |
| */ |
| public void testStartedClassesByName() { |
| |
| // The test program has started, the number of java.lang.Object is 1 |
| List<?> classes = fVM.classesByName("java.lang.Object"); |
| assertEquals("1", classes.size(), 1); |
| |
| // Collect names of received classes |
| String[] names = new String[classes.size()]; |
| ListIterator<?> iterator = classes.listIterator(); |
| int i = 0; |
| while (iterator.hasNext()) { |
| ReferenceType type = (ReferenceType) iterator.next(); |
| names[i++] = type.name(); |
| } |
| |
| // Check that they are all "java.lang.Object" |
| for (int j = 0; j < names.length; j++) { |
| assertEquals("2." + j, "java.lang.Object", names[j]); |
| } |
| } |
| /** |
| * Test JDI suspend() and resume() once the test program has been started. |
| */ |
| public void testStartedSuspendResume() { |
| // Suspend |
| fVM.suspend(); |
| ListIterator<?> threads = fVM.allThreads().listIterator(); |
| while (threads.hasNext()) { |
| ThreadReference thread = (ThreadReference) threads.next(); |
| assertTrue("1." + thread.name(), thread.isSuspended()); |
| } |
| |
| // Resume |
| fVM.resume(); |
| // Cannot assertTrue that all threads are not suspended because they might have been suspended |
| // by the program itself |
| |
| // Suspend VM and suspend one thread |
| fVM.suspend(); |
| threads = fVM.allThreads().listIterator(); |
| ThreadReference suspended = getThread(); |
| suspended.suspend(); |
| while (threads.hasNext()) { |
| ThreadReference thread = (ThreadReference) threads.next(); |
| assertTrue("2." + thread.name(), thread.isSuspended()); |
| } |
| |
| // Resume VM and ensure that the one thread that was suspended is still suspended |
| fVM.resume(); |
| assertTrue("3", suspended.isSuspended()); |
| } |
| /** |
| * Test JDI topLevelThreadGroups(). |
| */ |
| public void testStartedTopLevelThreadGroups() { |
| List<?> topLevelThreadGroups = fVM.topLevelThreadGroups(); |
| assertEquals("1", 1, topLevelThreadGroups.size()); |
| assertTrue("2", topLevelThreadGroups.get(0) instanceof ThreadGroupReference); |
| } |
| } |