Attachment #192028 for bug #337893

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.





#include <stdio.h>
#include "Sleep.h"


void PrintHello()
{
   printf("Hello World!\n");

   SLEEP(1);
    
}

void PrintHi()
{
   printf("Hi everybody!\n");

   SLEEP(1);
    
}

void PrintBonjour()
{
   printf("Bonjour!\n");   

   SLEEP(1);
    
}

int main(int argc, char *argv[])
{
	printf("In main\n");
	  
    SLEEP(1);
    
    SLEEP(1);
	
	PrintHello();
	
	PrintHi();
	
	PrintBonjour();
	
	return 0;
}




/*******************************************************************************
 * Copyright (c) 2007, 2010 Ericsson 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:
 *     Ericsson	AB		  - Initial implementation of Test cases
 *******************************************************************************/
package org.eclipse.cdt.tests.dsf.gdb.tests;


import static org.junit.Assert.fail;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants;
import org.eclipse.cdt.dsf.concurrent.CountingRequestMonitor;
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
import org.eclipse.cdt.dsf.concurrent.Query;
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
import org.eclipse.cdt.dsf.concurrent.Sequence.Step;
import org.eclipse.cdt.dsf.datamodel.DMContexts;
import org.eclipse.cdt.dsf.debug.service.IBreakpoints.IBreakpointsTargetDMContext;
import org.eclipse.cdt.dsf.debug.service.IProcesses.IProcessDMContext;
import org.eclipse.cdt.dsf.debug.service.IRunControl.IContainerDMContext;
import org.eclipse.cdt.dsf.debug.service.IRunControl.ISuspendedDMEvent;
import org.eclipse.cdt.dsf.gdb.service.command.IGDBControl;
import org.eclipse.cdt.dsf.mi.service.IMIProcesses;
import org.eclipse.cdt.dsf.mi.service.IMIRunControl;
import org.eclipse.cdt.dsf.mi.service.MIProcesses;
import org.eclipse.cdt.dsf.mi.service.command.output.MIBreakInsertInfo;
import org.eclipse.cdt.dsf.service.DsfServicesTracker;
import org.eclipse.cdt.dsf.service.DsfSession;
import org.eclipse.cdt.tests.dsf.gdb.framework.BackgroundRunner;
import org.eclipse.cdt.tests.dsf.gdb.framework.BaseTestCase;
import org.eclipse.cdt.tests.dsf.gdb.framework.ServiceEventWaitor;
import org.eclipse.cdt.tests.dsf.gdb.framework.SyncUtil;
import org.eclipse.cdt.tests.dsf.gdb.launching.TestsPlugin;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;


/**
 * Tests MIRunControl class for for the execWhileTargetAvailable() method. 
 */
@RunWith(BackgroundRunner.class)
public class MIRunControlTargetAvailableTest extends BaseTestCase {

	private static final String TIMEOUT_MESSAGE = "Timeout";

	private DsfServicesTracker fServicesTracker;    

    private IGDBControl fGDBCtrl;
	private IMIRunControl fRunCtrl;

	private IContainerDMContext fContainerDmc;

	/*
	 * Path to executable
	 */
	private static final String EXEC_PATH = "data/launch/bin/";
	/*
	 * Name of the executable
	 */
	private static final String EXEC_NAME = "TargetAvail.exe";
	private static final String SOURCE_NAME = "TargetAvail.cc";
	
	@Before
	public void init() throws Exception {
		final DsfSession session = getGDBLaunch().getSession();
		
        Runnable runnable = new Runnable() {
            public void run() {
           	fServicesTracker = 
            		new DsfServicesTracker(TestsPlugin.getBundleContext(), 
            				session.getId());
            	fGDBCtrl = fServicesTracker.getService(IGDBControl.class);
            	
            	IMIProcesses procService = fServicesTracker.getService(IMIProcesses.class);
            	IProcessDMContext procDmc = procService.createProcessContext(fGDBCtrl.getContext(), MIProcesses.UNIQUE_GROUP_ID);
            	fContainerDmc = procService.createContainerContext(procDmc, MIProcesses.UNIQUE_GROUP_ID);
            	
            	fRunCtrl = fServicesTracker.getService(IMIRunControl.class);
            }
        };
        session.getExecutor().submit(runnable).get();
	}


	@After
	public void tearDown() {
		fServicesTracker.dispose();
	}
	
	@BeforeClass
	public static void beforeClassMethod() {
		setLaunchAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME, 
				           EXEC_PATH + EXEC_NAME);
	}

    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for a single operation with a single step when the target is stopped. 
     */
    @Test
    public void executeSingleStepSingleOpWhileTargetStopped() throws Throwable {
    	// The target is currently stopped.
 
        // A single step that will set a breakpoint at PrintHello, which we will then make sure hits
    	final Step[] steps = new Step[] {
        	new Step() {
        		@Override
        		public void execute(RequestMonitor rm) {
        	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
        	    	
        	        fGDBCtrl.queueCommand(
        	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintHello", 0),
        	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
        		}}
        };
        
        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(DataRequestMonitor<Boolean> rm) {
				fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps, rm);				
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		fail(e.getCause().getMessage());
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	// Now resume the target and check that we stop at the breakpoint.
    	       	
        ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
        		getGDBLaunch().getSession(),
        		ISuspendedDMEvent.class);

    	SyncUtil.resume();
    	
        // Wait up to 3 second for the target to suspend. Should happen within 2 second.
        suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));
    }
    
    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for a single operation with a single step when the target is running. 
     */
    @Test
    public void executeSingleStepSingleOpWhileTargetRunning() throws Throwable {
        // A single step that will set a breakpoint at PrintHello, which we will then make sure hits
    	final Step[] steps = new Step[] {
        	new Step() {
        		@Override
        		public void execute(RequestMonitor rm) {
        	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
        	    	
        	        fGDBCtrl.queueCommand(
        	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintHello", 0),
        	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
        		}}
        };
        
    	// The target is currently stopped so we resume it
        ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
        		getGDBLaunch().getSession(),
        		ISuspendedDMEvent.class);

    	SyncUtil.resume();
    	
        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(DataRequestMonitor<Boolean> rm) {
				fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps, rm);				
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		fail(e.getCause().getMessage());
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	// Now check that the target is stopped at the breakpoint.
        // Wait up to 3 second for the target to suspend. Should happen at most in 2 seconds.
        suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));
    }
    
    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for a single operation with multiple steps when the target is stopped. 
     */
    @Test
    public void executeMultiStepSingleOpWhileTargetStopped() throws Throwable {
    	// The target is currently stopped.

        // Multiple steps that will set three temp breakpoints at three different lines
        // We then check that the target will stop three times
    	final Step[] steps = new Step[] {
        	new Step() {
        		@Override
        		public void execute(RequestMonitor rm) {
        	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
        	    	
        	        fGDBCtrl.queueCommand(
        	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintHello", 0),
        	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
        		}},
           	new Step() {
           		@Override
           		public void execute(RequestMonitor rm) {
           	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
           	    	
           	        fGDBCtrl.queueCommand(
           	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintHi", 0),
           	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
           		}},
           	new Step() {
           		@Override
           		public void execute(RequestMonitor rm) {
           	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
           	    	
           	        fGDBCtrl.queueCommand(
           	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintBonjour", 0),
           	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
           		}}
        };
        
        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(DataRequestMonitor<Boolean> rm) {
				fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps, rm);				
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		fail(e.getCause().getMessage());
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	// Now resume the target three times and check that we stop three times.
    	for (int i=0; i<steps.length; i++) {
            ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
            		getGDBLaunch().getSession(),
            		ISuspendedDMEvent.class);

        	SyncUtil.resume();

    		// Wait up to 3 second for the target to suspend. Should happen within 2 seconds.
    		suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));
    	}
    }
    
    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for a single operation with multiple steps when the target is stopped
     * and one of the steps fails. 
     */
    @Test
    public void executeMultiStepSingleOpWhileTargetStoppedWithError() throws Throwable {
    	// The target is currently stopped.

        // Multiple steps that will set three temp breakpoints at three different lines
        // We then check that the target will stop three times
    	final Step[] steps = new Step[] {
        	new Step() {
        		@Override
        		public void execute(RequestMonitor rm) {
        	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
        	    	
        	        fGDBCtrl.queueCommand(
        	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintHello", 0),
        	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
        		}},
           	new Step() {
           		@Override
           		public void execute(RequestMonitor rm) {
           	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
           	    	
           	        fGDBCtrl.queueCommand(
           	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, "invalid condition", 0, "PrintHi", 0),
           	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
           		}},
           	new Step() {
           		@Override
           		public void execute(RequestMonitor rm) {
           	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
           	    	
           	        fGDBCtrl.queueCommand(
           	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintBonjour", 0),
           	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
           		}}
        };
        
        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(DataRequestMonitor<Boolean> rm) {
				fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps, rm);				
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		// We want to detect the error, so this is success
    		return;
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	fail("Did not detect the error of the step");
    }
    
    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for a single operation with multiple steps when the target is running. 
     */
    @Test
    public void executeMultiStepSingleOpWhileTargetRunning() throws Throwable {
        // Multiple steps that will set three temp breakpoints at three different lines
        // We then check that the target will stop three times
    	final Step[] steps = new Step[] {
        	new Step() {
        		@Override
        		public void execute(RequestMonitor rm) {
        	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
        	    	
        	        fGDBCtrl.queueCommand(
        	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintHello", 0),
        	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
        		}},
           	new Step() {
           		@Override
           		public void execute(RequestMonitor rm) {
           	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
           	    	
           	        fGDBCtrl.queueCommand(
           	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintHi", 0),
           	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
           		}},
           	new Step() {
           		@Override
           		public void execute(RequestMonitor rm) {
           	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
           	    	
           	        fGDBCtrl.queueCommand(
           	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintBonjour", 0),
           	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
           		}}
        };
        
    	// The target is currently stopped so we resume it
        ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
        		getGDBLaunch().getSession(),
        		ISuspendedDMEvent.class);

    	SyncUtil.resume();

        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(DataRequestMonitor<Boolean> rm) {
				fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps, rm);				
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		fail(e.getCause().getMessage());
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	// Now resume the target three times and check that we stop three times.
    	for (int i=0; i<steps.length; i++) {
    		// Wait up to 3 second for the target to suspend. Should happen within two seconds.
    		suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));

    		suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
            		getGDBLaunch().getSession(),
            		ISuspendedDMEvent.class);

        	SyncUtil.resume();

    	}
    }
    
    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for a single operation with multiple steps when the target is running
     * and one of the steps fails. 
     */
    @Test
    public void executeMultiStepSingleOpWhileTargetRunningWithError() throws Throwable {
        // Multiple steps that will set three temp breakpoints at three different lines
        // We then check that the target will stop three times
    	final Step[] steps = new Step[] {
        	new Step() {
        		@Override
        		public void execute(RequestMonitor rm) {
        	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
        	    	
        	        fGDBCtrl.queueCommand(
        	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintHello", 0),
        	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
        		}},
           	new Step() {
           		@Override
           		public void execute(RequestMonitor rm) {
           	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
           	    	
           	        fGDBCtrl.queueCommand(
           	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, "invalid condition", 0, "PrintHi", 0),
           	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
           		}},
           	new Step() {
           		@Override
           		public void execute(RequestMonitor rm) {
           	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
           	    	
           	        fGDBCtrl.queueCommand(
           	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, "PrintBonjour", 0),
           	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
           		}}
        };
        
    	// The target is currently stopped so we resume it
        ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
        		getGDBLaunch().getSession(),
        		ISuspendedDMEvent.class);

    	SyncUtil.resume();

        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(DataRequestMonitor<Boolean> rm) {
				fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps, rm);				
			}
        };
        
        boolean caughtError = false;
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		caughtError = true;
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	Assert.assertTrue("Did not catch the error of the step", caughtError);
    	
    	// Now make sure the target stop of the first breakpoint
  		// Wait up to 3 second for the target to suspend. Should happen within two seconds.
   		suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));
    }

    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for concurrent operations with a single step when the target is stopped. 
     */
    @Test
    public void executeSingleStepConcurrentOpWhileTargetStopped() throws Throwable {
    	// The target is currently stopped.
 
    	final int NUM_CONCURRENT = 3;
    	
    	String[] locations = { "PrintHello", "PrintHi", "PrintBonjour" };
    	final Step[][] steps = new Step[NUM_CONCURRENT][1]; // one step for each concurrent operation
    	for (int i=0; i<steps.length; i++) {
    		final String location = locations[i];
           	steps[i] = new Step[] {
           			new Step() {
           		@Override
           		public void execute(RequestMonitor rm) {
           	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
           	    	
           	        fGDBCtrl.queueCommand(
           	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, location, 0),
           	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
           		}}
          };
    	}
            
        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(final DataRequestMonitor<Boolean> rm) {
				CountingRequestMonitor crm = new CountingRequestMonitor(fGDBCtrl.getExecutor(), null) {
					@Override
					protected void handleCompleted() {
						rm.done();
					};
				};
				

				int index;
				for (index=0; index<steps.length; index++) {
					fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps[index], crm);
				}
				
				crm.setDoneCount(index);
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		fail(e.getCause().getMessage());
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	for (int i=0; i<steps.length; i++) {
    		// Now resume the target and check that we stop at all the breakpoints.
    		ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
    				getGDBLaunch().getSession(),
    				ISuspendedDMEvent.class);

    		SyncUtil.resume();

    		// Wait up to 3 second for the target to suspend. Should happen within 2 second.
    		suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));
    	}
    }
    
    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for concurrent operations with a single step when the target is running. 
     */
    @Test
    public void executeSingleStepConcurrentOpWhileTargetRunning() throws Throwable { 
    	final int NUM_CONCURRENT = 3;
    	
    	String[] locations = { "PrintHello", "PrintHi", "PrintBonjour" };
    	final Step[][] steps = new Step[NUM_CONCURRENT][1]; // one step for each concurrent operation
    	for (int i=0; i<steps.length; i++) {
    		final String location = locations[i];
           	steps[i] = new Step[] {
           			new Step() {
           		@Override
           		public void execute(RequestMonitor rm) {
           	        IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);
           	    	
           	        fGDBCtrl.queueCommand(
           	        		fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, location, 0),
           	        		new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm));
           		}}
          };
    	}
            
    	// The target is currently stopped so we resume it
        ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
        		getGDBLaunch().getSession(),
        		ISuspendedDMEvent.class);

    	SyncUtil.resume();

        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(final DataRequestMonitor<Boolean> rm) {
				CountingRequestMonitor crm = new CountingRequestMonitor(fGDBCtrl.getExecutor(), null) {
					@Override
					protected void handleCompleted() {
						rm.done();
					};
				};
				

				int index;
				for (index=0; index<steps.length; index++) {
					fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps[index], crm);
				}
				
				crm.setDoneCount(index);
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		fail(e.getCause().getMessage());
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	for (int i=0; i<steps.length; i++) {
    		// Wait up to 3 second for the target to suspend. Should happen within 2 seconds.
    		suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));

    		// Now resume the target and check that we stop at all the breakpoints.
    		suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
    				getGDBLaunch().getSession(),
    				ISuspendedDMEvent.class);

    		SyncUtil.resume();
    	}
    }
    
    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for concurrent operations with a single step when the target is stopped. 
     * This tests verifies that we properly handle concurrent operations that are sent
     * while other operations are already being run.
     */
    @Test
    public void executeSingleStepConcurrentButDelayedOpWhileTargetStopped() throws Throwable {
    	// The target is currently stopped.

    	final String location = "PrintHello";
    	final String location2 = "PrintHi";
    	final Step[] steps = new  Step[] {
    			new Step() {
    				@Override
    				public void execute(final RequestMonitor rm) {
    					final IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);

    					fGDBCtrl.queueCommand(
    							fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, location, 0),
    							new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm) {
    								@Override
    								protected void handleSuccess() {
    									// Now that time has elapsed, send another command
    									fRunCtrl.executeWithTargetAvailable(fContainerDmc, new Step[] {
    											new Step() {
    												@Override
    												public void execute(final RequestMonitor rm) {
    													fGDBCtrl.queueCommand(
    															fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, location2, 0),
    															new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), null));
    												}}}, new RequestMonitor(fGDBCtrl.getExecutor(), null));

    									// Complete the first operation because the two are supposed to be independent
    									rm.done();
    								}});
    				}}
          };
            
        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(final DataRequestMonitor<Boolean> rm) {
				fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps, rm);				
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		fail(e.getCause().getMessage());
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	for (int i=0; i<2; i++) {
    	   	// The target is currently stopped so we resume it
            ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
            		getGDBLaunch().getSession(),
            		ISuspendedDMEvent.class);

        	SyncUtil.resume();

    		// Wait up to 3 second for the target to suspend. Should happen within 2 seconds.
    		suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));
    	}
    }
    
    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for concurrent operations with a single step when the target is running. 
     * This tests verifies that we properly handle concurrent operations that are sent
     * while other operations are already being run.
     */
    @Test
    public void executeSingleStepConcurrentButDelayedOpWhileTargetRunning() throws Throwable {    	
    	final String location = "PrintHello";
    	final String location2 = "PrintHi";
    	final Step[] steps = new  Step[] {
    			new Step() {
    				@Override
    				public void execute(final RequestMonitor rm) {
    					final IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);

    					fGDBCtrl.queueCommand(
    							fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, location, 0),
    							new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm) {
    								@Override
    								protected void handleSuccess() {
    									// Now that time has elapsed, send another command
    									fRunCtrl.executeWithTargetAvailable(fContainerDmc, new Step[] {
    											new Step() {
    												@Override
    												public void execute(final RequestMonitor otherRm) {
    													fGDBCtrl.queueCommand(
    															fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, location2, 0),
    															new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), otherRm));
    												}}}, new RequestMonitor(fGDBCtrl.getExecutor(), null));

    									// Complete the first operation because the two are supposed to be independent
    									rm.done();
    								}});
    				}}
          };
            
    	// The target is currently stopped so we resume it
        ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
        		getGDBLaunch().getSession(),
        		ISuspendedDMEvent.class);

    	SyncUtil.resume();

        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(final DataRequestMonitor<Boolean> rm) {
				fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps, rm);				
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		fail(e.getCause().getMessage());
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	for (int i=0; i<2; i++) {
    		// Wait up to 3 second for the target to suspend. Should happen within 2 seconds.
    		suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));

    		// Now resume the target and check that we stop at all the breakpoints.
    		suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
    				getGDBLaunch().getSession(),
    				ISuspendedDMEvent.class);

    		SyncUtil.resume();
    	}
    }

    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for concurrent operations with a single step when the target is stopped. 
     * This tests verifies that we properly handle concurrent operations that are
     * dependent on each other; this means that the second operation needs to complete
     * for the second one to complete.
     */
    @Test
    public void executeSingleStepConcurrentAndDependentOpWhileTargetStopped() throws Throwable {
    	// The target is currently stopped.

    	final String location = "PrintHello";
    	final String location2 = "PrintHi";
    	final Step[] steps = new  Step[] {
    			new Step() {
    				@Override
    				public void execute(final RequestMonitor rm) {
    					final IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);

    					fGDBCtrl.queueCommand(
    							fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, location, 0),
    							new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm) {
    								@Override
    								protected void handleSuccess() {
    									// Send another such operation and wait for it to complete to mark the original one as completed
    									fRunCtrl.executeWithTargetAvailable(fContainerDmc, new Step[] {
    											new Step() {
    												@Override
    												public void execute(final RequestMonitor otherRm) {
    													fGDBCtrl.queueCommand(
    															fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, location2, 0),
    															new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), otherRm));
    												}}}, rm);
    								}});
    				}}
          };
            
        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(final DataRequestMonitor<Boolean> rm) {
				fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps, rm);				
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		fail(e.getCause().getMessage());
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	for (int i=0; i<2; i++) {
    	   	// The target is currently stopped so we resume it
            ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
            		getGDBLaunch().getSession(),
            		ISuspendedDMEvent.class);

        	SyncUtil.resume();

    		// Wait up to 3 second for the target to suspend. Should happen within 2 seconds.
    		suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));
    	}
    }
    
    /**
     * Test that the executeWhileTargetAvailale interface works properly
     * for concurrent operations with a single step when the target is running. 
     * This tests verifies that we properly handle concurrent operations that are
     * dependent on each other; this means that the second operation needs to complete
     * for the second one to complete.
     */
    @Test
    public void executeSingleStepConcurrentAndDependentOpWhileTargetRunning() throws Throwable {    	
    	final String location = "PrintHello";
    	final String location2 = "PrintHi";
    	final Step[] steps = new  Step[] {
    			new Step() {
    				@Override
    				public void execute(final RequestMonitor rm) {
    					final IBreakpointsTargetDMContext bpTargetDmc = DMContexts.getAncestorOfType(fContainerDmc, IBreakpointsTargetDMContext.class);

    					fGDBCtrl.queueCommand(
    							fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, location, 0),
    							new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), rm) {
    								@Override
    								protected void handleSuccess() {
    									// Send another such operation and wait for it to complete to mark the original one as completed
    									fRunCtrl.executeWithTargetAvailable(fContainerDmc, new Step[] {
    											new Step() {
    												@Override
    												public void execute(final RequestMonitor otherRm) {
    													fGDBCtrl.queueCommand(
    															fGDBCtrl.getCommandFactory().createMIBreakInsert(bpTargetDmc, true, false, null, 0, location2, 0),
    															new DataRequestMonitor<MIBreakInsertInfo> (fGDBCtrl.getExecutor(), otherRm));
    												}}}, rm);
    								}});
    				}}
          };
            
    	// The target is currently stopped so we resume it
        ServiceEventWaitor<ISuspendedDMEvent> suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
        		getGDBLaunch().getSession(),
        		ISuspendedDMEvent.class);

    	SyncUtil.resume();

        Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(final DataRequestMonitor<Boolean> rm) {
				fRunCtrl.executeWithTargetAvailable(fContainerDmc, steps, rm);				
			}
        };
    	try {
    		fRunCtrl.getExecutor().execute(query);
    		query.get(500, TimeUnit.MILLISECONDS);
    	} catch (InterruptedException e) {
    		fail(e.getMessage());
    	} catch (ExecutionException e) {
    		fail(e.getCause().getMessage());
    	} catch (TimeoutException e) {
    		fail(TIMEOUT_MESSAGE);
    	}
    	
    	for (int i=0; i<2; i++) {
    		// Wait up to 3 second for the target to suspend. Should happen within 2 seconds.
    		suspendedEventWaitor.waitForEvent(TestsPlugin.massageTimeout(3000));

    		// Now resume the target and check that we stop at all the breakpoints.
    		suspendedEventWaitor = new ServiceEventWaitor<ISuspendedDMEvent>(
    				getGDBLaunch().getSession(),
    				ISuspendedDMEvent.class);

    		SyncUtil.resume();
    	}
    }
}




/*******************************************************************************
 * Copyright (c) 2011 Ericsson 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:
 *     Ericsson	AB		  - Initial implementation of Test cases
 *******************************************************************************/
package org.eclipse.cdt.tests.dsf.gdb.tests.tests_6_6;


import org.eclipse.cdt.tests.dsf.gdb.framework.BackgroundRunner;
import org.eclipse.cdt.tests.dsf.gdb.tests.ITestConstants;
import org.eclipse.cdt.tests.dsf.gdb.tests.MIRunControlTargetAvailableTest;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;

@RunWith(BackgroundRunner.class)
public class MIRunControlTargetAvailableTest_6_6 extends MIRunControlTargetAvailableTest {
	@BeforeClass
    public static void beforeClassMethod_6_6() {
		setGdbProgramNamesLaunchAttributes(ITestConstants.SUFFIX_GDB_6_6);
	}
}

Lines 28-33 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_6_6/Suite_6_6.java (+1 lines)
28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
29	MIRegistersTest_6_6.class,	29	MIRegistersTest_6_6.class,
30	MIRunControlTest_6_6.class,	30	MIRunControlTest_6_6.class,
		31	MIRunControlTargetAvailableTest_6_6.class,
31	MIExpressionsTest_6_6.class,	32	MIExpressionsTest_6_6.class,
32	MIMemoryTest_6_6.class,	33	MIMemoryTest_6_6.class,
33	MIBreakpointsTest_6_6.class,	34	MIBreakpointsTest_6_6.class,

Lines 32-37 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_6_6/Suite_Remote_6_6.java (+1 lines)
32	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	32	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
33	MIRegistersTest_6_6.class,	33	MIRegistersTest_6_6.class,
34	MIRunControlTest_6_6.class,	34	MIRunControlTest_6_6.class,
		35	MIRunControlTargetAvailableTest_6_6.class,
35	MIExpressionsTest_6_6.class,	36	MIExpressionsTest_6_6.class,
36	MIMemoryTest_6_6.class,	37	MIMemoryTest_6_6.class,
37	MIBreakpointsTest_6_6.class,	38	MIBreakpointsTest_6_6.class,




/*******************************************************************************
 * Copyright (c) 2011 Ericsson 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:
 *     Ericsson	AB		  - Initial implementation of Test cases
 *******************************************************************************/
package org.eclipse.cdt.tests.dsf.gdb.tests.tests_6_7;


import org.eclipse.cdt.tests.dsf.gdb.framework.BackgroundRunner;
import org.eclipse.cdt.tests.dsf.gdb.tests.ITestConstants;
import org.eclipse.cdt.tests.dsf.gdb.tests.tests_6_6.MIRunControlTargetAvailableTest_6_6;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;

@RunWith(BackgroundRunner.class)
public class MIRunControlTargetAvailableTest_6_7 extends MIRunControlTargetAvailableTest_6_6 {
	@BeforeClass
    public static void beforeClassMethod_6_7() {
		setGdbProgramNamesLaunchAttributes(ITestConstants.SUFFIX_GDB_6_7);
	}
}

Lines 28-33 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_6_7/Suite_6_7.java (+1 lines)
28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
29	MIRegistersTest_6_7.class,	29	MIRegistersTest_6_7.class,
30	MIRunControlTest_6_7.class,	30	MIRunControlTest_6_7.class,
		31	MIRunControlTargetAvailableTest_6_7.class,
31	MIExpressionsTest_6_7.class,	32	MIExpressionsTest_6_7.class,
32	MIMemoryTest_6_7.class,	33	MIMemoryTest_6_7.class,
33	MIBreakpointsTest_6_7.class,	34	MIBreakpointsTest_6_7.class,

Lines 32-37 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_6_7/Suite_Remote_6_7.java (+1 lines)
32	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	32	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
33	MIRegistersTest_6_7.class,	33	MIRegistersTest_6_7.class,
34	MIRunControlTest_6_7.class,	34	MIRunControlTest_6_7.class,
		35	MIRunControlTargetAvailableTest_6_7.class,
35	MIExpressionsTest_6_7.class,	36	MIExpressionsTest_6_7.class,
36	MIMemoryTest_6_7.class,	37	MIMemoryTest_6_7.class,
37	MIBreakpointsTest_6_7.class,	38	MIBreakpointsTest_6_7.class,




/*******************************************************************************
 * Copyright (c) 2011 Ericsson 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:
 *     Ericsson	AB		  - Initial implementation of Test cases
 *******************************************************************************/
package org.eclipse.cdt.tests.dsf.gdb.tests.tests_6_8;


import org.eclipse.cdt.tests.dsf.gdb.framework.BackgroundRunner;
import org.eclipse.cdt.tests.dsf.gdb.tests.ITestConstants;
import org.eclipse.cdt.tests.dsf.gdb.tests.tests_6_7.MIRunControlTargetAvailableTest_6_7;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;

@RunWith(BackgroundRunner.class)
public class MIRunControlTargetAvailableTest_6_8 extends MIRunControlTargetAvailableTest_6_7 {
	@BeforeClass
    public static void beforeClassMethod_6_8() {
		setGdbProgramNamesLaunchAttributes(ITestConstants.SUFFIX_GDB_6_8);
	}
}

Lines 28-33 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_6_8/Suite_6_8.java (+1 lines)
28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
29	MIRegistersTest_6_8.class,	29	MIRegistersTest_6_8.class,
30	MIRunControlTest_6_8.class,	30	MIRunControlTest_6_8.class,
		31	MIRunControlTargetAvailableTest_6_8.class,
31	MIExpressionsTest_6_8.class,	32	MIExpressionsTest_6_8.class,
32	MIMemoryTest_6_8.class,	33	MIMemoryTest_6_8.class,
33	MIBreakpointsTest_6_8.class,	34	MIBreakpointsTest_6_8.class,

Lines 32-37 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_6_8/Suite_Remote_6_8.java (+1 lines)
32	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	32	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
33	MIRegistersTest_6_8.class,	33	MIRegistersTest_6_8.class,
34	MIRunControlTest_6_8.class,	34	MIRunControlTest_6_8.class,
		35	MIRunControlTargetAvailableTest_6_8.class,
35	MIExpressionsTest_6_8.class,	36	MIExpressionsTest_6_8.class,
36	MIMemoryTest_6_8.class,	37	MIMemoryTest_6_8.class,
37	MIBreakpointsTest_6_8.class,	38	MIBreakpointsTest_6_8.class,




/*******************************************************************************
 * Copyright (c) 2011 Ericsson 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:
 *     Ericsson	AB		  - Initial implementation of Test cases
 *******************************************************************************/
package org.eclipse.cdt.tests.dsf.gdb.tests.tests_7_0;


import org.eclipse.cdt.tests.dsf.gdb.framework.BackgroundRunner;
import org.eclipse.cdt.tests.dsf.gdb.tests.ITestConstants;
import org.eclipse.cdt.tests.dsf.gdb.tests.tests_6_8.MIRunControlTargetAvailableTest_6_8;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;

@RunWith(BackgroundRunner.class)
public class MIRunControlTargetAvailableTest_7_0 extends MIRunControlTargetAvailableTest_6_8 {
	@BeforeClass
    public static void beforeClassMethod_7_0() {
		setGdbProgramNamesLaunchAttributes(ITestConstants.SUFFIX_GDB_7_0);
	}
}

Lines 28-33 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_7_0/Suite_7_0.java (+1 lines)
28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
29	MIRegistersTest_7_0.class,	29	MIRegistersTest_7_0.class,
30	MIRunControlTest_7_0.class,	30	MIRunControlTest_7_0.class,
		31	MIRunControlTargetAvailableTest_7_0.class,
31	MIExpressionsTest_7_0.class,	32	MIExpressionsTest_7_0.class,
32	MIMemoryTest_7_0.class,	33	MIMemoryTest_7_0.class,
33	MIBreakpointsTest_7_0.class,	34	MIBreakpointsTest_7_0.class,

Lines 32-37 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_7_0/Suite_Remote_7_0.java (+1 lines)
32	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	32	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
33	GDBRemoteTracepointsTest_7_0.class,	33	GDBRemoteTracepointsTest_7_0.class,
34	MIRegistersTest_7_0.class,	34	MIRegistersTest_7_0.class,
		35	MIRunControlTargetAvailableTest_7_0.class,
35	MIRunControlTest_7_0.class,	36	MIRunControlTest_7_0.class,
36	MIExpressionsTest_7_0.class,	37	MIExpressionsTest_7_0.class,
37	MIMemoryTest_7_0.class,	38	MIMemoryTest_7_0.class,




/*******************************************************************************
 * Copyright (c) 2011 Ericsson 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:
 *     Ericsson	AB		  - Initial implementation of Test cases
 *******************************************************************************/
package org.eclipse.cdt.tests.dsf.gdb.tests.tests_7_1;


import org.eclipse.cdt.tests.dsf.gdb.framework.BackgroundRunner;
import org.eclipse.cdt.tests.dsf.gdb.tests.ITestConstants;
import org.eclipse.cdt.tests.dsf.gdb.tests.tests_7_0.MIRunControlTargetAvailableTest_7_0;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;

@RunWith(BackgroundRunner.class)
public class MIRunControlTargetAvailableTest_7_1 extends MIRunControlTargetAvailableTest_7_0 {
	@BeforeClass
    public static void beforeClassMethod_7_1() {
		setGdbProgramNamesLaunchAttributes(ITestConstants.SUFFIX_GDB_7_1);
	}
}

Lines 28-33 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_7_1/Suite_7_1.java (+1 lines)
28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
29	MIRegistersTest_7_1.class,	29	MIRegistersTest_7_1.class,
30	MIRunControlTest_7_1.class,	30	MIRunControlTest_7_1.class,
		31	MIRunControlTargetAvailableTest_7_1.class,
31	MIExpressionsTest_7_1.class,	32	MIExpressionsTest_7_1.class,
32	MIMemoryTest_7_1.class,	33	MIMemoryTest_7_1.class,
33	MIBreakpointsTest_7_1.class,	34	MIBreakpointsTest_7_1.class,

Lines 32-37 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_7_1/Suite_Remote_7_1.java (+1 lines)
32	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	32	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
33	GDBRemoteTracepointsTest_7_1.class,	33	GDBRemoteTracepointsTest_7_1.class,
34	MIRegistersTest_7_1.class,	34	MIRegistersTest_7_1.class,
		35	MIRunControlTargetAvailableTest_7_1.class,
35	MIRunControlTest_7_1.class,	36	MIRunControlTest_7_1.class,
36	MIExpressionsTest_7_1.class,	37	MIExpressionsTest_7_1.class,
37	MIMemoryTest_7_1.class,	38	MIMemoryTest_7_1.class,




/*******************************************************************************
 * Copyright (c) 2011 Ericsson 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:
 *     Ericsson	AB		  - Initial implementation of Test cases
 *******************************************************************************/
package org.eclipse.cdt.tests.dsf.gdb.tests.tests_7_2;


import org.eclipse.cdt.tests.dsf.gdb.framework.BackgroundRunner;
import org.eclipse.cdt.tests.dsf.gdb.tests.ITestConstants;
import org.eclipse.cdt.tests.dsf.gdb.tests.tests_7_1.MIRunControlTargetAvailableTest_7_1;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;

@RunWith(BackgroundRunner.class)
public class MIRunControlTargetAvailableTest_7_2 extends MIRunControlTargetAvailableTest_7_1 {
	@BeforeClass
    public static void beforeClassMethod_7_2() {
		setGdbProgramNamesLaunchAttributes(ITestConstants.SUFFIX_GDB_7_2);
	}
}

Lines 28-33 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_7_2/Suite_7_2.java (+1 lines)
28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256	28	// We need specific name for the tests of this suite, because of bug https://bugs.eclipse.org/172256
29	MIRegistersTest_7_2.class,	29	MIRegistersTest_7_2.class,
30	MIRunControlTest_7_2.class,	30	MIRunControlTest_7_2.class,
		31	MIRunControlTargetAvailableTest_7_2.class,
31	MIExpressionsTest_7_2.class,	32	MIExpressionsTest_7_2.class,
32	MIMemoryTest_7_2.class,	33	MIMemoryTest_7_2.class,
33	MIBreakpointsTest_7_2.class,	34	MIBreakpointsTest_7_2.class,

Lines 33-38 Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_7_2/Suite_Remote_7_2.java (+1 lines)
33	GDBRemoteTracepointsTest_7_2.class,	33	GDBRemoteTracepointsTest_7_2.class,
34	MIRegistersTest_7_2.class,	34	MIRegistersTest_7_2.class,
35	MIRunControlTest_7_2.class,	35	MIRunControlTest_7_2.class,
		36	MIRunControlTargetAvailableTest_7_2.class,
36	MIExpressionsTest_7_2.class,	37	MIExpressionsTest_7_2.class,
37	MIMemoryTest_7_2.class,	38	MIMemoryTest_7_2.class,
38	MIBreakpointsTest_7_2.class,	39	MIBreakpointsTest_7_2.class,

Return to bug 337893

Added Link Here

(-)data/launch/src/TargetAvail.cc (+45 lines)
1
2	#include <stdio.h>
3	#include "Sleep.h"
4
5
6	void PrintHello()
7	{
8	printf("Hello World!\n");
9
10	SLEEP(1);
11
12	}
13
14	void PrintHi()
15	{
16	printf("Hi everybody!\n");
17
18	SLEEP(1);
19
20	}
21
22	void PrintBonjour()
23	{
24	printf("Bonjour!\n");
25
26	SLEEP(1);
27
28	}
29
30	int main(int argc, char *argv[])
31	{
32	printf("In main\n");
33
34	SLEEP(1);
35
36	SLEEP(1);
37
38	PrintHello();
39
40	PrintHi();
41
42	PrintBonjour();
43
44	return 0;
45	}

Added Link Here

(-)src/org/eclipse/cdt/tests/dsf/gdb/tests/tests_6_6/MIRunControlTargetAvailableTest_6_6.java (+26 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 Ericsson and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Ericsson AB - Initial implementation of Test cases
10	*******************************************************************************/
11	package org.eclipse.cdt.tests.dsf.gdb.tests.tests_6_6;
12
13
14	import org.eclipse.cdt.tests.dsf.gdb.framework.BackgroundRunner;
15	import org.eclipse.cdt.tests.dsf.gdb.tests.ITestConstants;
16	import org.eclipse.cdt.tests.dsf.gdb.tests.MIRunControlTargetAvailableTest;
17	import org.junit.BeforeClass;
18	import org.junit.runner.RunWith;
19
20	@RunWith(BackgroundRunner.class)
21	public class MIRunControlTargetAvailableTest_6_6 extends MIRunControlTargetAvailableTest {
22	@BeforeClass
23	public static void beforeClassMethod_6_6() {
24	setGdbProgramNamesLaunchAttributes(ITestConstants.SUFFIX_GDB_6_6);
25	}
26	}