package org.eclipse.cdt.debug.core.tests;

/*
 * (c) Copyright QNX Software Systems Ltd. 2002.
 * All Rights Reserved.
 */


import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

import junit.extensions.TestSetup;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.debug.core.cdi.CDIException;
import org.eclipse.cdt.debug.core.cdi.ICDIBreakpointManager;
import org.eclipse.cdt.debug.core.cdi.ICDICondition;
import org.eclipse.cdt.debug.core.cdi.ICDILocation;
import org.eclipse.cdt.debug.core.cdi.ICDISession;
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.ICDITarget;
import org.eclipse.cdt.debug.mi.core.MIException;
import org.eclipse.cdt.debug.testplugin.CDebugHelper;
import org.eclipse.cdt.debug.testplugin.CProjectHelper;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;

/**
 * @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 TestCase {
    IWorkspace workspace;
    IWorkspaceRoot root;
    static ICProject testProject=null;
    NullProgressMonitor monitor;
	static ICDISession session=null;
	static ICDITarget targets[] = null;
    

    /**
     * Constructor for BreakpointTests
     * @param name
     */
    public BreakpointTests(String name) {
        super(name);
     /***
     * The tests assume that they have a working workspace
     * and workspace root object to use to create projects/files in, 
     * so we need to get them setup first.
     */
        workspace= ResourcesPlugin.getWorkspace();
        root= workspace.getRoot();
        monitor = new NullProgressMonitor();
        if (workspace==null) 
            fail("Workspace was not setup");
        if (root==null)
            fail("Workspace root was not setup");

    }
    
    /**
     * Sets up the test fixture.
     *
     * Called before every test case method.
     * 
     * Example code test the packages in the project 
     *  "com.qnx.tools.ide.cdt.core"
     */
    protected static void oneTimeSetUp() throws CoreException, InvocationTargetException, IOException {
		ResourcesPlugin.getWorkspace().getDescription().setAutoBuilding(false);
		/***
		 * Create a new project and import the test source.
		 */
		String pluginRoot=org.eclipse.core.runtime.Platform.getPlugin("org.eclipse.cdt.debug.ui.tests").find(new Path("/")).getFile();
		pluginRoot=pluginRoot+"resources/debugTest.zip";
		testProject=CProjectHelper.createCProjectWithImport("filetest", pluginRoot);
        if (testProject==null)
            fail("Unable to create project");
		/* Build the test project.. */

		testProject.getProject().build(IncrementalProjectBuilder.FULL_BUILD, null);
	}
	 /**
	 * Tears down the test fixture.
	 *
	 * Called after every test case method.
	 */
	protected void tearDown() throws CoreException {
		if (targets!=null) {
			try {
				targets[0].terminate();
				targets=null;
			} catch (CDIException e) {}
		}
		if (session!=null) {
			try {
				session.terminate();
				session=null;
			} catch (CDIException e) {}
		}
	}
    
     /**
     * Tears down the test fixture.
     *
     * Called after every test case method.
     */
    protected static  void oneTimeTearDown() throws CoreException {
    	if (targets!=null) {
    		try {
				targets[0].terminate();
			} catch (CDIException e) {}
    	}
    	if (session!=null) {
    		try {
				session.terminate();
			} catch (CDIException e) {}
    	}
        CProjectHelper.delete(testProject);
		
    }
    
    public static Test suite() {
	    TestSuite suite= new TestSuite(BreakpointTests.class);
		/***
		 * Create a wrapper suite around the test suite we created above to 
		 * allow us to only do the general setup once for all the tests.  This
		 * is needed because the creation of the source and target projects 
		 * takes a long time and we really only need to do it once.  We could
		 * do the setup in the constructor, but we need to be able to remove
		 * everything when we are done.
		 */
		TestSetup wrapper = new TestSetup(suite) {

			protected void setUp() throws FileNotFoundException, IOException, InterruptedException, InvocationTargetException, CoreException {
				oneTimeSetUp();
			}
	
			protected void tearDown() throws FileNotFoundException, IOException, CoreException {
				oneTimeTearDown();
			}
		};
		return(wrapper);
    }
    

    /***
     * A couple tests to make sure setting breakpoints on functions works as
     * expected.
     */
    public void testFunctionBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
        ICDISession session;
        ICDIBreakpointManager breaks;
        ICDILocation location;
        boolean caught=false;    
        session=CDebugHelper.createSession("main", testProject);
        assertNotNull(session);
        breaks=session.getBreakpointManager();
        assertNotNull(breaks);
    
        /**********************************************************************
         * Create a break point on a generic function 
         **********************************************************************/    
   
        location=breaks.createLocation(null, "func1", 0);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, null, null);

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

        location=breaks.createLocation(null, "main", 0);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, null, null);

        
        /**********************************************************************
         *  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=breaks.createLocation(null, "badname", 0);
        assertNotNull(location);
        try {
            breaks.setLocationBreakpoint(0, location, null, null);
        } catch (CDIException e) {
            caught=true;            
        }
        assertTrue(caught);
        
        breaks.deleteAllBreakpoints();
        
        /**********************************************************************
         * Create a break point on a generic function and see if it will 
         * get hit and stop program execution.
         **********************************************************************/    
   
        location=breaks.createLocation(null, "func1", 0);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, null, null);
        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].isTerminated() || targets[0].isSuspended()) 
                break;
            Thread.sleep(100);
        }
        assertTrue(targets[0].isSuspended());
        location=targets[0].getCurrentThread().getStackFrames()[0].getLocation();
        assertTrue(location.getLineNumber()==6);
        assertTrue(location.getFunction().equals("func1"));
        assertTrue(location.getFile().equals("main.c"));

        /* 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();
        session.terminate();
		session=null;
		targets=null;        

    
   }

    /***
     * A couple tests to make sure setting breakpoints on line numbers works as
     * expected.
     */
    public void testLineBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
        ICDIBreakpointManager breaks;
        ICDILocation location;
        boolean caught=false;    
        session=CDebugHelper.createSession("main", testProject);
        assertNotNull(session);
        breaks=session.getBreakpointManager();
        assertNotNull(breaks);
    
        /********************************************************************** 
         * Create a break point in a generic function 
         **********************************************************************/    
        location=breaks.createLocation("main.c", null, 7);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, null, null);

        
        /**********************************************************************
         *  Create a break point in main 
         **********************************************************************/    
        location=breaks.createLocation("main.c", null, 18);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, null, null);

        
        /**********************************************************************
         *  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=breaks.createLocation("main.c", null, 30);
        assertNotNull(location);
        try {
            breaks.setLocationBreakpoint(0, location, null, null);
        } 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=breaks.createLocation("main.c", null, 11);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, null, null);
        
        /**********************************************************************
         *  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=breaks.createLocation(null, null, 7);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, null, null);
        caught=false;
        location=breaks.createLocation(null, null, 30);
        assertNotNull(location);
        try {
            breaks.setLocationBreakpoint(0, location, null, null);
        } catch (CDIException e) {
            caught=true;            
        }
        assertTrue("Ignoring line numbers with no file specified?", caught);

        breaks.deleteAllBreakpoints();     
        
        /**********************************************************************
         * Create a break point on a line number and see if it will 
         * get hit and stop program execution.
         **********************************************************************/    
   
        location=breaks.createLocation(null, null, 7);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, null, null);
        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());
        location=targets[0].getCurrentThread().getStackFrames()[0].getLocation();
        assertTrue(location.getLineNumber()==7);
        assertTrue(location.getFunction().equals("func1"));
        assertTrue(location.getFile().equals("main.c"));

        
        /* clean up the session */
        session.terminate();
        session=null;
        targets=null;
      
   }
    /***
     * A couple tests to make sure getting breakpoints works as expected
     */
    public void testGetBreak() throws CoreException, MIException, IOException, CDIException {
        ICDIBreakpointManager breaks;
        ICDILocation location;
        ICDIBreakpoint[] breakpoints;
        ICDILocationBreakpoint curbreak;
        session=CDebugHelper.createSession("main", testProject);
        assertNotNull(session);
        breaks=session.getBreakpointManager();
        assertNotNull(breaks);
        
        /**********************************************************************
         *  Make sure initially we don't have any breakpoints 
         **********************************************************************/
        breakpoints=breaks.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=breaks.createLocation("main.c", "func1", 0);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, null, null);
        
        breakpoints=breaks.getBreakpoints();
        assertNotNull(breakpoints);
        assertTrue(breakpoints.length==1);
        if (breakpoints[0] instanceof ICDILocationBreakpoint) {
            curbreak=(ICDILocationBreakpoint) breakpoints[0];
        } else
            curbreak=null;
        assertNotNull(curbreak);
        
        assertTrue(curbreak.getLocation().equals(location));

        /**********************************************************************
         * 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=breaks.createLocation("main.c", "main", 0);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, null, null);
        
        breakpoints=breaks.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));

        breaks.deleteAllBreakpoints();
        

        /* clean up the session */
        session.terminate();
		session=null;
		
   }

    /***
     * A couple tests to make sure deleting breakpoints works as expected
     */
    public void testDelBreak() throws CoreException, MIException, IOException, CDIException {
        ICDIBreakpointManager breaks;
        ICDILocation location, savedLocation;
        ICDIBreakpoint[] breakpoints, savedbreakpoints;
        ICDILocationBreakpoint curbreak;
        
        session=CDebugHelper.createSession("main", testProject);
        assertNotNull(session);
        breaks=session.getBreakpointManager();
        assertNotNull(breaks);
        
        /* Make sure initially we don't have any breakpoints */
        breakpoints=breaks.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=breaks.createLocation("main.c", "func1", 0);
        assertNotNull(location);
        curbreak=breaks.setLocationBreakpoint(0, location, null, null);
        breaks.deleteBreakpoint(curbreak);
        pause();
        /**
         * we should not have any breakpoints left.
         */
        breakpoints=breaks.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=breaks.createLocation("main.c", "func1", 0);
        assertNotNull(location);
        curbreak=breaks.setLocationBreakpoint(0, location, null, null);
        savedLocation=curbreak.getLocation();
        
        location=breaks.createLocation("main.c", "main", 0);
        assertNotNull(location);
        curbreak=breaks.setLocationBreakpoint(0, location, null, null);
        breaks.deleteBreakpoint(curbreak);
		pause();
        breakpoints=breaks.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.getLocation().equals(savedLocation));
        /***
         * Then delete the other breakpoint.
         */
        breaks.deleteBreakpoint(curbreak);
		pause();
        breakpoints=breaks.getBreakpoints();
        assertTrue(breakpoints.length==0);
        
        /**********************************************************************
         * Make sure deleteBreakpoints works when given 1 breakpoint to delete
         **********************************************************************/
        savedbreakpoints= new ICDIBreakpoint[1];
        for (int x=0;x<10;x++) {
            location=breaks.createLocation("main.c", null, x+1);
            savedbreakpoints[0]=breaks.setLocationBreakpoint(0, location, null, null);
            assertNotNull(savedbreakpoints[0]);
        }        
        breaks.deleteBreakpoints(savedbreakpoints);
		pause();
        /* We should now have 9 breakpoints left. */
        breakpoints=breaks.getBreakpoints();
        assertTrue(breakpoints.length==9);
        /* Make sure we have the correct 9 breakpoints left */
        for (int x=0;x<breakpoints.length;x++) {
            curbreak=(ICDILocationBreakpoint)breakpoints[x];
            assertTrue(curbreak.getLocation().getLineNumber()==x+1);
        }
        breaks.deleteAllBreakpoints();
		pause();
        assertTrue(breaks.getBreakpoints().length==0);
        
        /**********************************************************************
         * Make sure deleteBreakpoints works when given more then 1 but less 
         * then all breakpoints to delete
         **********************************************************************/
        savedbreakpoints= new ICDIBreakpoint[4];
        for (int x=0;x<10;x++) {
            location=breaks.createLocation("main.c", null, x+1);
            savedbreakpoints[x%4]=breaks.setLocationBreakpoint(0, location, null, null);
            assertNotNull(savedbreakpoints[x%4]);
        }        
        breaks.deleteBreakpoints(savedbreakpoints);
		pause();
        
        /* We should now have 6 breakpoints left. */
        breakpoints=breaks.getBreakpoints();
        assertTrue(breakpoints.length==6);
        /* Make sure we have the correct 6 breakpoints left */
        for (int x=0;x<breakpoints.length;x++) {
            curbreak=(ICDILocationBreakpoint)breakpoints[x];
            assertTrue(curbreak.getLocation().getLineNumber()==x+1);
        }
        breaks.deleteAllBreakpoints();
		pause();
        assertTrue(breaks.getBreakpoints().length==0);

        /**********************************************************************
         * Make sure deleteBreakpoints works when given all the breakpoints
         **********************************************************************/
        savedbreakpoints= new ICDIBreakpoint[10];
        for (int x=0;x<10;x++) {
            location=breaks.createLocation("main.c", null, x+1);
            savedbreakpoints[x]=breaks.setLocationBreakpoint(0, location, null, null);
            assertNotNull(savedbreakpoints[x]);
        }        
        breaks.deleteBreakpoints(savedbreakpoints);
		pause();
        /* We should now have 0 breakpoints left. */
        breakpoints=breaks.getBreakpoints();
        assertTrue(breakpoints.length==0);

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

        for (int x=0;x<10;x++) {
            location=breaks.createLocation("main.c", null, x+1);
            curbreak=breaks.setLocationBreakpoint(0, location, null, null);
            assertNotNull(curbreak);
        }        
        breaks.deleteAllBreakpoints();
		pause();
        /* We should now have 0 breakpoints left. */
        breakpoints=breaks.getBreakpoints();
        assertTrue(breakpoints.length==0);


        /* clean up the session */
        session.terminate();
		session=null;
    
   }
    /***
     * A couple tests to make sure setting breakpoints with conditions seems to
     * work as expected.
     */
    public void testCondBreak() throws CoreException, MIException, IOException, CDIException, InterruptedException {
        ICDIBreakpointManager breaks;
        ICDILocation location;
        ICDICondition cond;
        boolean caught=false;
        session=CDebugHelper.createSession("main", testProject);
        assertNotNull(session);
        breaks=session.getBreakpointManager();
        assertNotNull(breaks);
    
        /**********************************************************************
         * Create a break point on a generic function with an empty condition
         **********************************************************************/    
        cond=breaks.createCondition(0, "");
        location=breaks.createLocation(null, "func1", 0);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, cond, null);

        /**********************************************************************
         * Create a break point on a generic function with an valid condition
         **********************************************************************/    
        cond=breaks.createCondition(0, "x<10");
        location=breaks.createLocation(null, "func1", 0);
        assertNotNull(location);
        breaks.setLocationBreakpoint(0, location, cond, null);

        /**********************************************************************
         * 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.
         **********************************************************************/    
        cond=breaks.createCondition(0, "nonexist<10");
        location=breaks.createLocation(null, "func1", 0);
        assertNotNull(location);
        try {
            breaks.setLocationBreakpoint(0, location, cond, null);
        } catch (CDIException e) {
            caught=true;
        }
        assertTrue(caught);
        
        /**********************************************************************
         * 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
         **********************************************************************/    
        breaks.deleteAllBreakpoints();   
        location=breaks.createLocation(null, null, 23);
        assertNotNull(location);
        cond=breaks.createCondition(0, "a>10");
   
        breaks.setLocationBreakpoint(0, location, cond, null);
        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());
        location=targets[0].getCurrentThread().getStackFrames()[0].getLocation();
        assertTrue(location.getLineNumber()==23);
        assertTrue(location.getFunction().equals("main"));
        assertTrue(location.getFile().equals("main.c"));
        /* Get the value of a and and make sure it is 11 */
        assertTrue(targets[0].evaluateExpressionToString("a"),
        targets[0].evaluateExpressionToString("a").equals("11"));        
        
        
        /* clean up the session */
        session.terminate();
		session=null;
		targets=null;
    
   }
   void pause() {
	try {
		Thread.sleep(100);
	} catch (InterruptedException e) {
	}
   }

}