if (value)

			cancel();

  <extension point="org.eclipse.core.resources.builders" id="builderwithcallback" name="Builder With Callback">

    <builder>

      <run class="org.eclipse.core.tests.internal.builders.BuilderWithCallback"/>

    </builder>

  </extension>

import org.eclipse.core.tests.internal.builders.BuilderWithCallback.IBuildCallback;

	public void testInterruptLongAutobuild() throws CoreException, InterruptedException {

		setAutoBuilding(true);

		IProject project = getWorkspace().getRoot().getProject(getUniqueString());

		final IFile file = project.getFile("file.txt");

		ensureExistsInWorkspace(new IResource[] {project, file}, true);

		addBuilder(project, BuilderWithCallback.BUILDER_NAME);

		waitForBuild();

		final int[] status = new int[] {0};

		// use build callback to simulate user interaction with build

		BuilderWithCallback.getInstance().setBuildCallback(new IBuildCallback() {

			public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) {

				// let others know that build is running

				status[0] = TestBarrier.STATUS_RUNNING;

				// build will finish if monitor will be cancelled or the test already ended

				while (!monitor.isCanceled() && status[0] != TestBarrier.STATUS_BLOCKED) {

					try {

						Thread.sleep(100);

					} catch (InterruptedException e) {

						// ignore

					}

				}

				// let others know that build is finished

				status[0] = TestBarrier.STATUS_DONE;

				return null;

			}

		});

		// setContents will trigger a build

		file.setContents(getRandomContents(), IResource.NONE, getMonitor());

		// wait until build is running

		TestBarrier.waitForStatus(status, TestBarrier.STATUS_RUNNING);

		// setContents will trigger a build; do it in a separate job so that the main thread is not blocked

		Job job = new Job("setContents") {

			protected IStatus run(IProgressMonitor monitor) {

				try {

					file.setContents(getRandomContents(), IResource.NONE, getMonitor());

				} catch (CoreException e) {

					return e.getStatus();

				}

				return Status.OK_STATUS;

			}

		};

		job.schedule();

		try {

			// wait until build is finished; this should happen if build started after

			// the first setContents call was cancelled by the second setContents call

			TestBarrier.waitForStatus(status, TestBarrier.STATUS_DONE);

		} finally {

			BuilderWithCallback.getInstance().setBuildCallback(null);

			// unblock the builder so that the job can finish before ending the test

			status[0] = TestBarrier.STATUS_BLOCKED;

			job.join();

			assertTrue(job.getResult().isOK());

		}

		waitForBuild();

		ensureDoesNotExistInWorkspace(project);

	}

/*******************************************************************************

 * Copyright (c) 2014 IBM Corporation 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:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.core.tests.internal.builders;

import java.util.Map;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IncrementalProjectBuilder;

import org.eclipse.core.runtime.IProgressMonitor;

/**

 * Test builder that allows to override the build method using a callback interface.

 */

public class BuilderWithCallback extends IncrementalProjectBuilder {

	public interface IBuildCallback {

		IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor);

	}

	public static final String BUILDER_NAME = "org.eclipse.core.tests.resources.builderwithcallback";

	private static BuilderWithCallback instance;

	public static BuilderWithCallback getInstance() {

		return instance;

	}

	private IBuildCallback buildCallback;

	public BuilderWithCallback() {

		instance = this;

	}

	protected IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) {

		if (buildCallback != null)

			return buildCallback.build(kind, args, monitor);

		return null;

	}

	public void setBuildCallback(IBuildCallback buildCallback) {

		this.buildCallback = buildCallback;

	}

}