/*******************************************************************************
 * Copyright (c) 2000, 2011 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.jdt.debug.tests.core;

import org.eclipse.debug.core.model.ILineBreakpoint;
import org.eclipse.debug.core.model.IVariable;
import org.eclipse.jdt.debug.core.IJavaArray;
import org.eclipse.jdt.debug.core.IJavaArrayType;
import org.eclipse.jdt.debug.core.IJavaDebugTarget;
import org.eclipse.jdt.debug.core.IJavaPrimitiveValue;
import org.eclipse.jdt.debug.core.IJavaStackFrame;
import org.eclipse.jdt.debug.core.IJavaThread;
import org.eclipse.jdt.debug.core.IJavaValue;
import org.eclipse.jdt.debug.core.IJavaVariable;
import org.eclipse.jdt.debug.tests.AbstractDebugTest;

/**
 * Tests indexed collection API
 */
public class ArrayTests extends AbstractDebugTest {

	public ArrayTests(String name) {
		super(name);
	}

	public void testGetSize() throws Exception {
		String typeName = "ArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(19, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable variable = findVariable(frame, "array");
			assertNotNull(variable);
			IJavaArray array = (IJavaArray) variable.getValue();
			assertEquals("Array has wrong size", 100, array.getSize());
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}				
	}
	
	
	public void testGetVariable() throws Exception {
		String typeName = "ArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(19, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "array");
			assertNotNull(v);
			IJavaArray array = (IJavaArray) v.getValue();
			assertNotNull(array);
			IVariable variable = array.getVariable(99);
			assertNotNull(variable);
			assertEquals("Wrong value", ((IJavaDebugTarget)frame.getDebugTarget()).newValue(99), variable.getValue());
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}				
	}	
	
	public void testGetVariableRange() throws Exception {
		String typeName = "ArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(19, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "array");
			assertNotNull(v);
			IJavaArray array = (IJavaArray) v.getValue();
			assertNotNull(array);
			IVariable[] variables = array.getVariables(50, 15);
			assertNotNull(variables);
			for (int i = 0; i < 15; i++) {
				assertEquals("Wrong value", ((IJavaDebugTarget)frame.getDebugTarget()).newValue(50 + i), variables[i].getValue());
			}
			
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}				
	}	
	
	public void testSetValueRange() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(27, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArray array = (IJavaArray) v.getValue();
			assertNotNull(array);
			IJavaValue[] replacements = new IJavaValue[5000];
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			for (int i = 0; i < replacements.length; i++) {
				replacements[i] = target.newValue((byte)-1);
			}
			array.setValues(2500, 5000, replacements, 0);
			// verify new values
			IJavaValue[] values = array.getValues();
			for (int i = 0; i < values.length; i++) {
				byte byteValue = ((IJavaPrimitiveValue)values[i]).getByteValue();
				if (i < 2500) {
					assertFalse((byte)-1 == byteValue);
				} else if (i >= 7500) {
					assertFalse((byte)-1 == byteValue);
				} else {
					assertEquals((byte)-1, byteValue);
				}
			}
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	public void testCreateArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			// array should contain null value
			assertEquals(target.nullValue(), value);
			assertTrue(value.isNull());
			// assign a new array
			IJavaArray javaArray = type.newInstance(6000);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			
			IJavaValue[] replacements = new IJavaValue[6000];
			for (int i = 0; i < replacements.length; i++) {
				replacements[i] = target.newValue((byte)23);
			}
			array.setValues(replacements);
			// verify new values
			IJavaValue[] values = array.getValues();
			assertEquals(6000, array.getLength());
			for (int i = 0; i < values.length; i++) {
				byte byteValue = ((IJavaPrimitiveValue)values[i]).getByteValue();
				assertEquals((byte)23, byteValue);
			}
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}	
	
	/**
	 * Sets a zero-length array as the new values
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetZeroLengthArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			IJavaArray javaArray = type.newInstance(1);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			
			IJavaValue[] replacements = new IJavaValue[0];
			array.setValues(replacements);
			// the overall size of the array will never change size, and trying to set no values has not effect
			assertEquals(1, array.getLength());
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}	
	
	/**
	 * Tries to set a new array with a starting index of -1
	 * 
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetBadLowerIndexArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			IJavaArray javaArray = type.newInstance(1);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			
			IJavaValue[] replacements = {target.nullValue()};
			try {
				array.setValues(-1, 0, replacements, 0);
			}
			catch(IndexOutOfBoundsException ioobe) {
				//got the expected exception
				return;
			}
			fail("Should have gotten an IndexOutOfBoundsException trying to use a offset of -1");
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tries to set an array with an index greater than the total length of the source array
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetBadUpperIndexArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			IJavaArray javaArray = type.newInstance(1);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaValue bite = target.newValue((byte)-1);
			IJavaValue[] replacements = {bite};
			try {
				array.setValues(3, 0, replacements, 0);
			}
			catch(IndexOutOfBoundsException ioobe) {
				//got the expected exception
				return;
			}
			fail("Should have gotten an IndexOutOfBoundsException trying to use an offset of 3");
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tries to set an array with an index greater than the total length of the soure array
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetExactUpperIndexArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			// assign a new array
			IJavaArray javaArray = type.newInstance(3);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaValue bite = target.newValue((byte)-1);
			IJavaValue[] replacements = {bite, bite, bite};
			try {
				array.setValues(3, 0, replacements, 0);
			}
			catch(IndexOutOfBoundsException ioobe) {
				//got the expected exception
				return;
			}
			fail("Should have gotten an IndexOutOfBoundsException trying to use an offset of 3");
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tries to set an array with a source index greater than the total length of the new values array
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetBadLowerSrcIndexArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			// assign a new array
			IJavaArray javaArray = type.newInstance(3);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaValue bite = target.newValue((byte)-1);
			IJavaValue[] replacements = {bite, bite, bite};
			try {
				array.setValues(0, 1, replacements, -2);
			}
			catch(IndexOutOfBoundsException ioobe) {
				//got the expected exception
				return;
			}
			fail("Should have gotten an IndexOutOfBoundsException trying to use a source offset of -2");
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tries to set an array with a source index greater than the total length of the new values array
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetBadUpperSrcIndexArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			// assign a new array
			IJavaArray javaArray = type.newInstance(3);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaValue bite = target.newValue((byte)-1);
			IJavaValue[] replacements = {bite, bite, bite};
			try {
				array.setValues(0, 1, replacements, 4);
			}
			catch(IndexOutOfBoundsException ioobe) {
				//got the expected exception
				return;
			}
			fail("Should have gotten an IndexOutOfBoundsException trying to use a source offset of 4");
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tries to set an array with a source index greater than the total length of the new values array
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetExactSrcIndexArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			// assign a new array
			IJavaArray javaArray = type.newInstance(3);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaValue bite = target.newValue((byte)-1);
			IJavaValue[] replacements = {bite, bite, bite};
			try {
				array.setValues(0, 1, replacements, 3);
			}
			catch(IndexOutOfBoundsException ioobe) {
				//got the expected exception
				return;
			}
			fail("Should have gotten an IndexOutOfBoundsException trying to use a source offset of 3");
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tries to set an array with a length less than -1
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetBadLowerLengthArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			// assign a new array
			IJavaArray javaArray = type.newInstance(3);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaValue bite = target.newValue((byte)-1);
			IJavaValue[] replacements = {bite, bite, bite};
			try {
				array.setValues(0, -2, replacements, 3);
			}
			catch(IndexOutOfBoundsException ioobe) {
				//got the expected exception
				return;
			}
			fail("Should have gotten an IndexOutOfBoundsException trying to use a length less than -1");
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tries to set an array with a length equal to -1
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetMinus1LengthArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			// assign a new array
			IJavaArray javaArray = type.newInstance(3);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaValue bite = target.newValue((byte)-1);
			IJavaValue[] replacements = {bite, bite, bite};
			try {
				array.setValues(0, -1, replacements, 0);
			}
			catch(IndexOutOfBoundsException ioobe) {
				fail("should be able to set all values passing -1 as length");
			}
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tries to set an array where the given length and index combined exceed the length of the array 
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetBadLengthPlusIndexArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			// assign a new array
			IJavaArray javaArray = type.newInstance(3);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaValue bite = target.newValue((byte)-1);
			IJavaValue[] replacements = {bite, bite, bite};
			try {
				array.setValues(2, 2, replacements, 0);
			}
			catch(IndexOutOfBoundsException ioobe) {
				//got the expected exception
				return;
			}
			fail("Should have gotten an IndexOutOfBoundsException trying to set a combined index of 4");
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tries to set an array where the given length and source index combined exceed the length of the array 
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetBadLengthPlusSrcIndexArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			IJavaArray javaArray = type.newInstance(3);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaValue bite = target.newValue((byte)-1);
			IJavaValue[] replacements = {bite, bite, bite};
			try {
				array.setValues(0, 2, replacements, 2);
			}
			catch(IndexOutOfBoundsException ioobe) {
				//got the expected exception
				return;
			}
			fail("Should have gotten an IndexOutOfBoundsException trying to set a combined source index of 4");
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
	
	/**
	 * Tries to set an array where the source array is longer than the array to set the values into
	 * @throws Exception
	 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=359450
	 */
	public void testSetLongerSrcArray() throws Exception {
		String typeName = "ByteArrayTests";
		ILineBreakpoint bp = createLineBreakpoint(32, typeName);
		
		IJavaThread thread = null;
		try {
			thread= launchToLineBreakpoint(typeName, bp);
			IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
			assertNotNull(frame);
			IJavaVariable v = findVariable(frame, "bytes");
			assertNotNull(v);
			IJavaArrayType type = (IJavaArrayType) v.getJavaType();
			IJavaValue value = (IJavaValue) v.getValue();
			assertNotNull(value);
			IJavaArray javaArray = type.newInstance(3);
			v.setValue(javaArray);
			IJavaArray  array = (IJavaArray) v.getValue();
			IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
			IJavaValue bite = target.newValue((byte)-1);
			IJavaValue[] replacements = {bite, bite, bite, bite, bite, bite};
			try {
				array.setValues(0, -1, replacements, 0);
			}
			catch(IndexOutOfBoundsException ioobe) {
				fail("Should not have gotten an IndexOutOfBoundsException trying to set an oversized source array");
			}
		} finally {
			terminateAndRemove(thread);
			removeAllBreakpoints();
		}	
	}
}