org.eclipse.cdt.debug.edc.tests/src/org/eclipse/cdt/debug/edc/debugger/tests/Concurrent.java - cdt/org.eclipse.cdt.edc - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009, 2010 Nokia 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:
  * Nokia - Initial API and implementation
  *******************************************************************************/
 package org.eclipse.cdt.debug.edc.debugger.tests;

 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;

 import junit.framework.Assert;

 import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants;
 import org.eclipse.cdt.debug.edc.internal.services.dsf.INoop;
 import org.eclipse.cdt.debug.edc.internal.services.dsf.RunControl.ExecutionDMC;
 import org.eclipse.cdt.debug.edc.launch.EDCLaunch;
 import org.eclipse.cdt.debug.edc.services.Stack;
 import org.eclipse.cdt.debug.edc.services.Stack.StackFrameDMC;
 import org.eclipse.cdt.debug.edc.tests.TestUtils;
 import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
 import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
 import org.eclipse.cdt.dsf.debug.service.IStack;
 import org.eclipse.cdt.dsf.debug.service.IStack.IFrameDMContext;
 import org.eclipse.cdt.dsf.service.DsfSession;
 import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
 import org.junit.After;
 import org.junit.Test;

 public class Concurrent extends BaseLaunchTest {

 	private EDCLaunch launch;
 	private DsfSession session;
 	private boolean testDidShutdown;

 	/**
 	 * This test validates that the EDC service threads are given a chance to
 	 * complete before the DSF session proceeds with its shutdown. Otherwise,
 	 * the logic running on those threads would likely encounter all sorts of
 	 * problems as it tries to operate within a session that has been shut down.
 	 */
 	@Test
 	public void testEDCThreadAtShutdown_1() throws Throwable {
 		TestUtils.showDebugPerspective();
 		launch = createLaunch();
 		assertNotNull(launch);
 		session = TestUtils.waitForSession(launch);
 		assertNotNull(session);
 		final ExecutionDMC threadDMC = TestUtils.waitForSuspendedThread(session);
 		assertNotNull(threadDMC);
 		TestUtils.waitForStackFrame(session, threadDMC);
 		final INoop service = TestUtils.getService(session, INoop.class);
 		final String semaphore = new String();
 		final AtomicBoolean successful = new AtomicBoolean(false);
 		final Throwable[] exception = new Throwable[1];

 		Runnable runnable = new Runnable() {
 			public void run() {
 				try {
 					RequestMonitor rm = new RequestMonitor(service.getExecutor(), null);
 					service.longNoopUsingServiceTracker(3, rm);
 					successful.set(true);
 					synchronized (semaphore) {
 						semaphore.notify();
 					}
 				}
 				catch (Throwable exc) {
 					synchronized (exception) {
 						exception[0] = exc;
 					}
 					synchronized (semaphore) {
 						semaphore.notify();
 					}
 				}
 			}
 		};

 		// Kick off some work on an EDC service thread. Its logic will encounter
 		// an exception if the DSF session shuts down while they're running
 		EDCLaunch.getThreadPool(service.getSession().getId()).execute(runnable);

 		// Tell the DSF session to shut down
 		TestUtils.shutdownDebugSession(launch, session);

 		// Avoid a redundant shutdown by the @After method
 		testDidShutdown = true;

 		// Wait until the EDC service thread either completes or encounters an
 		// exception
 		synchronized (semaphore) {
 			semaphore.wait(8 * 1000);
 		}

 		// If it ran into an exception, fail the test
 		synchronized (exception) {
 			if (exception[0] != null) {
 				throw exception[0];
 			}
 		}

 		// A sanity check that the thread completed successfully
 		assertTrue(successful.get());
 	}

 	/**
 	 * This test validates that the EDC service threads are given a chance to
 	 * complete before the DSF session proceeds with its shutdown. Note the request
 	 * monitor should be completed properly.
 	 */
 	@Test
 	public void testEDCThreadAtShutdown_2() throws Throwable {
 		TestUtils.showDebugPerspective();
 		launch = createLaunch();
 		assertNotNull(launch);
 		session = TestUtils.waitForSession(launch);
 		assertNotNull(session);
 		final ExecutionDMC threadDMC = TestUtils.waitForSuspendedThread(session);
 		assertNotNull(threadDMC);
 		TestUtils.waitForStackFrame(session, threadDMC);
 		final INoop service = TestUtils.getService(session, INoop.class);
 		final String semaphore = new String();
 		final AtomicBoolean successful = new AtomicBoolean(false);
 		final Throwable[] exception = new Throwable[1];

 		Runnable runnable = new Runnable() {
 			public void run() {
 				try {
 					DataRequestMonitor<Boolean> drm = new DataRequestMonitor<Boolean>(service.getExecutor(), null) {
 						@Override
 						protected void handleCompleted() {
 							successful.set(getData());

 							synchronized (semaphore) {
 								semaphore.notify();
 							}
 						}};

 					service.longNoop(3, drm);
 				}
 				catch (Throwable exc) {
 					synchronized (exception) {
 						exception[0] = exc;
 					}
 					synchronized (semaphore) {
 						semaphore.notify();
 					}
 				}
 			}
 		};

 		// Kick off some work on an EDC service thread. Its logic will encounter
 		// an exception if the DSF session shuts down while they're running
 		EDCLaunch.getThreadPool(service.getSession().getId()).execute(runnable);

 		// Tell the DSF session to shut down
 		TestUtils.shutdownDebugSession(launch, session);

 		// Avoid a redundant shutdown by the @After method
 		testDidShutdown = true;

 		// Wait until the EDC service thread either completes or encounters an
 		// exception
 		synchronized (semaphore) {
 			semaphore.wait(4 * 1000);
 		}

 		// If it ran into an exception, fail the test
 		synchronized (exception) {
 			if (exception[0] != null) {
 				throw exception[0];
 			}
 		}

 		// A sanity check that the thread and request monitor completed successfully
 		assertTrue(successful.get());
 	}

 	/**
 	 * This test validates that a non EDC service thread is not given a chance to
 	 * complete before the DSF session proceeds with its shutdown.
 	 */
 	@Test
 	public void testNonEDCThreadAtShutdown() throws Throwable {
 		TestUtils.showDebugPerspective();
 		launch = createLaunch();
 		assertNotNull(launch);
 		session = TestUtils.waitForSession(launch);
 		assertNotNull(session);
 		final ExecutionDMC threadDMC = TestUtils.waitForSuspendedThread(session);
 		assertNotNull(threadDMC);
 		TestUtils.waitForStackFrame(session, threadDMC);
 		final INoop service = TestUtils.getService(session, INoop.class);
 		final String semaphore = new String();
 		final AtomicBoolean successful = new AtomicBoolean(false);
 		final Throwable[] exception = new Throwable[1];

 		final Runnable runnable = new Runnable() {
 			public void run() {
 				try {
 					DataRequestMonitor<Boolean> drm = new DataRequestMonitor<Boolean>(service.getExecutor(), null) {

 						@Override
 						protected void handleRejectedExecutionException() {
 							// Executor is shutting down
 							synchronized (exception) {
 								exception[0] = new Exception("Executor has been shut down.");
 							}
 							synchronized (semaphore) {
 								semaphore.notify();
 							}
 						}

 						@Override
 						protected void handleCompleted() {
 							successful.set(getData());

 							synchronized (semaphore) {
 								semaphore.notify();
 							}
 						}};

 					service.longNoop(3, drm);
 				}
 				catch (Throwable exc) {
 					synchronized (exception) {
 						exception[0] = exc;
 					}
 					synchronized (semaphore) {
 						semaphore.notify();
 					}
 				}
 			}
 		};

 		// Kick off some work in a regular thread (non EDC service thread). Its logic will encounter
 		// an exception if the DSF session shuts down while they're running
 		new Thread(runnable).start();

 		// Tell the DSF session to shut down
 		TestUtils.shutdownDebugSession(launch, session);

 		// Avoid a redundant shutdown by the @After method
 		testDidShutdown = true;

 		// Wait until the thread either completes or encounters an
 		// exception
 		synchronized (semaphore) {
 			semaphore.wait(4 * 1000);
 		}

 		// it's expected to run into exception
 		synchronized (exception) {
 			assertNotNull(exception[0]);
 		}

 		// the task (request monitor) is not completed successfully
 		assertFalse(successful.get());
 	}

 	/**
 	 * Basic test. See {@link #testStackTraces()}
 	 */
 	@Test
 	public void testStackTraces1() throws Throwable {
 		testStackTraces();
 	}

 	/**
 	 * Variation that uses a thread pool with only one thread. Will be slower,
 	 * but should be able to handle the load.
 	 */
 	/**
 	 * @throws Throwable
 	 */
 	@Test
 	public void testStackTraces2() throws Throwable {
 		System.setProperty("org.eclipse.cdt.edc.poolthread.coreThreadCount", "1");
 		testStackTraces();
 	}

 	/**
 	 * Variation that uses a larger thread pool. Should be more effective in
 	 * flushing out concurrenc issues since more threads are running the same
 	 * code simultaneously
 	 */
 	/**
 	 * @throws Throwable
 	 */
 	@Test
 	public void testStackTraces3() throws Throwable {
 		System.setProperty("org.eclipse.cdt.edc.poolthread.coreThreadCount", "10");
 		testStackTraces();
 	}

 	/**
 	 * Test that an overwhelmed thread pool throws the expected exception.
 	 * There's no way three threads can handle 10,000 requests with a maximum
 	 * backlog of five requests.
 	 */
 	/**
 	 * @throws Throwable
 	 */
 	@Test
 	public void testStackTraces4() throws Throwable {
 		String existingProp = System.getProperty("org.eclipse.cdt.edc.poolthread.queueLimit");
 		if (existingProp == null)
 			existingProp = "10000"; // See value in EDC Launch
 		System.setProperty("org.eclipse.cdt.edc.poolthread.queueLimit", "5");
 		try {
 			testStackTraces();
 			Assert.fail(); // RejectedExecutionException should have been thrown
 		}
 		catch (RejectedExecutionException exc) {}
 		System.setProperty("org.eclipse.cdt.edc.poolthread.queueLimit", existingProp);
 	}

 	/**
 	 * @throws Throwable
 	 */
 	public void testStackTraces() throws Throwable {
 		TestUtils.showDebugPerspective();
 		launch = createLaunch();
 		assertNotNull(launch);
 		session = TestUtils.waitForSession(launch);
 		assertNotNull(session);
 		final ExecutionDMC threadDMC = TestUtils.waitForSuspendedThread(session);
 		assertNotNull(threadDMC);
 		TestUtils.waitForStackFrame(session, threadDMC);
 		final AtomicInteger completed = new AtomicInteger();

 		final Stack stackService = TestUtils.getService(session, Stack.class);
 		final int testCount = 10000;

 		final IFrameDMContext[][] referenceStackCrawl = new IFrameDMContext[1][];
 		final Throwable[] exception = new Throwable[1];

 		Runnable getFrames = new Runnable() {
 			public void run() {
 				try {
 					// Don't bother if another thread has already encountered an
 					// exception
 					synchronized (exception) {
 						if (exception[0] != null) {
 							return;
 						}
 					}

 					IFrameDMContext[] frames = stackService.getFramesForDMC((ExecutionDMC)threadDMC, 0, IStack.ALL_FRAMES);

 					// The first stack crawl we get is the one we compare all
 					// subsequent ones to
 					synchronized (referenceStackCrawl) {
 						if (referenceStackCrawl[0] == null) {
 							referenceStackCrawl[0] = frames;
 						}
 					}
 					if (frames != referenceStackCrawl[0]) {
 						Assert.assertEquals(referenceStackCrawl[0].length, frames.length);
 						for (int i = 0; i < frames.length; i++) {
 							Assert.assertEquals(frames[i].getLevel(), referenceStackCrawl[0][i].getLevel());
 							compareStackFrames((StackFrameDMC)frames[i], ((StackFrameDMC)referenceStackCrawl[0][i]));
 						}
 					}
 					if (completed.incrementAndGet() == testCount) {
 						synchronized (completed) {
 							completed.notify();
 						}
 					}
 				} catch (Throwable e) {
 					synchronized (exception) {
 						if (exception[0] == null) {
 							exception[0] = e;
 						}
 					}
 					synchronized (completed) {
 						completed.notify();
 					}
 				}
 			}
 		};

 		for (int i = 0; i < testCount; i++) {
 			EDCLaunch.getThreadPool(stackService.getSession().getId()).execute(getFrames);
 		}

 		synchronized (completed) {
 			completed.wait(30*1000);
 		}

 		// See if the threads encountered an exception. If so, then throw it from this thread (the test thread) so the test fails accordingly
 		synchronized (exception) {
 			if (exception[0] != null) {
 				throw exception[0];
 			}
 		}

 		Assert.assertEquals(testCount, completed.get());

 	}

 	/**
 	 * Validate two stack frames are equal
 	 */
 	private static void compareStackFrames(StackFrameDMC f1, StackFrameDMC f2) throws Exception {
 		Assert.assertEquals(f1.getFunctionName(), f2.getFunctionName());
 		Assert.assertEquals(f1.getLineNumber(), f2.getLineNumber());
 		Assert.assertEquals(f1.getModuleName(), f2.getModuleName());
 		Assert.assertEquals(f1.getName(), f2.getName());
 		Assert.assertEquals(f1.getSourceFile(), f2.getSourceFile());
 		Assert.assertEquals(f1.getBaseAddress(), f2.getBaseAddress());
 		Assert.assertEquals(f1.getCalledFrame(), f2.getCalledFrame());
 	}


 	@After
 	public void shutdown() {
 		if (!testDidShutdown) {
 			TestUtils.shutdownDebugSession(launch, session);
 		}
 	}

 	@Override
 	protected void configureLaunchConfiguration(
 			ILaunchConfigurationWorkingCopy configuration) {

 		// Make sure it stop at main
 		configuration.setAttribute(ICDTLaunchConfigurationConstants.ATTR_DEBUGGER_STOP_AT_MAIN, true);
 		configuration.setAttribute(ICDTLaunchConfigurationConstants.ATTR_DEBUGGER_STOP_AT_MAIN_SYMBOL, "main");
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2009, 2010 Nokia 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:
	* Nokia - Initial API and implementation
	*******************************************************************************/
	package org.eclipse.cdt.debug.edc.debugger.tests;

	import java.util.concurrent.RejectedExecutionException;
	import java.util.concurrent.atomic.AtomicBoolean;
	import java.util.concurrent.atomic.AtomicInteger;

	import junit.framework.Assert;

	import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants;
	import org.eclipse.cdt.debug.edc.internal.services.dsf.INoop;
	import org.eclipse.cdt.debug.edc.internal.services.dsf.RunControl.ExecutionDMC;
	import org.eclipse.cdt.debug.edc.launch.EDCLaunch;
	import org.eclipse.cdt.debug.edc.services.Stack;
	import org.eclipse.cdt.debug.edc.services.Stack.StackFrameDMC;
	import org.eclipse.cdt.debug.edc.tests.TestUtils;
	import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
	import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
	import org.eclipse.cdt.dsf.debug.service.IStack;
	import org.eclipse.cdt.dsf.debug.service.IStack.IFrameDMContext;
	import org.eclipse.cdt.dsf.service.DsfSession;
	import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
	import org.junit.After;
	import org.junit.Test;

	public class Concurrent extends BaseLaunchTest {

	private EDCLaunch launch;
	private DsfSession session;
	private boolean testDidShutdown;

	/**
	* This test validates that the EDC service threads are given a chance to
	* complete before the DSF session proceeds with its shutdown. Otherwise,
	* the logic running on those threads would likely encounter all sorts of
	* problems as it tries to operate within a session that has been shut down.
	*/
	@Test
	public void testEDCThreadAtShutdown_1() throws Throwable {
	TestUtils.showDebugPerspective();
	launch = createLaunch();
	assertNotNull(launch);
	session = TestUtils.waitForSession(launch);
	assertNotNull(session);
	final ExecutionDMC threadDMC = TestUtils.waitForSuspendedThread(session);
	assertNotNull(threadDMC);
	TestUtils.waitForStackFrame(session, threadDMC);
	final INoop service = TestUtils.getService(session, INoop.class);
	final String semaphore = new String();
	final AtomicBoolean successful = new AtomicBoolean(false);
	final Throwable[] exception = new Throwable[1];

	Runnable runnable = new Runnable() {
	public void run() {
	try {
	RequestMonitor rm = new RequestMonitor(service.getExecutor(), null);
	service.longNoopUsingServiceTracker(3, rm);
	successful.set(true);
	synchronized (semaphore) {
	semaphore.notify();
	}
	}
	catch (Throwable exc) {
	synchronized (exception) {
	exception[0] = exc;
	}
	synchronized (semaphore) {
	semaphore.notify();
	}
	}
	}
	};

	// Kick off some work on an EDC service thread. Its logic will encounter
	// an exception if the DSF session shuts down while they're running
	EDCLaunch.getThreadPool(service.getSession().getId()).execute(runnable);

	// Tell the DSF session to shut down
	TestUtils.shutdownDebugSession(launch, session);

	// Avoid a redundant shutdown by the @After method
	testDidShutdown = true;

	// Wait until the EDC service thread either completes or encounters an
	// exception
	synchronized (semaphore) {
	semaphore.wait(8 * 1000);
	}

	// If it ran into an exception, fail the test
	synchronized (exception) {
	if (exception[0] != null) {
	throw exception[0];
	}
	}

	// A sanity check that the thread completed successfully
	assertTrue(successful.get());
	}

	/**
	* This test validates that the EDC service threads are given a chance to
	* complete before the DSF session proceeds with its shutdown. Note the request
	* monitor should be completed properly.
	*/
	@Test
	public void testEDCThreadAtShutdown_2() throws Throwable {
	TestUtils.showDebugPerspective();
	launch = createLaunch();
	assertNotNull(launch);
	session = TestUtils.waitForSession(launch);
	assertNotNull(session);
	final ExecutionDMC threadDMC = TestUtils.waitForSuspendedThread(session);
	assertNotNull(threadDMC);
	TestUtils.waitForStackFrame(session, threadDMC);
	final INoop service = TestUtils.getService(session, INoop.class);
	final String semaphore = new String();
	final AtomicBoolean successful = new AtomicBoolean(false);
	final Throwable[] exception = new Throwable[1];

	Runnable runnable = new Runnable() {
	public void run() {
	try {
	DataRequestMonitor<Boolean> drm = new DataRequestMonitor<Boolean>(service.getExecutor(), null) {
	@Override
	protected void handleCompleted() {
	successful.set(getData());

	synchronized (semaphore) {
	semaphore.notify();
	}
	}};

	service.longNoop(3, drm);
	}
	catch (Throwable exc) {
	synchronized (exception) {
	exception[0] = exc;
	}
	synchronized (semaphore) {
	semaphore.notify();
	}
	}
	}
	};

	// Kick off some work on an EDC service thread. Its logic will encounter
	// an exception if the DSF session shuts down while they're running
	EDCLaunch.getThreadPool(service.getSession().getId()).execute(runnable);

	// Tell the DSF session to shut down
	TestUtils.shutdownDebugSession(launch, session);

	// Avoid a redundant shutdown by the @After method
	testDidShutdown = true;

	// Wait until the EDC service thread either completes or encounters an
	// exception
	synchronized (semaphore) {
	semaphore.wait(4 * 1000);
	}

	// If it ran into an exception, fail the test
	synchronized (exception) {
	if (exception[0] != null) {
	throw exception[0];
	}
	}

	// A sanity check that the thread and request monitor completed successfully
	assertTrue(successful.get());
	}

	/**
	* This test validates that a non EDC service thread is not given a chance to
	* complete before the DSF session proceeds with its shutdown.
	*/
	@Test
	public void testNonEDCThreadAtShutdown() throws Throwable {
	TestUtils.showDebugPerspective();
	launch = createLaunch();
	assertNotNull(launch);
	session = TestUtils.waitForSession(launch);
	assertNotNull(session);
	final ExecutionDMC threadDMC = TestUtils.waitForSuspendedThread(session);
	assertNotNull(threadDMC);
	TestUtils.waitForStackFrame(session, threadDMC);
	final INoop service = TestUtils.getService(session, INoop.class);
	final String semaphore = new String();
	final AtomicBoolean successful = new AtomicBoolean(false);
	final Throwable[] exception = new Throwable[1];

	final Runnable runnable = new Runnable() {
	public void run() {
	try {
	DataRequestMonitor<Boolean> drm = new DataRequestMonitor<Boolean>(service.getExecutor(), null) {

	@Override
	protected void handleRejectedExecutionException() {
	// Executor is shutting down
	synchronized (exception) {
	exception[0] = new Exception("Executor has been shut down.");
	}
	synchronized (semaphore) {
	semaphore.notify();
	}
	}

	@Override
	protected void handleCompleted() {
	successful.set(getData());

	synchronized (semaphore) {
	semaphore.notify();
	}
	}};

	service.longNoop(3, drm);
	}
	catch (Throwable exc) {
	synchronized (exception) {
	exception[0] = exc;
	}
	synchronized (semaphore) {
	semaphore.notify();
	}
	}
	}
	};

	// Kick off some work in a regular thread (non EDC service thread). Its logic will encounter
	// an exception if the DSF session shuts down while they're running
	new Thread(runnable).start();

	// Tell the DSF session to shut down
	TestUtils.shutdownDebugSession(launch, session);

	// Avoid a redundant shutdown by the @After method
	testDidShutdown = true;

	// Wait until the thread either completes or encounters an
	// exception
	synchronized (semaphore) {
	semaphore.wait(4 * 1000);
	}

	// it's expected to run into exception
	synchronized (exception) {
	assertNotNull(exception[0]);
	}

	// the task (request monitor) is not completed successfully
	assertFalse(successful.get());
	}

	/**
	* Basic test. See {@link #testStackTraces()}
	*/
	@Test
	public void testStackTraces1() throws Throwable {
	testStackTraces();
	}

	/**
	* Variation that uses a thread pool with only one thread. Will be slower,
	* but should be able to handle the load.
	*/
	/**
	* @throws Throwable
	*/
	@Test
	public void testStackTraces2() throws Throwable {
	System.setProperty("org.eclipse.cdt.edc.poolthread.coreThreadCount", "1");
	testStackTraces();
	}

	/**
	* Variation that uses a larger thread pool. Should be more effective in
	* flushing out concurrenc issues since more threads are running the same
	* code simultaneously
	*/
	/**
	* @throws Throwable
	*/
	@Test
	public void testStackTraces3() throws Throwable {
	System.setProperty("org.eclipse.cdt.edc.poolthread.coreThreadCount", "10");
	testStackTraces();
	}

	/**
	* Test that an overwhelmed thread pool throws the expected exception.
	* There's no way three threads can handle 10,000 requests with a maximum
	* backlog of five requests.
	*/
	/**
	* @throws Throwable
	*/
	@Test
	public void testStackTraces4() throws Throwable {
	String existingProp = System.getProperty("org.eclipse.cdt.edc.poolthread.queueLimit");
	if (existingProp == null)
	existingProp = "10000"; // See value in EDC Launch
	System.setProperty("org.eclipse.cdt.edc.poolthread.queueLimit", "5");
	try {
	testStackTraces();
	Assert.fail(); // RejectedExecutionException should have been thrown
	}
	catch (RejectedExecutionException exc) {}
	System.setProperty("org.eclipse.cdt.edc.poolthread.queueLimit", existingProp);
	}

	/**
	* @throws Throwable
	*/
	public void testStackTraces() throws Throwable {
	TestUtils.showDebugPerspective();
	launch = createLaunch();
	assertNotNull(launch);
	session = TestUtils.waitForSession(launch);
	assertNotNull(session);
	final ExecutionDMC threadDMC = TestUtils.waitForSuspendedThread(session);
	assertNotNull(threadDMC);
	TestUtils.waitForStackFrame(session, threadDMC);
	final AtomicInteger completed = new AtomicInteger();

	final Stack stackService = TestUtils.getService(session, Stack.class);
	final int testCount = 10000;

	final IFrameDMContext[][] referenceStackCrawl = new IFrameDMContext[1][];
	final Throwable[] exception = new Throwable[1];

	Runnable getFrames = new Runnable() {
	public void run() {
	try {
	// Don't bother if another thread has already encountered an
	// exception
	synchronized (exception) {
	if (exception[0] != null) {
	return;
	}
	}

	IFrameDMContext[] frames = stackService.getFramesForDMC((ExecutionDMC)threadDMC, 0, IStack.ALL_FRAMES);

	// The first stack crawl we get is the one we compare all
	// subsequent ones to
	synchronized (referenceStackCrawl) {
	if (referenceStackCrawl[0] == null) {
	referenceStackCrawl[0] = frames;
	}
	}
	if (frames != referenceStackCrawl[0]) {
	Assert.assertEquals(referenceStackCrawl[0].length, frames.length);
	for (int i = 0; i < frames.length; i++) {
	Assert.assertEquals(frames[i].getLevel(), referenceStackCrawl[0][i].getLevel());
	compareStackFrames((StackFrameDMC)frames[i], ((StackFrameDMC)referenceStackCrawl[0][i]));
	}
	}
	if (completed.incrementAndGet() == testCount) {
	synchronized (completed) {
	completed.notify();
	}
	}
	} catch (Throwable e) {
	synchronized (exception) {
	if (exception[0] == null) {
	exception[0] = e;
	}
	}
	synchronized (completed) {
	completed.notify();
	}
	}
	}
	};

	for (int i = 0; i < testCount; i++) {
	EDCLaunch.getThreadPool(stackService.getSession().getId()).execute(getFrames);
	}

	synchronized (completed) {
	completed.wait(30*1000);
	}

	// See if the threads encountered an exception. If so, then throw it from this thread (the test thread) so the test fails accordingly
	synchronized (exception) {
	if (exception[0] != null) {
	throw exception[0];
	}
	}

	Assert.assertEquals(testCount, completed.get());

	}

	/**
	* Validate two stack frames are equal
	*/
	private static void compareStackFrames(StackFrameDMC f1, StackFrameDMC f2) throws Exception {
	Assert.assertEquals(f1.getFunctionName(), f2.getFunctionName());
	Assert.assertEquals(f1.getLineNumber(), f2.getLineNumber());
	Assert.assertEquals(f1.getModuleName(), f2.getModuleName());
	Assert.assertEquals(f1.getName(), f2.getName());
	Assert.assertEquals(f1.getSourceFile(), f2.getSourceFile());
	Assert.assertEquals(f1.getBaseAddress(), f2.getBaseAddress());
	Assert.assertEquals(f1.getCalledFrame(), f2.getCalledFrame());
	}


	@After
	public void shutdown() {
	if (!testDidShutdown) {
	TestUtils.shutdownDebugSession(launch, session);
	}
	}

	@Override
	protected void configureLaunchConfiguration(
	ILaunchConfigurationWorkingCopy configuration) {

	// Make sure it stop at main
	configuration.setAttribute(ICDTLaunchConfigurationConstants.ATTR_DEBUGGER_STOP_AT_MAIN, true);
	configuration.setAttribute(ICDTLaunchConfigurationConstants.ATTR_DEBUGGER_STOP_AT_MAIN_SYMBOL, "main");
	}

	}