/*******************************************************************************
 * Copyright (c) 2000, 2010 QNX Software Systems 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:
 *     QNX Software Systems - Initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.debug.core.tests;

import java.io.IOException;
import java.math.BigInteger;

import junit.framework.Test;

import org.eclipse.cdt.debug.core.cdi.CDIException;
import org.eclipse.cdt.debug.core.cdi.ICDIAddressLocation;
import org.eclipse.cdt.debug.core.cdi.ICDICondition;
import org.eclipse.cdt.debug.core.cdi.ICDIFunctionLocation;
import org.eclipse.cdt.debug.core.cdi.ICDILineLocation;
import org.eclipse.cdt.debug.core.cdi.ICDILocator;
import org.eclipse.cdt.debug.core.cdi.model.ICDIBreakpoint;
import org.eclipse.cdt.debug.core.cdi.model.ICDILocationBreakpoint;
import org.eclipse.cdt.debug.core.cdi.model.ICDIStackFrame;
import org.eclipse.cdt.debug.core.cdi.model.ICDITarget;
import org.eclipse.cdt.debug.mi.core.MIException;
import org.eclipse.core.runtime.CoreException;

/**
 * @author Peter Graves
 * 
 * This file contains a set of generic tests for the CDI break point interfaces.
 * It will currenly use the mi implementation.
 *  
 */
public class BreakpointTests extends AbstractDebugTest {


	public static Test suite() {
		return new DebugTestWrapper(BreakpointTests.class) {};
	}
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		createDebugSession();
		assertNotNull(currentTarget);
		currentTarget.deleteAllBreakpoints();
		pause();
	}
	@Override
	protected void tearDown() throws Exception {
		/* clean up the session */
		targets[0].terminate();
		int x = 0;
		while ((!targets[0].isTerminated()) && (x < 30)) {
			Thread.sleep(100);
		}
		if (!targets[0].isTerminated())
			targets[0].terminate();
		super.tearDown();
	}


	/***************************************************************************
	 * A couple tests to make sure setting breakpoints on functions works as
	 * expected.
	 */
	public void testFunctionBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
		
		ICDITarget cdiTarget = currentTarget;
		ICDIFunctionLocation location;
		boolean caught = false;


		/***********************************************************************
		 * Create a break point on a generic function
		 **********************************************************************/

		location = cdiTarget.createFunctionLocation(null, "func1"); //$NON-NLS-1$
		assertNotNull(location);
		cdiTarget.setFunctionBreakpoint(0, location, null, false);

		/***********************************************************************
		 * Create a break point on main
		 **********************************************************************/

		location = cdiTarget.createFunctionLocation(null, "main"); //$NON-NLS-1$
		assertNotNull(location);
		cdiTarget.setFunctionBreakpoint(0, location, null, false);

		/***********************************************************************
		 * Try to create a break point on a function name that does not exist We
		 * expect that this will cause the setLocationBreakpoint to throw a
		 * CDIException
		 **********************************************************************/

		location = cdiTarget.createFunctionLocation(null, "badname"); //$NON-NLS-1$
		assertNotNull(location);
		try {
			cdiTarget.setFunctionBreakpoint(0, location, null, false);
		} catch (CDIException e) {
			caught = true;
		}
		assertTrue(caught);

		cdiTarget.deleteAllBreakpoints();

		/***********************************************************************
		 * Create a break point on a generic function and see if it will get hit
		 * and stop program execution.
		 **********************************************************************/

		location = cdiTarget.createFunctionLocation(null, "func1"); //$NON-NLS-1$
		assertNotNull(location);
		cdiTarget.setFunctionBreakpoint(0, location, null, false);
		targets = session.getTargets();
		/*
		 * We better only have one target connected to this session or something
		 * is not right...
		 */
		assertTrue(targets.length == 1);
		/*
		 * Resume the target, this should cause it to run till it hits the
		 * breakpoint
		 */
		resumeCurrentTarget();
		/**
		 * Give the process up to 10 seconds to become either terminated or
		 * suspended. It sould hit the breakponint almost immediatly so we
		 * should only sleep for max 100 ms
		 */
		waitSuspend(cdiTarget);
		ICDILocator locator = getCurrentLocator();
		assertTrue(locator.getLineNumber() == 6);
		assertTrue(locator.getFunction().equals("func1")); //$NON-NLS-1$
		assertTrue(locator.getFile().endsWith("main.c")); //$NON-NLS-1$
	}

	/***************************************************************************
	 * A couple tests to make sure setting breakpoints on line numbers works as
	 * expected.
	 */
	public void testLineBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
		ICDITarget cdiTarget = currentTarget;
		ICDILineLocation location;
		boolean caught = false;


		/***********************************************************************
		 * Create a break point in a generic function
		 **********************************************************************/
		location = cdiTarget.createLineLocation("main.c", 7);
		assertNotNull(location);
		cdiTarget.setLineBreakpoint(0, location, null, false);

		/***********************************************************************
		 * Create a break point in main
		 **********************************************************************/
		location = cdiTarget.createLineLocation("main.c", 18);
		assertNotNull(location);
		cdiTarget.setLineBreakpoint(0, location, null, false);

		/***********************************************************************
		 * Try to create a break point on a line that does not exist We expect
		 * that this will cause the setLocationBreakpoint to throw a
		 * CDIException
		 **********************************************************************/

		location = cdiTarget.createLineLocation("main.c", 30);
		assertNotNull(location);
		try {
			cdiTarget.setLineBreakpoint(0, location, null, false);
		} catch (CDIException e) {
			caught = true;
		}
		assertTrue(caught);

		caught = false;
		/***********************************************************************
		 * Try to create a break point on a line that does not have code on it
		 **********************************************************************/

		location = cdiTarget.createLineLocation("main.c", 11);
		assertNotNull(location);
		cdiTarget.setLineBreakpoint(0, location, null, false);

		/***********************************************************************
		 * Create a break point in a generic function without passing the source
		 * file name. At the time of writing this would just silently fail, so
		 * to make sure it works, we will do it once with a valid line number
		 * and once with an invalid line number, and the first should always
		 * succeed and the second should always throw an exception.
		 **********************************************************************/
		location = cdiTarget.createLineLocation(null, 7);
		assertNotNull(location);
		cdiTarget.setLineBreakpoint(0, location, null, false);
		caught = false;
		location = cdiTarget.createLineLocation(null, 30);
		assertNotNull(location);
		try {
			cdiTarget.setLineBreakpoint(0, location, null, false);
		} catch (CDIException e) {
			caught = true;
		}
		assertTrue("Ignoring line numbers with no file specified?", caught);

		cdiTarget.deleteAllBreakpoints();

		/***********************************************************************
		 * Create a break point on a line number and see if it will get hit and
		 * stop program execution.
		 **********************************************************************/

		location = cdiTarget.createLineLocation(null, 7);
		assertNotNull(location);
		cdiTarget.setLineBreakpoint(0, location, null, false);
		targets = session.getTargets();
		/*
		 * We better only have one target connected to this session or something
		 * is not right...
		 */
		assertTrue(targets.length == 1);
		/*
		 * Resume the target, this should cause it to run till it hits the
		 * breakpoint
		 */
		targets[0].resume();
		/**
		 * Give the process up to 10 seconds to become either terminated or
		 * suspended. It sould hit the breakponint almost immediatly so we
		 * should only sleep for max 100 ms
		 */
		for (int x = 0; x < 100; x++) {
			if (targets[0].isSuspended() || targets[0].isTerminated())
				break;
			Thread.sleep(100);
		}
		assertTrue("Suspended: " + targets[0].isSuspended() + " Termiunated: " + targets[0].isTerminated(), targets[0]
				.isSuspended());
		ICDILocator locator = getCurrentLocator();
		assertTrue(locator.getLineNumber() == 7);
		assertTrue(locator.getFunction().equals("func1"));
		assertTrue(locator.getFile().endsWith("main.c"));

	}

	/***************************************************************************
	 * A couple tests to make sure getting breakpoints works as expected
	 */
	public void testGetBreak() throws CoreException, MIException, IOException, CDIException {
		ICDITarget cdiTarget = currentTarget;
		ICDIFunctionLocation location;
		ICDIBreakpoint[] breakpoints;
		ICDILocationBreakpoint curbreak;


		/***********************************************************************
		 * Make sure initially we don't have any breakpoints
		 **********************************************************************/
		breakpoints = cdiTarget.getBreakpoints();
		assertNotNull(breakpoints);
		assertTrue(breakpoints.length == 0);

		/***********************************************************************
		 * Make sure if we create a simple breakpoint, that we can get it back
		 * from the system
		 **********************************************************************/
		/* Create a break point on a generic function */
		location = cdiTarget.createFunctionLocation("main.c", "func1");
		assertNotNull(location);
		cdiTarget.setFunctionBreakpoint(0, location, null, false);

		breakpoints = cdiTarget.getBreakpoints();
		assertNotNull(breakpoints);
		assertTrue(breakpoints.length == 1);
		if (breakpoints[0] instanceof ICDILocationBreakpoint) {
			curbreak = (ICDILocationBreakpoint) breakpoints[0];
		} else
			curbreak = null;
		assertNotNull(curbreak);

		//assertTrue(curbreak.getLocator().equals(location));
		{
			ICDILocator locator = curbreak.getLocator();
			String file = locator.getFile();
			String function = locator.getFunction();
			assertTrue("main.c".equals(file));
			assertTrue("func1".equals(function));
		}

		/***********************************************************************
		 * Make sure if we create multiple break points that we can still get
		 * them all back from the system,
		 **********************************************************************/
		/* Create another break point on main */
		location = cdiTarget.createFunctionLocation("main.c", "main");
		assertNotNull(location);
		cdiTarget.setFunctionBreakpoint(0, location, null, false);

		breakpoints = cdiTarget.getBreakpoints();
		assertNotNull(breakpoints);
		assertTrue(breakpoints.length == 2);
		if (breakpoints[1] instanceof ICDILocationBreakpoint) {
			curbreak = (ICDILocationBreakpoint) breakpoints[1];
		} else
			curbreak = null;
		assertNotNull(curbreak);
		/*
		 * Make sure the location still looks like we expect it to.. .
		 */
		//assertTrue(curbreak.getLocation().equals(location));
		{
			ICDILocator locator = curbreak.getLocator();
			String file = locator.getFile();
			String function = locator.getFunction();
			assertTrue("main.c".equals(file));
			assertTrue("main".equals(function));
		}

		cdiTarget.deleteAllBreakpoints();


	}

	/***************************************************************************
	 * A couple tests to make sure deleting breakpoints works as expected
	 */
	public void testDelBreak() throws CoreException, MIException, IOException, CDIException {
		ICDITarget cdiTarget = currentTarget;
		ICDIFunctionLocation location;
		ICDILocator savedLocation;
		ICDIBreakpoint[] breakpoints, savedbreakpoints;
		ICDILocationBreakpoint curbreak;

		/* Make sure initially we don't have any breakpoints */
		breakpoints = cdiTarget.getBreakpoints();
		assertNotNull(breakpoints);
		assertTrue(breakpoints.length == 0);

		/***********************************************************************
		 * 
		 * Test to make sure if we create a new breakpoint, we can delete it by
		 * passing a refrence to it to deleteBreakpoint()
		 *  
		 **********************************************************************/

		/* Create a break point on a generic function */
		location = cdiTarget.createFunctionLocation("main.c", "func1");
		assertNotNull(location);
		curbreak = cdiTarget.setFunctionBreakpoint(0, location, null, false);
		cdiTarget.deleteBreakpoints( new ICDIBreakpoint[] { curbreak } );
		pause();
		/**
		 * we should not have any breakpoints left.
		 */
		breakpoints = cdiTarget.getBreakpoints();
		assertTrue(breakpoints.length == 0);

		/***********************************************************************
		 * 
		 * Test to make sure if we create multiple new breakpoint, we can delete
		 * one of them by passing a refrence to it to deleteBreakpoint()
		 *  
		 **********************************************************************/

		/* Create a break point on a generic function */
		location = cdiTarget.createFunctionLocation("main.c", "func1");
		assertNotNull(location);
		curbreak = cdiTarget.setFunctionBreakpoint(0, location, null, false);
		savedLocation = curbreak.getLocator();

		location = cdiTarget.createFunctionLocation("main.c", "main");
		assertNotNull(location);
		curbreak = cdiTarget.setFunctionBreakpoint(0, location, null, false);
		cdiTarget.deleteBreakpoints( new ICDIBreakpoint[] { curbreak } );
		pause();
		breakpoints = cdiTarget.getBreakpoints();
		/***********************************************************************
		 * Make sure there is only 1 breakpoint left, and it's the one we expect
		 */
		assertTrue(breakpoints.length == 1);
		curbreak = (ICDILocationBreakpoint) breakpoints[0];
		assertNotNull(curbreak);
		assertTrue(curbreak.getLocator().equals(savedLocation));
		/***********************************************************************
		 * Then delete the other breakpoint.
		 */
		cdiTarget.deleteBreakpoints( new ICDIBreakpoint[] { curbreak } );
		pause();
		breakpoints = cdiTarget.getBreakpoints();
		assertTrue(breakpoints.length == 0);

		/***********************************************************************
		 * Make sure deleteBreakpoints works when given 1 breakpoint to delete
		 **********************************************************************/
		savedbreakpoints = new ICDIBreakpoint[1];
		int lineStart = 6;
		int maxBreakpoints = 5;
		for (int x = 0; x < maxBreakpoints; x++) {
			ICDILineLocation lineLocation = cdiTarget.createLineLocation("main.c", x + lineStart);
			ICDILocationBreakpoint bp = cdiTarget.setLineBreakpoint(0, lineLocation, null, false);
			assertNotNull(bp);
			assertEquals(x + lineStart, (bp.getLocator().getLineNumber()));
			savedbreakpoints[0] = bp;
		}
		cdiTarget.deleteBreakpoints(savedbreakpoints);
		pause();
		/* We should now have N-1 breakpoints left. */
		breakpoints = cdiTarget.getBreakpoints();
		assertTrue(breakpoints.length == maxBreakpoints-1);
		/* Make sure we have the correct N-1 breakpoints left, we deleted one at line N */
		for (int x = 0; x < breakpoints.length; x++) {
			curbreak = (ICDILocationBreakpoint) breakpoints[x];
			assertNotEquals(((ICDILocationBreakpoint)savedbreakpoints[0]).getLocator().getLineNumber(), curbreak.getLocator().getLineNumber());
		}
		cdiTarget.deleteAllBreakpoints();
		pause();
		assertTrue(cdiTarget.getBreakpoints().length == 0);

		/***********************************************************************
		 * Make sure deleteBreakpoints works when given more then 1 but less
		 * then all breakpoints to delete
		 **********************************************************************/
		savedbreakpoints = new ICDIBreakpoint[2];
		for (int x = 0; x < maxBreakpoints; x++) {
			ICDILineLocation lineLocation = cdiTarget.createLineLocation("main.c", x + lineStart);
			savedbreakpoints[x % 2] = cdiTarget.setLineBreakpoint(0, lineLocation, null, false);
			assertNotNull(savedbreakpoints[x % 2]);
		}
		cdiTarget.deleteBreakpoints(savedbreakpoints);
		pause();

		/* We should now have maxBreakpoints-2 breakpoints left. */
		breakpoints = cdiTarget.getBreakpoints();
		assertEquals(maxBreakpoints-2, breakpoints.length );
		/* Make sure we have the correct 6 breakpoints left */
		for (int x = 0; x < breakpoints.length; x++) {
			curbreak = (ICDILocationBreakpoint) breakpoints[x];
			assertEquals(x+lineStart, curbreak.getLocator().getLineNumber());
		}
		cdiTarget.deleteAllBreakpoints();
		pause();
		assertTrue(cdiTarget.getBreakpoints().length == 0);

		/***********************************************************************
		 * Make sure deleteBreakpoints works when given all the breakpoints
		 **********************************************************************/
		savedbreakpoints = new ICDIBreakpoint[maxBreakpoints];
		for (int x = 0; x < maxBreakpoints; x++) {
			ICDILineLocation lineLocation = cdiTarget.createLineLocation("main.c", x + lineStart);
			savedbreakpoints[x] = cdiTarget.setLineBreakpoint(0, lineLocation, null, false);
			assertNotNull(savedbreakpoints[x]);
		}
		cdiTarget.deleteBreakpoints(savedbreakpoints);
		pause();
		/* We should now have 0 breakpoints left. */
		breakpoints = cdiTarget.getBreakpoints();
		assertTrue(breakpoints.length == 0);

		/***********************************************************************
		 * Make sure deleteAllBreakpoints works
		 **********************************************************************/

		for (int x = 0; x < maxBreakpoints; x++) {
			ICDILineLocation lineLocation = cdiTarget.createLineLocation("main.c", x + lineStart);
			curbreak = cdiTarget.setLineBreakpoint(0, lineLocation, null, false);
			assertNotNull(curbreak);
		}
		cdiTarget.deleteAllBreakpoints();
		pause();
		/* We should now have 0 breakpoints left. */
		breakpoints = cdiTarget.getBreakpoints();
		assertTrue(breakpoints.length == 0);

	}

	private void assertNotEquals(int notExpected, int actual) {
		if (notExpected==actual)
			fail("not expected:<"+actual+">");
		
	}
	/***************************************************************************
	 * A couple tests to make sure setting breakpoints with conditions seems to
	 * work as expected.
	 */
	public void testCondBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
		boolean caught = false;
		ICDITarget cdiTarget = currentTarget;
		ICDICondition cond;

		/***********************************************************************
		 * Create a break point on a line number with a condition and make sure
		 * it does not suspend execution of the application until the condition
		 * is true
		 **********************************************************************/
		cdiTarget.deleteAllBreakpoints();
		pause();
		ICDILineLocation lineLocation = cdiTarget.createLineLocation(null, 23);
		assertNotNull(lineLocation);
		cond = cdiTarget.createCondition(0, "a>10");
		cdiTarget.setLineBreakpoint(0, lineLocation, cond, false);
		pause();
		resumeCurrentTarget();
		/**
		 * Give the process up to 10 seconds to become either terminated or
		 * suspended. It sould hit the breakponint almost immediatly so we
		 * should only sleep for max 100 ms
		 */
		waitSuspend(cdiTarget);
		ICDIStackFrame frame = getCurrentFrame(); 
		ICDILocator locator = getCurrentLocator();
		assertTrue(locator.getLineNumber() == 23);
		assertTrue(locator.getFunction().equals("main"));
		assertTrue(locator.getFile().endsWith("main.c"));
		/* Get the value of a and and make sure it is 11 */
		assertTrue(targets[0].evaluateExpressionToString(frame, "a"), targets[0].evaluateExpressionToString(frame, "a").equals("11"));

	}
	public void testCondBreak2() throws CoreException, MIException, IOException, CDIException, InterruptedException {

		ICDITarget cdiTarget = currentTarget;

		/***********************************************************************
		 * Create a break point on a generic function with an empty condition
		 **********************************************************************/
		ICDICondition cond = cdiTarget.createCondition(0, "");
		ICDIFunctionLocation location = cdiTarget.createFunctionLocation(null, "func1");
		assertNotNull(location);
		cdiTarget.setFunctionBreakpoint(0, location, cond, false);

		/***********************************************************************
		 * Create a break point on a generic function with an valid condition
		 **********************************************************************/
		cond = cdiTarget.createCondition(0, "x<10");
		ICDILineLocation location2 = cdiTarget.createLineLocation("main.c", 9);
		assertNotNull(location);
		cdiTarget.setLineBreakpoint(0, location2, cond, false);
	}
	
	public void testCondBreakError() {
		ICDITarget cdiTarget = currentTarget;
	    ICDICondition cond;
	    ICDIFunctionLocation location;
	    /***********************************************************************
		 * Create a break point on a generic function with an invalid condition
		 * We expect to get a CDIException when we try to set the breakpoint.
		 **********************************************************************/
		boolean caught = false;
		cond = cdiTarget.createCondition(0, "nonexist<10");
		location = cdiTarget.createFunctionLocation(null, "func1");
		assertNotNull(location);
		try {
			cdiTarget.setFunctionBreakpoint(0, location, cond, false);
		} catch (CDIException e) {
			caught = true;
		}
		assertTrue("Setting wrong condition should fail",caught);
    }
	
	public void testHitCond() throws CoreException, MIException, IOException, CDIException, InterruptedException {
		setBreakOnMain();
		testCondBreak2();
		resumeCurrentTarget();
		waitSuspend(currentTarget);
	}
	public void xfail_testHitCondWithError() throws CoreException, MIException, IOException, CDIException, InterruptedException {
		// this currently fails sometimes - after set bad breakpoint it does not hit any
		// only reproducible when setting invalid condition breakpoint, reason unknown
		setBreakOnMain();
		testCondBreak2();
		testCondBreakError();
		pause();
		/* We should now have 3 breakpoints left. */
		ICDIBreakpoint[] breakpoints = currentTarget.getBreakpoints();
		assertTrue(breakpoints.length == 3);
		resumeCurrentTarget();
		waitSuspend(currentTarget);
	}
	/***************************************************************************
	 * A test to make sure setting address breakpoints works as
	 * expected.
	 */
	public void testAddressBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
		
		
		ICDIAddressLocation location;
		boolean caught = false;

		setBreakOnMain();
		currentTarget.resume(false);
		waitSuspend(currentTarget);
		currentTarget.stepOver(1);
		pause();
		BigInteger address = getCurrentLocator().getAddress();
		/***********************************************************************
		 * Create a break point on first instruction
		 **********************************************************************/

		location = currentTarget.createAddressLocation(address); 
		assertNotNull(location);
		currentTarget.setAddressBreakpoint(0, location, null, false);
		
		// restart
		currentTarget.restart();
		pause();
		waitSuspend(currentTarget);
		
		ICDILocator locator = getCurrentLocator();
		assertTrue(locator.getLineNumber() == 18);
		assertTrue(locator.getFunction().equals("main")); //$NON-NLS-1$
		assertTrue(locator.getFile().endsWith("main.c")); //$NON-NLS-1$
	}

}