/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.debug.jdi.tests;

import com.sun.jdi.ArrayType;
import com.sun.jdi.ReferenceType;

/**
 * Test cases for the implementation of providing argument information even if
 * no debugging information is present in the new java 1.6 VM
 *
 * @since 3.3
 */
public class ConstantPoolTests extends AbstractJDITest {

	ReferenceType fClass;

	/** setup test info locally **/
	@Override
	public void localSetUp() {}

	/**
	 * test to see if we can get class file version info from a 1.6 VM, and
	 * that we cannot from a pre-1.6 VM
	 */
	public void testCanGetClassFileVersion() {
		if(is16OrGreater()) {
			assertTrue("Should have classfile version info", fVM.canGetClassFileVersion());
		}
		else {
			assertTrue("Should not have classfile version info", !fVM.canGetClassFileVersion());
		}
	}

	/**
	 * test to make sure we can get constant pool information from a 1.6 VM, and
	 * that we cannot get it from a pre-1.6 VM
	 */
	public void testCanGetConstantPool() {
		if(is16OrGreater()) {
			assertTrue("Should have constant pool info", fVM.canGetConstantPool());
		}
		else {
			assertFalse("Should not have constant pool info", fVM.canGetConstantPool());
		}
	}

	/**
	 * test to make sure that if majorVersion is unsupported an UnsupportedOperationException is
	 * thrown.
	 */
	public void testMajorVersionUnsupported() {
		triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclassload", true);
		fClass = getClass("org.eclipse.debug.jdi.tests.program.RefClass1");
		assertNotNull("RefClass1 should not be null", fClass);
		if(is16OrGreater()) {
			try {
				fClass.majorVersion();
			}
			catch(UnsupportedOperationException uoe) {
				assertTrue("Threw unsupported exception in 1.6 VM", false);
			}
		}
		else {
			try {
				fClass.majorVersion();
				assertTrue("No exception for non 1.6 VM", false);
			}
			catch(UnsupportedOperationException uoe) {}
		}
	}

	/**
	 * test to make sure that majorVersion returns 0 for an arrayType.
	 * this test does not apply to non-16 VMs
	 */
	public void testMajorVersionArrayType() {
		if(!fVM.canGetClassFileVersion()) {
			return;
		}
		ArrayType type = getArrayType();
		assertNotNull("type should not be null", type);
		int ver = type.majorVersion();
		assertTrue("major verison should be 0", ver == 0);
	}

	/**
	 * test to make sure majorVerison works.
	 * this test does not apply to non-1.6VMs
	 */
	public void testMajorVersion() {
		if(!fVM.canGetClassFileVersion()) {
			return;
		}
		triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclassload", true);
		fClass = getClass("org.eclipse.debug.jdi.tests.program.RefClass1");
		assertNotNull("RefClass1 should not be null", fClass);
		int ver = fClass.majorVersion();
		assertTrue("version cannot be equal to -1", ver != -1);
	}

	/**
	 * test to make sure that if minorVersion is unsupported an UnsupportedIOperationException
	 * is thrown
	 */
	public void testMinorVersionUnsupported() {
		triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclassload", true);
		fClass = getClass("org.eclipse.debug.jdi.tests.program.RefClass1");
		assertNotNull("RefClass1 should not be null", fClass);
		if(is16OrGreater()) {
			try {
				fClass.minorVersion();
			}
			catch(UnsupportedOperationException uoe) {
				assertTrue("Threw unsupported exception in 1.6 VM", false);
			}
		}
		else {
			try {
				fClass.minorVersion();
				assertTrue("No exception for non 1.6 VM", false);
			}
			catch(UnsupportedOperationException uoe) {}
		}
	}

	/**
	 * test to make sure minorVerison works.
	 * this test does not apply to non-1.6VMs
	 */
	public void testMinorVersion() {
		if(!fVM.canGetClassFileVersion()) {
			return;
		}
		triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclassload", true);
		fClass = getClass("org.eclipse.debug.jdi.tests.program.RefClass1");
		assertNotNull("RefClass1 should not be null", fClass);
		int ver = fClass.minorVersion();
		assertTrue("version cannot be equal to -1", ver != -1);
	}

	/**
	 * test to make sure that if constantPoolCount is unsupported an UnsupportedIOperationException
	 * is thrown
	 */
	public void testConstantPoolCountSupported() {
		triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclassload", true);
		fClass = getClass("org.eclipse.debug.jdi.tests.program.RefClass1");
		assertNotNull("RefClass1 should not be null", fClass);
		if(is16OrGreater()) {
			try {
				fClass.constantPoolCount();
			}
			catch(UnsupportedOperationException uoe) {
				assertTrue("Threw unsupported exception in 1.6 VM", false);
			}
		}
		else {
			try {
				fClass.constantPoolCount();
				assertTrue("No exception for non 1.6 VM", false);
			}
			catch(UnsupportedOperationException uoe) {}
		}
	}

	/**
	 * test to ensure the constant pool count is working correctly
	 * this test does not apply to non-1.6 VMs
	 */
	public void testConstantPoolCount() {
		if(!fVM.canGetConstantPool()) {
			return;
		}
		triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclass4load", true);
		fClass = getClass("org.eclipse.debug.jdi.tests.program.RefClass4");
		assertNotNull("RefClass4 should not be null", fClass);
		fClass.constantPoolCount();
		//for now we don't care about constant pool counts, not likely to have a useful debug extension for this feature,
		//but it is here for completeness
	}

	/**
	 * test to make sure that if constantPool is unsupported an UnsupportedIOperationException
	 * is thrown
	 */
	public void testConstantPoolSupported() {
		triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclassload", true);
		fClass = getClass("org.eclipse.debug.jdi.tests.program.RefClass1");
		assertNotNull("RefClass1 should not be null", fClass);
		if(is16OrGreater()) {
			try {
				fClass.constantPool();
			}
			catch(UnsupportedOperationException uoe) {
				assertTrue("Threw unsupported exception in 1.6 VM", false);
			}
		}
		else {
			try {
				fClass.constantPool();
				assertTrue("No exception for non 1.6 VM", false);
			}
			catch(UnsupportedOperationException uoe) {}
		}
	}

	/**
	 * test to ensure the constant pool is working correctly
	 * this test does not apply to non-1.6 VMs
	 */
	public void testConstantPool() {
		if(!fVM.canGetConstantPool()) {
			return;
		}
		triggerAndWait(fVM.eventRequestManager().createClassPrepareRequest(), "refclass4load", true);
		fClass = getClass("org.eclipse.debug.jdi.tests.program.RefClass4");
		assertNotNull("RefClass4 should not be null", fClass);
		byte[] bytes = fClass.constantPool();
		assertNotNull("byte array should not be null", bytes);
		assertTrue("byte array should not be less than 1", bytes.length > 0);
		//for now we don't care about constant pool bytes, not likely to have a useful debug extension for this feature,
		//but it is here for completeness
	}
}