dsf-gdb/org.eclipse.cdt.tests.dsf.gdb/src/org/eclipse/cdt/tests/dsf/gdb/tests/GDBConsoleSynchronizingTest.java - cdt/org.eclipse.cdt - Git at Google

 /*******************************************************************************
  * Copyright (c) 2013, 2015 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:
  * Marc Khouzam (Ericsson) - Initial API and implementation
  *******************************************************************************/

 package org.eclipse.cdt.tests.dsf.gdb.tests;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;

 import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants;
 import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
 import org.eclipse.cdt.dsf.concurrent.ImmediateRequestMonitor;
 import org.eclipse.cdt.dsf.concurrent.Query;
 import org.eclipse.cdt.dsf.datamodel.DMContexts;
 import org.eclipse.cdt.dsf.datamodel.IDMContext;
 import org.eclipse.cdt.dsf.datamodel.IDMEvent;
 import org.eclipse.cdt.dsf.debug.service.IExpressions;
 import org.eclipse.cdt.dsf.debug.service.IExpressions.IExpressionDMAddress;
 import org.eclipse.cdt.dsf.debug.service.IExpressions.IExpressionDMContext;
 import org.eclipse.cdt.dsf.debug.service.IFormattedValues;
 import org.eclipse.cdt.dsf.debug.service.IMemory;
 import org.eclipse.cdt.dsf.debug.service.IMemory.IMemoryChangedEvent;
 import org.eclipse.cdt.dsf.debug.service.IMemory.IMemoryDMContext;
 import org.eclipse.cdt.dsf.debug.service.IRunControl;
 import org.eclipse.cdt.dsf.debug.service.IStack.IFrameDMContext;
 import org.eclipse.cdt.dsf.gdb.service.IReverseRunControl;
 import org.eclipse.cdt.dsf.gdb.service.IReverseRunControl.IReverseModeChangedDMEvent;
 import org.eclipse.cdt.dsf.gdb.service.command.IGDBControl;
 import org.eclipse.cdt.dsf.mi.service.command.events.MIStoppedEvent;
 import org.eclipse.cdt.dsf.mi.service.command.output.MIInfo;
 import org.eclipse.cdt.dsf.service.DsfServiceEventHandler;
 import org.eclipse.cdt.dsf.service.DsfServicesTracker;
 import org.eclipse.cdt.dsf.service.DsfSession;
 import org.eclipse.cdt.tests.dsf.gdb.framework.BaseParametrizedTestCase;
 import org.eclipse.cdt.tests.dsf.gdb.framework.SyncUtil;
 import org.eclipse.cdt.tests.dsf.gdb.launching.TestsPlugin;
 import org.eclipse.debug.core.model.MemoryByte;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;

 /**
  * This test case verifies that different commands issued from the
  * GDB console cause proper updating within the CDT views.
  */
 @RunWith(Parameterized.class)
 public class GDBConsoleSynchronizingTest extends BaseParametrizedTestCase {
 	final static private String EXEC_NAME = "ConsoleSyncTestApp.exe";

 	final static private int DEFAULT_TIMEOUT = TestsPlugin.massageTimeout(1000);
 	final static private TimeUnit DEFAULT_TIME_UNIT = TimeUnit.MILLISECONDS;
 	final static private String NEW_VAR_VALUE = "0x12345678";
 	final static private int NEW_VAR_SIZE = 4; // The number of bytes of NEW_VAR_VALUE
 	final static private byte[] NEW_MEM = { 0x12, 0x34, 0x56, 0x78 }; // The individual bytes of NEW_VAR_VALUE

 	private DsfSession fSession;
 	private DsfServicesTracker fServicesTracker;
 	private IGDBControl fCommandControl;
 	private IMemory fMemoryService;
 	private IExpressions fExprService;
 	private IRunControl fRunControl;

 	private List<IDMEvent<? extends IDMContext>> fEventsReceived = new ArrayList<IDMEvent<? extends IDMContext>>();

     @Override
     protected void setLaunchAttributes() {
     	super.setLaunchAttributes();
     	setLaunchAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME, EXEC_PATH + EXEC_NAME);
     }

     @Override
     public void doBeforeTest() throws Exception {
     	assumeGdbVersionAtLeast(ITestConstants.SUFFIX_GDB_7_6);
     	super.doBeforeTest();

     	fSession = getGDBLaunch().getSession();
         Runnable runnable = new Runnable() {
             @Override
 			public void run() {
                 fServicesTracker = new DsfServicesTracker(TestsPlugin.getBundleContext(), fSession.getId());
                 Assert.assertTrue(fServicesTracker != null);

                 fCommandControl = fServicesTracker.getService(IGDBControl.class);
                 Assert.assertTrue(fCommandControl != null);

                 fMemoryService = fServicesTracker.getService(IMemory.class);
                 Assert.assertTrue(fMemoryService != null);

                 fExprService = fServicesTracker.getService(IExpressions.class);
                 Assert.assertTrue(fExprService != null);

                 fRunControl = fServicesTracker.getService(IRunControl.class);
                 Assert.assertTrue(fRunControl != null);

                 // Register to breakpoint events
                 fSession.addServiceEventListener(GDBConsoleSynchronizingTest.this, null);
             }
         };
         fSession.getExecutor().submit(runnable).get();
     }

     @Override
     public void doAfterTest() throws Exception {
 		if (fSession != null) {
 			fSession.getExecutor().submit(() -> fSession.removeServiceEventListener(GDBConsoleSynchronizingTest.this))
 					.get();
 		}
         fEventsReceived.clear();
         if (fServicesTracker!=null) fServicesTracker.dispose();
         super.doAfterTest();
     }

 	//////////////////////////////////////////////////////////////////////////////////////
 	// Start of tests
 	//////////////////////////////////////////////////////////////////////////////////////

     /**
      * This test verifies that setting a variable from the console
      * using the set command will properly trigger a DSF event to
      * indicate the change.  This test makes sure the value that
      * changes is in the memory cache also.
      */
 	@Test
 	public void testSettingVariableWithSetWithMemory() throws Throwable {
         MIStoppedEvent stoppedEvent = SyncUtil.runToLocation("testMemoryChanges");

         final IFrameDMContext frameDmc = SyncUtil.getStackFrame(stoppedEvent.getDMContext(), 0);
         final IExpressionDMContext exprDmc = SyncUtil.createExpression(frameDmc, "i");

         // Read the memory that will change first, or else there will be no event for it
 		Query<IExpressionDMAddress> query = new Query<IExpressionDMAddress>() {
 			@Override
 			protected void execute(final DataRequestMonitor<IExpressionDMAddress> rm) {
 				fExprService.getExpressionAddressData(exprDmc, rm);
 			}
 		};

 		fSession.getExecutor().execute(query);
 		IExpressionDMAddress data = query.get();

         IMemoryDMContext memoryDmc = DMContexts.getAncestorOfType(frameDmc, IMemoryDMContext.class);
         SyncUtil.readMemory(memoryDmc, data.getAddress(), 0, 1, NEW_VAR_SIZE);

         fEventsReceived.clear();

         String newValue = NEW_VAR_VALUE;
         queueConsoleCommand("set variable i=" + newValue);

         IMemoryChangedEvent memoryEvent = waitForEvent(IMemoryChangedEvent.class);
         assertEquals(1, memoryEvent.getAddresses().length);
         assertEquals(data.getAddress(), memoryEvent.getAddresses()[0]);

         // Now verify the memory service knows the new memory value
         MemoryByte[] memory = SyncUtil.readMemory(memoryDmc, data.getAddress(), 0, 1, NEW_VAR_SIZE);
         assertEquals(NEW_VAR_SIZE, memory.length);
         for (int i=0; i<NEW_VAR_SIZE; i++) {
         	if (memory[0].isBigEndian()) {
         		assertEquals(NEW_MEM[i], memory[i].getValue());
         	} else {
         		assertEquals(NEW_MEM[i], memory[NEW_VAR_SIZE-1-i].getValue());
         	}
         }

         // Now verify the expressions service knows the new value
         String exprValue = SyncUtil.getExpressionValue(exprDmc, IFormattedValues.HEX_FORMAT);
         assertEquals(newValue, exprValue);
 	}

 	private void testSettingVariableWithCommon(String commandPrefix) throws Throwable {
 		MIStoppedEvent stoppedEvent = SyncUtil.runToLocation("testMemoryChanges");

 		final IFrameDMContext frameDmc = SyncUtil.getStackFrame(stoppedEvent.getDMContext(), 0);
 		final IExpressionDMContext exprDmc = SyncUtil.createExpression(frameDmc, "i");

 		// Read the memory that will change first, or else there will be no event for it
 		Query<IExpressionDMAddress> query = new Query<IExpressionDMAddress>() {
 			@Override
 			protected void execute(final DataRequestMonitor<IExpressionDMAddress> rm) {
 				fExprService.getExpressionAddressData(exprDmc, rm);
 			}
 		};

 		fSession.getExecutor().execute(query);
 		IExpressionDMAddress data = query.get();

 		fEventsReceived.clear();

 		final String newValue = NEW_VAR_VALUE;
 		queueConsoleCommand(commandPrefix + " = " + newValue);

 		IMemoryChangedEvent memoryEvent = waitForEvent(IMemoryChangedEvent.class);
 		assertEquals(1, memoryEvent.getAddresses().length);
 		assertEquals(data.getAddress(), memoryEvent.getAddresses()[0]);

 		// Now verify the memory service knows the new memory value
 		IMemoryDMContext memoryDmc = DMContexts.getAncestorOfType(frameDmc, IMemoryDMContext.class);
 		MemoryByte[] memory = SyncUtil.readMemory(memoryDmc, data.getAddress(), 0, 1, NEW_VAR_SIZE);
 		assertEquals(NEW_VAR_SIZE, memory.length);
 		for (int i=0; i<NEW_VAR_SIZE; i++) {
 			if (memory[0].isBigEndian()) {
 				assertEquals(NEW_MEM[i], memory[i].getValue());
 			} else {
 				assertEquals(NEW_MEM[i], memory[NEW_VAR_SIZE-1-i].getValue());
 			}
 		}

 		// Now verify the expressions service knows the new value
 		String exprValue = SyncUtil.getExpressionValue(exprDmc, IFormattedValues.HEX_FORMAT);
 		assertEquals(newValue, exprValue);
 	}

     /**
      * This test verifies that setting a variable from the console
      * using the set command will properly trigger a DSF event to
      * indicate the change, when the address is not in the memory cache.
      */
 	@Test
 	public void testSettingVariableWithSet() throws Throwable {
 		testSettingVariableWithCommon("set variable i");
 	}

     /**
      * This test verifies that setting a variable from the console
      * using the print command will properly trigger a DSF event
      * to indicate the change.
      */
 	@Test
 	public void testSettingVariableWithPrint() throws Throwable {
 		testSettingVariableWithCommon("print i");
 	}

 	/**
      * This test verifies that setting a memory location from the
      * console will properly trigger a DSF event to indicate the change.
      */
 	@Test
 	public void testSettingMemory() throws Throwable {
         MIStoppedEvent stoppedEvent = SyncUtil.runToLocation("testMemoryChanges");

         final IFrameDMContext frameDmc = SyncUtil.getStackFrame(stoppedEvent.getDMContext(), 0);
         final IExpressionDMContext exprDmc = SyncUtil.createExpression(frameDmc, "i");

         // Read the memory that will change first, or else there will be no event for it
         Query<IExpressionDMAddress> query = new Query<IExpressionDMAddress>() {
 			@Override
 			protected void execute(final DataRequestMonitor<IExpressionDMAddress> rm) {
 				fExprService.getExpressionAddressData(exprDmc, rm);
 			}
 		};

 		fSession.getExecutor().execute(query);
 		IExpressionDMAddress data = query.get();

         fEventsReceived.clear();

         final String newValue = NEW_VAR_VALUE;
         queueConsoleCommand("set {int}&i=" + newValue);

         IMemoryChangedEvent memoryEvent = waitForEvent(IMemoryChangedEvent.class);
         assertEquals(1, memoryEvent.getAddresses().length);
         assertEquals(data.getAddress(), memoryEvent.getAddresses()[0]);

         // Now verify the memory service knows the new memory value
         IMemoryDMContext memoryDmc = DMContexts.getAncestorOfType(frameDmc, IMemoryDMContext.class);
         MemoryByte[] memory = SyncUtil.readMemory(memoryDmc, data.getAddress(), 0, 1, NEW_VAR_SIZE);
         assertEquals(NEW_VAR_SIZE, memory.length);
         for (int i=0; i<NEW_VAR_SIZE; i++) {
         	if (memory[0].isBigEndian()) {
         		assertEquals(NEW_MEM[i], memory[i].getValue());
         	} else {
         		assertEquals(NEW_MEM[i], memory[NEW_VAR_SIZE-1-i].getValue());
         	}
         }

         // Now verify the expressions service knows the new value
         String exprValue = SyncUtil.getExpressionValue(exprDmc, IFormattedValues.HEX_FORMAT);
         assertEquals(newValue, exprValue);
 	}

 	/**
      * This test verifies that enabling reverse debugging from the
      * console will properly trigger a DSF event to indicate the change and
      * will be processed by the service.
      */
 	@Test
 	public void testEnableRecord() throws Throwable {
 		assertTrue("Reverse debugging is not supported", fRunControl instanceof IReverseRunControl);
 		final IReverseRunControl reverseService = (IReverseRunControl)fRunControl;

 		SyncUtil.runToLocation("testMemoryChanges");

 		// check starting state
 		Query<Boolean> query = new Query<Boolean>() {
 			@Override
 			protected void execute(final DataRequestMonitor<Boolean> rm) {
 				reverseService.isReverseModeEnabled(fCommandControl.getContext(), rm);
 			}
 		};

 		fSession.getExecutor().execute(query);
 		Boolean enabled = query.get();
 		assertTrue("Reverse debugging should not be enabled", !enabled);

         fEventsReceived.clear();

         queueConsoleCommand("record");

         // Wait for the event
         IReverseModeChangedDMEvent event = waitForEvent(IReverseModeChangedDMEvent.class);
         assertEquals(true, event.isReverseModeEnabled());

         // Check the service
         query = new Query<Boolean>() {
 			@Override
 			protected void execute(final DataRequestMonitor<Boolean> rm) {
 				reverseService.isReverseModeEnabled(fCommandControl.getContext(), rm);
 			}
 		};
 		fSession.getExecutor().execute(query);
 		enabled = query.get();
 		assertTrue("Reverse debugging should be enabled", enabled);
 	}

 	/**
      * This test verifies that disabling reverse debugging from the
      * console will properly trigger a DSF event to indicate the change and
      * will be processed by the service.
      */
 	@Test
 	public void testDisableRecord() throws Throwable {
 		assertTrue("Reverse debugging is not supported", fRunControl instanceof IReverseRunControl);
 		final IReverseRunControl reverseService = (IReverseRunControl)fRunControl;

 		SyncUtil.runToLocation("testMemoryChanges");

 		fEventsReceived.clear();

 		// check starting state
 		Query<Boolean> query = new Query<Boolean>() {
 			@Override
 			protected void execute(final DataRequestMonitor<Boolean> rm) {
 				reverseService.enableReverseMode(fCommandControl.getContext(), true,
 						                         new ImmediateRequestMonitor(rm) {
 					@Override
 					protected void handleSuccess() {
 						reverseService.isReverseModeEnabled(fCommandControl.getContext(), rm);
 					}
 				});
 			}
 		};

 		fSession.getExecutor().execute(query);
 		Boolean enabled = query.get();
 		assertTrue("Reverse debugging should be enabled", enabled);

         // Wait for the event to avoid confusing it with the next one
         IReverseModeChangedDMEvent event = waitForEvent(IReverseModeChangedDMEvent.class);
         assertEquals(true, event.isReverseModeEnabled());
 		fEventsReceived.clear();

         queueConsoleCommand("record stop");

         // Wait for the event
         event = waitForEvent(IReverseModeChangedDMEvent.class);
         assertEquals(false, event.isReverseModeEnabled());

         // Check the service
         query = new Query<Boolean>() {
 			@Override
 			protected void execute(final DataRequestMonitor<Boolean> rm) {
 				reverseService.isReverseModeEnabled(fCommandControl.getContext(), rm);
 			}
 		};
 		fSession.getExecutor().execute(query);
 		enabled = query.get();
 		assertTrue("Reverse debugging should not be enabled", !enabled);
 	}

 	//////////////////////////////////////////////////////////////////////////////////////
 	// End of tests
 	//////////////////////////////////////////////////////////////////////////////////////

   	@DsfServiceEventHandler
 	public void eventDispatched(IDMEvent<? extends IDMContext> e) {
   		synchronized(this) {
   			fEventsReceived.add(e);
   			notifyAll();
   		}
   	}

   	private void queueConsoleCommand(String command) throws Throwable {
   		queueConsoleCommand(command, DEFAULT_TIMEOUT, DEFAULT_TIME_UNIT);
   	}

   	private void queueConsoleCommand(final String command, int timeout, TimeUnit unit) throws Throwable {
 		Query<MIInfo> query = new Query<MIInfo>() {
 			@Override
 			protected void execute(DataRequestMonitor<MIInfo> rm) {
 				fCommandControl.queueCommand(
 					fCommandControl.getCommandFactory().createMIInterpreterExecConsole(
 						fCommandControl.getContext(),
 						command),
 					rm);
 			}
 		};
 		fSession.getExecutor().execute(query);
 		query.get(timeout, unit);
   	}

   	private <V extends IDMEvent<? extends IDMContext>> V waitForEvent(Class<V> eventType) throws Exception {
   		return waitForEvent(eventType, DEFAULT_TIMEOUT);
   	}

   	@SuppressWarnings("unchecked")
 	private <V extends IDMEvent<? extends IDMContext>> V waitForEvent(Class<V> eventType, int timeout) throws Exception {
   		IDMEvent<?> event = getEvent(eventType);
   		if (event == null) {
 			synchronized(this) {
 				try {
 					wait(timeout);
 				}
 				catch (InterruptedException ex) {
 				}
 			}
 			event = getEvent(eventType);
 			if (event == null) {
 				throw new Exception(String.format("Timed out waiting for '%s' to occur.", eventType.getName()));
 			}
 		}
   		return (V)event;
 	}

   	@SuppressWarnings("unchecked")
 	private synchronized <V extends IDMEvent<? extends IDMContext>> V getEvent(Class<V> eventType) {
 		for (IDMEvent<?> e : fEventsReceived) {
 			if (eventType.isAssignableFrom(e.getClass())) {
 				fEventsReceived.remove(e);
 				return (V)e;
 			}
 		}
 		return null;
   	}

 }
	/*******************************************************************************
	* Copyright (c) 2013, 2015 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:
	* Marc Khouzam (Ericsson) - Initial API and implementation
	*******************************************************************************/

	package org.eclipse.cdt.tests.dsf.gdb.tests;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertTrue;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.concurrent.TimeUnit;

	import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants;
	import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
	import org.eclipse.cdt.dsf.concurrent.ImmediateRequestMonitor;
	import org.eclipse.cdt.dsf.concurrent.Query;
	import org.eclipse.cdt.dsf.datamodel.DMContexts;
	import org.eclipse.cdt.dsf.datamodel.IDMContext;
	import org.eclipse.cdt.dsf.datamodel.IDMEvent;
	import org.eclipse.cdt.dsf.debug.service.IExpressions;
	import org.eclipse.cdt.dsf.debug.service.IExpressions.IExpressionDMAddress;
	import org.eclipse.cdt.dsf.debug.service.IExpressions.IExpressionDMContext;
	import org.eclipse.cdt.dsf.debug.service.IFormattedValues;
	import org.eclipse.cdt.dsf.debug.service.IMemory;
	import org.eclipse.cdt.dsf.debug.service.IMemory.IMemoryChangedEvent;
	import org.eclipse.cdt.dsf.debug.service.IMemory.IMemoryDMContext;
	import org.eclipse.cdt.dsf.debug.service.IRunControl;
	import org.eclipse.cdt.dsf.debug.service.IStack.IFrameDMContext;
	import org.eclipse.cdt.dsf.gdb.service.IReverseRunControl;
	import org.eclipse.cdt.dsf.gdb.service.IReverseRunControl.IReverseModeChangedDMEvent;
	import org.eclipse.cdt.dsf.gdb.service.command.IGDBControl;
	import org.eclipse.cdt.dsf.mi.service.command.events.MIStoppedEvent;
	import org.eclipse.cdt.dsf.mi.service.command.output.MIInfo;
	import org.eclipse.cdt.dsf.service.DsfServiceEventHandler;
	import org.eclipse.cdt.dsf.service.DsfServicesTracker;
	import org.eclipse.cdt.dsf.service.DsfSession;
	import org.eclipse.cdt.tests.dsf.gdb.framework.BaseParametrizedTestCase;
	import org.eclipse.cdt.tests.dsf.gdb.framework.SyncUtil;
	import org.eclipse.cdt.tests.dsf.gdb.launching.TestsPlugin;
	import org.eclipse.debug.core.model.MemoryByte;
	import org.junit.Assert;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.Parameterized;

	/**
	* This test case verifies that different commands issued from the
	* GDB console cause proper updating within the CDT views.
	*/
	@RunWith(Parameterized.class)
	public class GDBConsoleSynchronizingTest extends BaseParametrizedTestCase {
	final static private String EXEC_NAME = "ConsoleSyncTestApp.exe";

	final static private int DEFAULT_TIMEOUT = TestsPlugin.massageTimeout(1000);
	final static private TimeUnit DEFAULT_TIME_UNIT = TimeUnit.MILLISECONDS;
	final static private String NEW_VAR_VALUE = "0x12345678";
	final static private int NEW_VAR_SIZE = 4; // The number of bytes of NEW_VAR_VALUE
	final static private byte[] NEW_MEM = { 0x12, 0x34, 0x56, 0x78 }; // The individual bytes of NEW_VAR_VALUE

	private DsfSession fSession;
	private DsfServicesTracker fServicesTracker;
	private IGDBControl fCommandControl;
	private IMemory fMemoryService;
	private IExpressions fExprService;
	private IRunControl fRunControl;

	private List<IDMEvent<? extends IDMContext>> fEventsReceived = new ArrayList<IDMEvent<? extends IDMContext>>();

	@Override
	protected void setLaunchAttributes() {
	super.setLaunchAttributes();
	setLaunchAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME, EXEC_PATH + EXEC_NAME);
	}

	@Override
	public void doBeforeTest() throws Exception {
	assumeGdbVersionAtLeast(ITestConstants.SUFFIX_GDB_7_6);
	super.doBeforeTest();

	fSession = getGDBLaunch().getSession();
	Runnable runnable = new Runnable() {
	@Override
	public void run() {
	fServicesTracker = new DsfServicesTracker(TestsPlugin.getBundleContext(), fSession.getId());
	Assert.assertTrue(fServicesTracker != null);

	fCommandControl = fServicesTracker.getService(IGDBControl.class);
	Assert.assertTrue(fCommandControl != null);

	fMemoryService = fServicesTracker.getService(IMemory.class);
	Assert.assertTrue(fMemoryService != null);

	fExprService = fServicesTracker.getService(IExpressions.class);
	Assert.assertTrue(fExprService != null);

	fRunControl = fServicesTracker.getService(IRunControl.class);
	Assert.assertTrue(fRunControl != null);

	// Register to breakpoint events
	fSession.addServiceEventListener(GDBConsoleSynchronizingTest.this, null);
	}
	};
	fSession.getExecutor().submit(runnable).get();
	}

	@Override
	public void doAfterTest() throws Exception {
	if (fSession != null) {
	fSession.getExecutor().submit(() -> fSession.removeServiceEventListener(GDBConsoleSynchronizingTest.this))
	.get();
	}
	fEventsReceived.clear();
	if (fServicesTracker!=null) fServicesTracker.dispose();
	super.doAfterTest();
	}

	//////////////////////////////////////////////////////////////////////////////////////
	// Start of tests
	//////////////////////////////////////////////////////////////////////////////////////

	/**
	* This test verifies that setting a variable from the console
	* using the set command will properly trigger a DSF event to
	* indicate the change. This test makes sure the value that
	* changes is in the memory cache also.
	*/
	@Test
	public void testSettingVariableWithSetWithMemory() throws Throwable {
	MIStoppedEvent stoppedEvent = SyncUtil.runToLocation("testMemoryChanges");

	final IFrameDMContext frameDmc = SyncUtil.getStackFrame(stoppedEvent.getDMContext(), 0);
	final IExpressionDMContext exprDmc = SyncUtil.createExpression(frameDmc, "i");

	// Read the memory that will change first, or else there will be no event for it
	Query<IExpressionDMAddress> query = new Query<IExpressionDMAddress>() {
	@Override
	protected void execute(final DataRequestMonitor<IExpressionDMAddress> rm) {
	fExprService.getExpressionAddressData(exprDmc, rm);
	}
	};

	fSession.getExecutor().execute(query);
	IExpressionDMAddress data = query.get();

	IMemoryDMContext memoryDmc = DMContexts.getAncestorOfType(frameDmc, IMemoryDMContext.class);
	SyncUtil.readMemory(memoryDmc, data.getAddress(), 0, 1, NEW_VAR_SIZE);

	fEventsReceived.clear();

	String newValue = NEW_VAR_VALUE;
	queueConsoleCommand("set variable i=" + newValue);

	IMemoryChangedEvent memoryEvent = waitForEvent(IMemoryChangedEvent.class);
	assertEquals(1, memoryEvent.getAddresses().length);
	assertEquals(data.getAddress(), memoryEvent.getAddresses()[0]);

	// Now verify the memory service knows the new memory value
	MemoryByte[] memory = SyncUtil.readMemory(memoryDmc, data.getAddress(), 0, 1, NEW_VAR_SIZE);
	assertEquals(NEW_VAR_SIZE, memory.length);
	for (int i=0; i<NEW_VAR_SIZE; i++) {
	if (memory[0].isBigEndian()) {
	assertEquals(NEW_MEM[i], memory[i].getValue());
	} else {
	assertEquals(NEW_MEM[i], memory[NEW_VAR_SIZE-1-i].getValue());
	}
	}

	// Now verify the expressions service knows the new value
	String exprValue = SyncUtil.getExpressionValue(exprDmc, IFormattedValues.HEX_FORMAT);
	assertEquals(newValue, exprValue);
	}

	private void testSettingVariableWithCommon(String commandPrefix) throws Throwable {
	MIStoppedEvent stoppedEvent = SyncUtil.runToLocation("testMemoryChanges");

	final IFrameDMContext frameDmc = SyncUtil.getStackFrame(stoppedEvent.getDMContext(), 0);
	final IExpressionDMContext exprDmc = SyncUtil.createExpression(frameDmc, "i");

	// Read the memory that will change first, or else there will be no event for it
	Query<IExpressionDMAddress> query = new Query<IExpressionDMAddress>() {
	@Override
	protected void execute(final DataRequestMonitor<IExpressionDMAddress> rm) {
	fExprService.getExpressionAddressData(exprDmc, rm);
	}
	};

	fSession.getExecutor().execute(query);
	IExpressionDMAddress data = query.get();

	fEventsReceived.clear();

	final String newValue = NEW_VAR_VALUE;
	queueConsoleCommand(commandPrefix + " = " + newValue);

	IMemoryChangedEvent memoryEvent = waitForEvent(IMemoryChangedEvent.class);
	assertEquals(1, memoryEvent.getAddresses().length);
	assertEquals(data.getAddress(), memoryEvent.getAddresses()[0]);

	// Now verify the memory service knows the new memory value
	IMemoryDMContext memoryDmc = DMContexts.getAncestorOfType(frameDmc, IMemoryDMContext.class);
	MemoryByte[] memory = SyncUtil.readMemory(memoryDmc, data.getAddress(), 0, 1, NEW_VAR_SIZE);
	assertEquals(NEW_VAR_SIZE, memory.length);
	for (int i=0; i<NEW_VAR_SIZE; i++) {
	if (memory[0].isBigEndian()) {
	assertEquals(NEW_MEM[i], memory[i].getValue());
	} else {
	assertEquals(NEW_MEM[i], memory[NEW_VAR_SIZE-1-i].getValue());
	}
	}

	// Now verify the expressions service knows the new value
	String exprValue = SyncUtil.getExpressionValue(exprDmc, IFormattedValues.HEX_FORMAT);
	assertEquals(newValue, exprValue);
	}

	/**
	* This test verifies that setting a variable from the console
	* using the set command will properly trigger a DSF event to
	* indicate the change, when the address is not in the memory cache.
	*/
	@Test
	public void testSettingVariableWithSet() throws Throwable {
	testSettingVariableWithCommon("set variable i");
	}

	/**
	* This test verifies that setting a variable from the console
	* using the print command will properly trigger a DSF event
	* to indicate the change.
	*/
	@Test
	public void testSettingVariableWithPrint() throws Throwable {
	testSettingVariableWithCommon("print i");
	}

	/**
	* This test verifies that setting a memory location from the
	* console will properly trigger a DSF event to indicate the change.
	*/
	@Test
	public void testSettingMemory() throws Throwable {
	MIStoppedEvent stoppedEvent = SyncUtil.runToLocation("testMemoryChanges");

	final IFrameDMContext frameDmc = SyncUtil.getStackFrame(stoppedEvent.getDMContext(), 0);
	final IExpressionDMContext exprDmc = SyncUtil.createExpression(frameDmc, "i");

	// Read the memory that will change first, or else there will be no event for it
	Query<IExpressionDMAddress> query = new Query<IExpressionDMAddress>() {
	@Override
	protected void execute(final DataRequestMonitor<IExpressionDMAddress> rm) {
	fExprService.getExpressionAddressData(exprDmc, rm);
	}
	};

	fSession.getExecutor().execute(query);
	IExpressionDMAddress data = query.get();

	fEventsReceived.clear();

	final String newValue = NEW_VAR_VALUE;
	queueConsoleCommand("set {int}&i=" + newValue);

	IMemoryChangedEvent memoryEvent = waitForEvent(IMemoryChangedEvent.class);
	assertEquals(1, memoryEvent.getAddresses().length);
	assertEquals(data.getAddress(), memoryEvent.getAddresses()[0]);

	// Now verify the memory service knows the new memory value
	IMemoryDMContext memoryDmc = DMContexts.getAncestorOfType(frameDmc, IMemoryDMContext.class);
	MemoryByte[] memory = SyncUtil.readMemory(memoryDmc, data.getAddress(), 0, 1, NEW_VAR_SIZE);
	assertEquals(NEW_VAR_SIZE, memory.length);
	for (int i=0; i<NEW_VAR_SIZE; i++) {
	if (memory[0].isBigEndian()) {
	assertEquals(NEW_MEM[i], memory[i].getValue());
	} else {
	assertEquals(NEW_MEM[i], memory[NEW_VAR_SIZE-1-i].getValue());
	}
	}

	// Now verify the expressions service knows the new value
	String exprValue = SyncUtil.getExpressionValue(exprDmc, IFormattedValues.HEX_FORMAT);
	assertEquals(newValue, exprValue);
	}

	/**
	* This test verifies that enabling reverse debugging from the
	* console will properly trigger a DSF event to indicate the change and
	* will be processed by the service.
	*/
	@Test
	public void testEnableRecord() throws Throwable {
	assertTrue("Reverse debugging is not supported", fRunControl instanceof IReverseRunControl);
	final IReverseRunControl reverseService = (IReverseRunControl)fRunControl;

	SyncUtil.runToLocation("testMemoryChanges");

	// check starting state
	Query<Boolean> query = new Query<Boolean>() {
	@Override
	protected void execute(final DataRequestMonitor<Boolean> rm) {
	reverseService.isReverseModeEnabled(fCommandControl.getContext(), rm);
	}
	};

	fSession.getExecutor().execute(query);
	Boolean enabled = query.get();
	assertTrue("Reverse debugging should not be enabled", !enabled);

	fEventsReceived.clear();

	queueConsoleCommand("record");

	// Wait for the event
	IReverseModeChangedDMEvent event = waitForEvent(IReverseModeChangedDMEvent.class);
	assertEquals(true, event.isReverseModeEnabled());

	// Check the service
	query = new Query<Boolean>() {
	@Override
	protected void execute(final DataRequestMonitor<Boolean> rm) {
	reverseService.isReverseModeEnabled(fCommandControl.getContext(), rm);
	}
	};
	fSession.getExecutor().execute(query);
	enabled = query.get();
	assertTrue("Reverse debugging should be enabled", enabled);
	}

	/**
	* This test verifies that disabling reverse debugging from the
	* console will properly trigger a DSF event to indicate the change and
	* will be processed by the service.
	*/
	@Test
	public void testDisableRecord() throws Throwable {
	assertTrue("Reverse debugging is not supported", fRunControl instanceof IReverseRunControl);
	final IReverseRunControl reverseService = (IReverseRunControl)fRunControl;

	SyncUtil.runToLocation("testMemoryChanges");

	fEventsReceived.clear();

	// check starting state
	Query<Boolean> query = new Query<Boolean>() {
	@Override
	protected void execute(final DataRequestMonitor<Boolean> rm) {
	reverseService.enableReverseMode(fCommandControl.getContext(), true,
	new ImmediateRequestMonitor(rm) {
	@Override
	protected void handleSuccess() {
	reverseService.isReverseModeEnabled(fCommandControl.getContext(), rm);
	}
	});
	}
	};

	fSession.getExecutor().execute(query);
	Boolean enabled = query.get();
	assertTrue("Reverse debugging should be enabled", enabled);

	// Wait for the event to avoid confusing it with the next one
	IReverseModeChangedDMEvent event = waitForEvent(IReverseModeChangedDMEvent.class);
	assertEquals(true, event.isReverseModeEnabled());
	fEventsReceived.clear();

	queueConsoleCommand("record stop");

	// Wait for the event
	event = waitForEvent(IReverseModeChangedDMEvent.class);
	assertEquals(false, event.isReverseModeEnabled());

	// Check the service
	query = new Query<Boolean>() {
	@Override
	protected void execute(final DataRequestMonitor<Boolean> rm) {
	reverseService.isReverseModeEnabled(fCommandControl.getContext(), rm);
	}
	};
	fSession.getExecutor().execute(query);
	enabled = query.get();
	assertTrue("Reverse debugging should not be enabled", !enabled);
	}

	//////////////////////////////////////////////////////////////////////////////////////
	// End of tests
	//////////////////////////////////////////////////////////////////////////////////////

	@DsfServiceEventHandler
	public void eventDispatched(IDMEvent<? extends IDMContext> e) {
	synchronized(this) {
	fEventsReceived.add(e);
	notifyAll();
	}
	}

	private void queueConsoleCommand(String command) throws Throwable {
	queueConsoleCommand(command, DEFAULT_TIMEOUT, DEFAULT_TIME_UNIT);
	}

	private void queueConsoleCommand(final String command, int timeout, TimeUnit unit) throws Throwable {
	Query<MIInfo> query = new Query<MIInfo>() {
	@Override
	protected void execute(DataRequestMonitor<MIInfo> rm) {
	fCommandControl.queueCommand(
	fCommandControl.getCommandFactory().createMIInterpreterExecConsole(
	fCommandControl.getContext(),
	command),
	rm);
	}
	};
	fSession.getExecutor().execute(query);
	query.get(timeout, unit);
	}

	private <V extends IDMEvent<? extends IDMContext>> V waitForEvent(Class<V> eventType) throws Exception {
	return waitForEvent(eventType, DEFAULT_TIMEOUT);
	}

	@SuppressWarnings("unchecked")
	private <V extends IDMEvent<? extends IDMContext>> V waitForEvent(Class<V> eventType, int timeout) throws Exception {
	IDMEvent<?> event = getEvent(eventType);
	if (event == null) {
	synchronized(this) {
	try {
	wait(timeout);
	}
	catch (InterruptedException ex) {
	}
	}
	event = getEvent(eventType);
	if (event == null) {
	throw new Exception(String.format("Timed out waiting for '%s' to occur.", eventType.getName()));
	}
	}
	return (V)event;
	}

	@SuppressWarnings("unchecked")
	private synchronized <V extends IDMEvent<? extends IDMContext>> V getEvent(Class<V> eventType) {
	for (IDMEvent<?> e : fEventsReceived) {
	if (eventType.isAssignableFrom(e.getClass())) {
	fEventsReceived.remove(e);
	return (V)e;
	}
	}
	return null;
	}

	}