/*******************************************************************************
 * Copyright (c) 2000, 2011 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.Type;

/**
 * Tests for JDI com.sun.jdi.Type.
 */
public class TypeTest extends AbstractJDITest {
	private Type
		fArrayType,
		fClassType,
		fInterfaceType,
		// primitive types
		fShortType,
		fByteType,
		fIntegerType,
		fLongType,
		fFloatType,
		fDoubleType,
		fCharType,
		fBooleanType,
		// One-dimensional primitive arrays
		fByteArrayType,
		fShortArrayType,
		fIntArrayType,
		fLongArrayType,
		fFloatArrayType,
		fDoubleArrayType,
		fCharArrayType,
		fBooleanArrayType,
		// Two-dimensional primitive arrays
		fByteDoubleArrayType,
		fShortDoubleArrayType,
		fIntDoubleArrayType,
		fLongDoubleArrayType,
		fFloatDoubleArrayType,
		fDoubleDoubleArrayType,
		fCharDoubleArrayType,
		fBooleanDoubleArrayType;

	/**
	 * Creates a new test.
	 */
	public TypeTest() {
		super();
	}
	/**
	 * Init the fields that are used by this test only.
	 */
	@Override
	public void localSetUp() {
		// Get reference types
		fArrayType = getArrayType();
		fClassType = getMainClass();
		fInterfaceType = getInterfaceType();
		// Get primitive types
		fBooleanType = (fVM.mirrorOf(true).type());
		fByteType = (fVM.mirrorOf((byte) 1).type());
		fCharType = (fVM.mirrorOf('a').type());
		fDoubleType = (fVM.mirrorOf(12345.6789).type());
		fFloatType = (fVM.mirrorOf(12345.6789f).type());
		fIntegerType = (fVM.mirrorOf(12345).type());
		fLongType = (fVM.mirrorOf(123456789l).type());
		fShortType = (fVM.mirrorOf((short) 12345).type());
		// Get one-dimensional primitive arrays
		fByteArrayType = getByteArrayType();
		fShortArrayType = getShortArrayType();
		fIntArrayType = getIntArrayType();
		fLongArrayType = getLongArrayType();
		fFloatArrayType = getFloatArrayType();
		fDoubleArrayType = getDoubleArrayType();
		fCharArrayType = getCharArrayType();
		fBooleanArrayType = getBooleanArrayType();
		//  Get two-dimensional primitive arrays
		fByteDoubleArrayType = getByteDoubleArrayType();
		fShortDoubleArrayType = getShortDoubleArrayType();
		fIntDoubleArrayType = getIntDoubleArrayType();
		fLongDoubleArrayType = getLongDoubleArrayType();
		fFloatDoubleArrayType = getFloatDoubleArrayType();
		fDoubleDoubleArrayType = getDoubleDoubleArrayType();
		fCharDoubleArrayType = getCharDoubleArrayType();
		fBooleanDoubleArrayType = getBooleanDoubleArrayType();

	}
	/**
	 * Run all tests and output to standard output.
	 * @param args
	 */
	public static void main(java.lang.String[] args) {
		new TypeTest().runSuite(args);
	}
	/**
	 * Gets the name of the test case.
	 * @see junit.framework.TestCase#getName()
	 */
	@Override
	public String getName() {
		return "com.sun.jdi.Type";
	}
	/**
	 * Test JDI signature().
	 */
	public void testJDISignature() {
		assertEquals("1", "[Ljava/lang/String;", fArrayType.signature());
		assertEquals("2", "Lorg/eclipse/debug/jdi/tests/program/MainClass;", fClassType.signature());
		assertEquals("3", "Lorg/eclipse/debug/jdi/tests/program/Printable;", fInterfaceType.signature());
		// Primitive types
		assertEquals("4", "S", fShortType.signature());
		assertEquals("5", "B", fByteType.signature());
		assertEquals("6", "I", fIntegerType.signature());
		assertEquals("7", "J", fLongType.signature());
		assertEquals("8", "F", fFloatType.signature());
		assertEquals("9", "D", fDoubleType.signature());
		assertEquals("10", "C", fCharType.signature());
		assertEquals("11", "Z", fBooleanType.signature());
		// One-dimensional primitive arrays
		assertEquals("12", "[B", fByteArrayType.signature());
		assertEquals("13", "[S", fShortArrayType.signature());
		assertEquals("14", "[I", fIntArrayType.signature());
		assertEquals("15", "[J", fLongArrayType.signature());
		assertEquals("16", "[F", fFloatArrayType.signature());
		assertEquals("17", "[D", fDoubleArrayType.signature());
		assertEquals("18", "[C", fCharArrayType.signature());
		assertEquals("19", "[Z", fBooleanArrayType.signature());
		// Two-dimensional primitive arrays
		assertEquals("20", "[[B", fByteDoubleArrayType.signature());
		assertEquals("21", "[[S", fShortDoubleArrayType.signature());
		assertEquals("22", "[[I", fIntDoubleArrayType.signature());
		assertEquals("23", "[[J", fLongDoubleArrayType.signature());
		assertEquals("24", "[[F", fFloatDoubleArrayType.signature());
		assertEquals("25", "[[D", fDoubleDoubleArrayType.signature());
		assertEquals("26", "[[C", fCharDoubleArrayType.signature());
		assertEquals("27", "[[Z", fBooleanDoubleArrayType.signature());
	}
	/**
	 * Test JDI typeName().
	 */
	public void testJDITypeName() {
		assertEquals("1", "java.lang.String[]", fArrayType.name());
		assertEquals("2", "org.eclipse.debug.jdi.tests.program.MainClass", fClassType.name());
		assertEquals("3", "org.eclipse.debug.jdi.tests.program.Printable", fInterfaceType.name());
		// Primitive types
		assertEquals("4", "byte", fByteType.name());
		assertEquals("5", "short", fShortType.name());
		assertEquals("6", "int", fIntegerType.name());
		assertEquals("7", "long", fLongType.name());
		assertEquals("8", "float", fFloatType.name());
		assertEquals("9", "double", fDoubleType.name());
		assertEquals("10", "char", fCharType.name());
		assertEquals("11", "boolean", fBooleanType.name());
		// One-dimensional primitive arrays
		assertEquals("12", "byte[]", fByteArrayType.name());
		assertEquals("13", "short[]", fShortArrayType.name());
		assertEquals("14", "int[]", fIntArrayType.name());
		assertEquals("15", "long[]", fLongArrayType.name());
		assertEquals("16", "float[]", fFloatArrayType.name());
		assertEquals("17", "double[]", fDoubleArrayType.name());
		assertEquals("18", "char[]", fCharArrayType.name());
		assertEquals("19", "boolean[]", fBooleanArrayType.name());
		// Two-dimensional primitive arrays
		assertEquals("20", "byte[][]", fByteDoubleArrayType.name());
		assertEquals("21", "short[][]", fShortDoubleArrayType.name());
		assertEquals("22", "int[][]", fIntDoubleArrayType.name());
		assertEquals("23", "long[][]", fLongDoubleArrayType.name());
		assertEquals("24", "float[][]", fFloatDoubleArrayType.name());
		assertEquals("25", "double[][]", fDoubleDoubleArrayType.name());
		assertEquals("26", "char[][]", fCharDoubleArrayType.name());
		assertEquals("27", "boolean[][]", fBooleanDoubleArrayType.name());
	}
}