org.eclipse.jdt.debug.jdi.tests/tests/org/eclipse/debug/jdi/tests/HeapWalkingTests.java

/*******************************************************************************
 * 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()));
	}
}