| /******************************************************************************* |
| * Copyright (c) 2000, 2015 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.ArrayList; |
| import java.util.List; |
| |
| import com.sun.jdi.ObjectReference; |
| import com.sun.jdi.ReferenceType; |
| |
| /** |
| * Test cases for the implementation of heap walking in the new java 1.6 VM |
| * |
| * @since 3.3 |
| */ |
| public class HeapWalkingTests extends AbstractJDITest { |
| |
| private ReferenceType fClass, fClass1; |
| private ObjectReference fObject; |
| |
| /** setup our tests */ |
| @Override |
| public void localSetUp() {} |
| |
| /** tear down our tests */ |
| @Override |
| public void localTearDown() { |
| super.localTearDown(); |
| fClass = null; |
| fClass1 = null; |
| fObject = null; |
| } |
| |
| /** |
| * test to make sure that the VM supports getting instance info for heap walking if it is a 1.6 VM |
| */ |
| public void testCanGetInstanceInfo() { |
| if(is16OrGreater()) { |
| assertTrue("Should have instance info", fVM.canGetInstanceInfo()); |
| } |
| else { |
| assertTrue("Should not have instance info", !fVM.canGetInstanceInfo()); |
| } |
| } |
| |
| /** |
| * tests the new method instanceCounts, to make sure it throws an NPE when required. |
| * test is not applicable to non 1.6 VMs |
| */ |
| public void testGetInstanceCountsNullAttrib() { |
| if(!fVM.canGetInstanceInfo()) { |
| return; |
| } |
| try { |
| fVM.instanceCounts(null); |
| assertTrue("No excpetion thrown", false); |
| } |
| catch (NullPointerException npe) {} |
| } |
| |
| /** |
| * tests to make sure the instanceCounts method throws a not supported |
| */ |
| public void testGetInstanceCountsUnsupported() { |
| if(is16OrGreater()) { |
| try { |
| fVM.instanceCounts(new ArrayList<ReferenceType>()); |
| } |
| catch(UnsupportedOperationException uoe) { |
| assertTrue("Threw unsupported exception in 1.6 VM", false); |
| } |
| } |
| else { |
| try { |
| fVM.instanceCounts(new ArrayList<ReferenceType>()); |
| assertTrue("No exception for non 1.6 VM", false); |
| } |
| catch(UnsupportedOperationException uoe) {} |
| } |
| } |
| |
| /** |
| * test to collect any referring instances can be collected for the specified class. |
| * test is not applicable to non 1.6 VMs. |
| */ |
| public void testGetInstanceCounts() { |
| if(!fVM.canGetInstanceInfo()) { |
| return; |
| } |
| triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclass3load", true); |
| triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclassload", true); |
| ArrayList<ReferenceType> list = new ArrayList<>(2); |
| fClass = getClass("org.eclipse.debug.jdi.tests.program.RefClass1"); |
| assertNotNull("RefClass should not be null", fClass); |
| list.add(fClass); |
| fClass1 = getClass("org.eclipse.debug.jdi.tests.program.RefClass2"); |
| list.add(fClass1); |
| long[] counts = fVM.instanceCounts(list); |
| assertNotNull("counts should not be null", counts); |
| assertTrue("counts should have two entires", counts.length == 2); |
| assertTrue("count for RefClass1 should be 2", counts[0] == 2); |
| assertTrue("count for RefClass2 should be 1", counts[1] == 1); |
| } |
| |
| /** |
| * test to make sure instances throws an unsupported exception for non 1.6 VMs |
| */ |
| public void testGetInstancesUnsupported() { |
| fClass = getClass("java.io.PrintStream"); |
| assertNotNull("classs should not be null", fClass); |
| if(is16OrGreater()) { |
| try { |
| fClass.instances(20); |
| } |
| catch(UnsupportedOperationException uoe) { |
| assertTrue("Threw unsupported exception in 1.6 VM", false); |
| } |
| } |
| else { |
| try { |
| fClass.instances(20); |
| assertTrue("No exception for non 1.6 VM", false); |
| } |
| catch(UnsupportedOperationException uoe) {} |
| } |
| } |
| |
| /** |
| * test to make sure instances throws and IllegalArgument exception for negative long arguments. |
| * test is not applicable to non 1.6 VMs |
| */ |
| public void testGetInstancesNegativeMax() { |
| if(!fVM.canGetInstanceInfo()) { |
| return; |
| } |
| fClass = getClass("java.io.PrintStream"); |
| assertNotNull("classs should not be null", fClass); |
| try { |
| fClass.instances(-1); |
| assertTrue("No excpetion thrown", false); |
| } |
| catch (IllegalArgumentException iae) {} |
| } |
| |
| /** |
| * test to collect a list of instances. |
| * test is not applicable to non 1.6 VMs. |
| */ |
| public void testGetInstances() { |
| if(!fVM.canGetInstanceInfo()) { |
| return; |
| } |
| triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclass3load", true); |
| triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclassload", true); |
| fClass = getClass("org.eclipse.debug.jdi.tests.program.RefClass3"); |
| assertNotNull("RefClass3 should not be null", fClass); |
| fClass1 = getClass("org.eclipse.debug.jdi.tests.program.RefClass1"); |
| assertNotNull("RefClass1 should not be null", fClass1); |
| List<?> list = fClass1.instances(10); |
| assertNotNull("list should not be null", list); |
| assertTrue("list should have two enrtries", list.size() == 2); |
| } |
| |
| /** |
| * test to make sure referringObjects throws an unsupported exception for non-1.6 VMs |
| */ |
| public void testGetReferringObjectsUnsupported() { |
| fClass = getMainClass(); |
| assertNotNull("main class ref should not be null", fClass); |
| fObject = getObjectReference(); |
| assertNotNull("String obj ref should not be null", fObject); |
| if(is16OrGreater()) { |
| try { |
| fObject.referringObjects(100); |
| } |
| catch(UnsupportedOperationException uoe) { |
| assertTrue("Threw unsupported exception in 1.6 VM", false); |
| } |
| } |
| else { |
| try { |
| fObject.referringObjects(10); |
| assertTrue("No exception for non 1.6 VM", false); |
| } |
| catch(UnsupportedOperationException uoe) {} |
| } |
| } |
| |
| /** |
| * test to make sure referringObjects throws an IllegalArgument exception for bad values of max |
| */ |
| public void testGetreferringObjectsNegativeMax() { |
| if(!fVM.canGetInstanceInfo()) { |
| return; |
| } |
| fClass = getMainClass(); |
| assertNotNull("main class ref should not be null", fClass); |
| fObject = getStringReference(); |
| assertNotNull("String obj ref should not be null", fObject); |
| try { |
| fObject.referringObjects(-1); |
| assertTrue("No excpetion thrown", false); |
| } |
| catch (IllegalArgumentException iae) { |
| assertTrue("Threw exception", true); |
| } |
| } |
| |
| /** |
| * tests the method referring objects to ensure working to spec. |
| * test is not applicable to non 1.6 VMs |
| */ |
| public void testGetReferringObjects() { |
| if(!fVM.canGetInstanceInfo()) { |
| return; |
| } |
| fClass = getMainClass(); |
| assertNotNull("main class ref should not be null", fClass); |
| triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclassload", true); |
| fClass1 = getClass("org.eclipse.debug.jdi.tests.program.RefClass"); |
| assertNotNull("RefClass should not be null", fClass1); |
| fObject = getObjectReference(); |
| assertNotNull("String obj ref should not be null", fObject); |
| List<?> list = fObject.referringObjects(100); |
| assertNotNull("referring objects list should not be null", list); |
| assertTrue("list size should be 4", list.size() == 4); |
| assertTrue("list should contain the main class", list.contains(fClass.classObject())); |
| assertTrue("list should contain the main class thread", list.contains(getThread())); |
| } |
| } |