tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/builders/RelaxedSchedRuleBuilderTest.java - platform/eclipse.platform.resources - Git at Google

 /*******************************************************************************
  *  Copyright (c) 2010, 2015 Broadcom 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:
  *     James Blackburn (Broadcom Corp.) - initial API and implementation
  *     Alexander Kurtakov <akurtako@redhat.com> - Bug 459343
  *******************************************************************************/
 package org.eclipse.core.tests.internal.builders;

 import java.io.ByteArrayInputStream;
 import java.util.*;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 import org.eclipse.core.resources.*;
 import org.eclipse.core.runtime.*;
 import org.eclipse.core.runtime.jobs.*;
 import org.eclipse.core.tests.harness.TestBarrier;
 import org.eclipse.core.tests.internal.builders.TestBuilder.BuilderRuleCallback;

 /**
  * This class tests extended functionality (since 3.6) which allows
  * builders to be run with reduced (non-Workspace) scheduling rules.
  *
  * When one of these builders runs, other threads may modify the workspace
  * depending on the builder's scheduling rule
  */
 public class RelaxedSchedRuleBuilderTest extends AbstractBuilderTest {
 	public static Test suite() {
 		return new TestSuite(RelaxedSchedRuleBuilderTest.class);
 	}

 	public RelaxedSchedRuleBuilderTest() {
 		super(null);
 	}

 	public RelaxedSchedRuleBuilderTest(String name) {
 		super(name);
 	}

 	@Override
 	protected void setUp() throws Exception {
 		super.setUp();
 	}

 	@Override
 	protected void tearDown() throws Exception {
 		super.tearDown();
 		getWorkspace().getRoot().delete(true, null);
 		TestBuilder builder = DeltaVerifierBuilder.getInstance();
 		if (builder != null) {
 			builder.reset();
 		}
 		builder = EmptyDeltaBuilder.getInstance();
 		if (builder != null) {
 			builder.reset();
 		}
 		builder = EmptyDeltaBuilder2.getInstance();
 		if (builder != null) {
 			builder.reset();
 		}
 	}

 	/**
 	 * Test a simple builder with a relaxed scheduling rule
 	 * @throws Exception
 	 */
 	public void testBasicRelaxedSchedulingRules() throws Exception {
 		String name = "TestRelaxed";
 		setAutoBuilding(false);
 		final IProject project = getWorkspace().getRoot().getProject(name);
 		create(project, false);
 		addBuilder(project, EmptyDeltaBuilder.BUILDER_NAME);

 		// Ensure the builder is instantiated
 		project.build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());

 		final TestBarrier tb = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);

 		// Create a builder set a null scheduling rule
 		EmptyDeltaBuilder builder = EmptyDeltaBuilder.getInstance();
 		builder.setRuleCallback(new BuilderRuleCallback() {
 			@Override
 			public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
 				return null;
 			}

 			@Override
 			public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
 				assertTrue(Job.getJobManager().currentRule() == null);
 				tb.setStatus(TestBarrier.STATUS_START);
 				while (!monitor.isCanceled()) {
 					try {
 						Thread.sleep(10);
 					} catch (InterruptedException e) {
 						// Don't care
 					}
 				}
 				tb.setStatus(TestBarrier.STATUS_DONE);
 				return super.build(kind, args, monitor);
 			}
 		});

 		Job j = new Job("build job") {
 			@Override
 			protected IStatus run(IProgressMonitor monitor) {
 				try {
 					project.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
 				} catch (CoreException e) {
 					fail();
 				}
 				return Status.OK_STATUS;
 			}
 		};
 		j.schedule();

 		// wait for build to be called
 		tb.waitForStatus(TestBarrier.STATUS_START);

 		// Should be able to write a file in the project
 		create(project.getFile("foo.c"), false);
 		assertTrue(project.getFile("foo.c").exists());

 		// Cancel the builder
 		j.cancel();
 		tb.waitForStatus(TestBarrier.STATUS_DONE);
 	}

 	/**
 	 * Test two builders, each with relaxed scheduling rules, run in the same build operation
 	 * Each should be run with their own scheduling rule.
 	 * Tests:
 	 *     Bug 306824 - null scheduling rule and non-null scheduling rule don't work together
 	 *     Builders should have separate scheduling rules
 	 * @throws Exception
 	 */
 	public void testTwoBuildersRunInOneBuild() throws Exception {
 		String name = "testTwoBuildersRunInOneBuild";
 		setAutoBuilding(false);
 		final IProject project = getWorkspace().getRoot().getProject(name);
 		create(project, false);

 		IProjectDescription desc = project.getDescription();
 		desc.setBuildSpec(new ICommand[] {createCommand(desc, EmptyDeltaBuilder.BUILDER_NAME, "Project1Build1"), createCommand(desc, EmptyDeltaBuilder2.BUILDER_NAME, "Project1Build2")});
 		project.setDescription(desc, getMonitor());

 		// Ensure the builder is instantiated
 		project.build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());

 		final TestBarrier tb1 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);
 		final TestBarrier tb2 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);

 		// Create a builder set a null scheduling rule
 		EmptyDeltaBuilder builder = EmptyDeltaBuilder.getInstance();
 		EmptyDeltaBuilder2 builder2 = EmptyDeltaBuilder2.getInstance();

 		// Set the rule call-back
 		builder.setRuleCallback(new BuilderRuleCallback() {
 			@Override
 			public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
 				tb1.setStatus(TestBarrier.STATUS_START);
 				return project;
 			}

 			@Override
 			public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
 				// shared scheduling rule
 				assertTrue(Job.getJobManager().currentRule().contains(project));
 				tb1.setStatus(TestBarrier.STATUS_RUNNING);
 				tb1.waitForStatus(TestBarrier.STATUS_WAIT_FOR_DONE);
 				tb1.setStatus(TestBarrier.STATUS_DONE);
 				return super.build(kind, args, monitor);
 			}
 		});
 		// Set the rule call-back
 		builder2.setRuleCallback(new BuilderRuleCallback() {
 			@Override
 			public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
 				// get rule is called before starting
 				tb2.setStatus(TestBarrier.STATUS_START);
 				return null;
 			}

 			@Override
 			public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
 				// shared scheduling rule
 				assertTrue(Job.getJobManager().currentRule() == null || Job.getJobManager().currentRule().contains(getWorkspace().getRoot()));
 				tb2.setStatus(TestBarrier.STATUS_RUNNING);
 				tb2.waitForStatus(TestBarrier.STATUS_WAIT_FOR_DONE);
 				tb2.setStatus(TestBarrier.STATUS_DONE);
 				return super.build(kind, args, monitor);
 			}
 		});

 		// Run the build
 		Job j = new Job("build job1") {
 			@Override
 			protected IStatus run(IProgressMonitor monitor) {
 				try {
 					project.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
 				} catch (CoreException e) {
 					fail();
 				}
 				return Status.OK_STATUS;
 			}
 		};
 		j.schedule();

 		// Wait for the build to transition

 		tb1.waitForStatus(TestBarrier.STATUS_RUNNING);
 		tb1.setStatus(TestBarrier.STATUS_WAIT_FOR_DONE);
 		tb1.waitForStatus(TestBarrier.STATUS_DONE);

 		tb2.waitForStatus(TestBarrier.STATUS_RUNNING);
 		tb2.setStatus(TestBarrier.STATUS_WAIT_FOR_DONE);
 		tb2.waitForStatus(TestBarrier.STATUS_DONE);
 	}

 	HashSet<ISchedulingRule> getRulesAsSet(ISchedulingRule rule) {
 		HashSet<ISchedulingRule> rules = new HashSet<>();
 		if (rule == null) {
 			return rules;
 		}
 		if (rule instanceof MultiRule) {
 			rules.addAll(Arrays.asList(((MultiRule) rule).getChildren()));
 		} else {
 			rules.add(rule);
 		}
 		return rules;
 	}

 	/**
 	 * As the builder is run with a relaxed scheduling rule, we ensure that any changes made before
 	 * the build is actually run are present in the delta.
 	 * Acquiring the scheduling rule must be done outside of the WS lock, so this tests that
 	 * a change which sneaks in during the window or the build thread acquiring its scheduling
 	 * rule, is correctly present in the builder's delta.
 	 * @throws Exception
 	 */
 	public void testBuilderDeltaUsingRelaxedRuleBug343256() throws Exception {
 		String name = "testBuildDeltaUsingRelaxedRuleBug343256";
 		setAutoBuilding(false);
 		final IProject project = getWorkspace().getRoot().getProject(name);
 		final IFile foo = project.getFile("foo");
 		create(project, false);

 		IProjectDescription desc = project.getDescription();
 		desc.setBuildSpec(new ICommand[] {createCommand(desc, EmptyDeltaBuilder.BUILDER_NAME, "Project1Build1")});
 		project.setDescription(desc, getMonitor());

 		// Ensure the builder is instantiated
 		project.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());

 		final TestBarrier tb1 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);

 		// Create a builder set a null scheduling rule
 		EmptyDeltaBuilder builder = EmptyDeltaBuilder.getInstance();

 		// Set the rule call-back
 		builder.setRuleCallback(new BuilderRuleCallback() {

 			boolean called = false;

 			@Override
 			public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
 				// Remove once Bug 331187 is fixed.
 				// Currently #getRule is called twice when building a specific build configuration (so as to minimized change in
 				// 3.7 end-game.  As this test is trying to provoke a bug in the window between fetching a rule and applying it
 				// to the build, we don't want to run the first time #getRule is called (in Workspace#build)
 				if (!called) {
 					called = true;
 					return project;
 				}
 				// REMOVE
 				tb1.setStatus(TestBarrier.STATUS_START);
 				tb1.waitForStatus(TestBarrier.STATUS_WAIT_FOR_RUN);
 				try {
 					// Give the resource modification time be queued
 					Thread.sleep(10);
 				} catch (InterruptedException e) {
 					fail();
 				}
 				return project;
 			}

 			@Override
 			public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
 				// shared scheduling rule
 				assertTrue(Job.getJobManager().currentRule().equals(project));
 				// assert that the delta contains the file foo
 				IResourceDelta delta = getDelta(project);
 				assertNotNull("1.1", delta);
 				assertTrue("1.2", delta.getAffectedChildren().length == 1);
 				assertTrue("1.3", delta.getAffectedChildren()[0].getResource().equals(foo));
 				tb1.setStatus(TestBarrier.STATUS_DONE);
 				return super.build(kind, args, monitor);
 			}
 		});

 		// Run the incremental build
 		Job j = new Job("IProject.build()") {
 			@Override
 			protected IStatus run(IProgressMonitor monitor) {
 				try {
 					getWorkspace().build(new IBuildConfiguration[] {project.getActiveBuildConfig()}, IncrementalProjectBuilder.INCREMENTAL_BUILD, true, monitor);
 				} catch (CoreException e) {
 					fail();
 				}
 				return Status.OK_STATUS;
 			}
 		};
 		j.schedule();

 		// Wait for the build to transition to getRule
 		tb1.waitForStatus(TestBarrier.STATUS_START);
 		// Modify a file in the project
 		j = new Job("IProject.build()") {
 			@Override
 			protected IStatus run(IProgressMonitor monitor) {
 				tb1.setStatus(TestBarrier.STATUS_WAIT_FOR_RUN);
 				ensureExistsInWorkspace(foo, new ByteArrayInputStream(new byte[0]));
 				return Status.OK_STATUS;
 			}
 		};
 		j.schedule();
 		tb1.waitForStatus(TestBarrier.STATUS_DONE);
 	}

 	/**
 	 * Tests for regression in running the build with reduced scheduling rules.
 	 * @throws Exception
 	 */
 	public void testBug343256() throws Exception {
 		String name = "testBug343256";
 		setAutoBuilding(false);
 		final IProject project = getWorkspace().getRoot().getProject(name);
 		create(project, false);

 		IProjectDescription desc = project.getDescription();
 		desc.setBuildSpec(new ICommand[] {createCommand(desc, EmptyDeltaBuilder.BUILDER_NAME, "Project1Build1"), createCommand(desc, EmptyDeltaBuilder2.BUILDER_NAME, "Project1Build2")});
 		project.setDescription(desc, getMonitor());

 		// Ensure the builder is instantiated
 		project.build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());

 		final TestBarrier tb1 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);
 		final TestBarrier tb2 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);

 		// Scheduling rules to returng from #getRule
 		final ISchedulingRule[] getRules = new ISchedulingRule[2];
 		final ISchedulingRule[] buildRules = new ISchedulingRule[2];

 		// Create a builder set a null scheduling rule
 		EmptyDeltaBuilder builder = EmptyDeltaBuilder.getInstance();
 		EmptyDeltaBuilder2 builder2 = EmptyDeltaBuilder2.getInstance();

 		// Set the rule call-back
 		builder.setRuleCallback(new BuilderRuleCallback() {
 			@Override
 			public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
 				tb1.waitForStatus(TestBarrier.STATUS_START);
 				return getRules[0];
 			}

 			@Override
 			public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
 				HashSet<ISchedulingRule> h1 = getRulesAsSet(Job.getJobManager().currentRule());
 				HashSet<ISchedulingRule> h2 = getRulesAsSet(buildRules[0]);
 				// shared scheduling rule
 				assertTrue(h1.equals(h2));
 				tb1.setStatus(TestBarrier.STATUS_DONE);
 				return super.build(kind, args, monitor);
 			}
 		});
 		// Set the rule call-back
 		builder2.setRuleCallback(new BuilderRuleCallback() {
 			@Override
 			public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
 				tb2.waitForStatus(TestBarrier.STATUS_START);
 				return getRules[1];
 			}

 			@Override
 			public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
 				HashSet<ISchedulingRule> h1 = getRulesAsSet(Job.getJobManager().currentRule());
 				HashSet<ISchedulingRule> h2 = getRulesAsSet(buildRules[1]);
 				assertTrue(h1.equals(h2));
 				tb2.setStatus(TestBarrier.STATUS_DONE);
 				return super.build(kind, args, monitor);
 			}
 		});

 		Job j;

 		// Enable for Bug 331187
 		//		// IProject.build()
 		//		j = new Job("IProject.build()") {
 		//			protected IStatus run(IProgressMonitor monitor) {
 		//				try {
 		//					project.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
 		//				} catch (CoreException e) {
 		//					fail(e.toString());
 		//				}
 		//				return Status.OK_STATUS;
 		//			}
 		//		};
 		//		invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);

 		//		// IWorkspace.build()
 		//		j = new Job("IWorkspace.build()") {
 		//			protected IStatus run(IProgressMonitor monitor) {
 		//				try {
 		//					getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, monitor);
 		//				} catch (CoreException e) {
 		//					fail(e.toString());
 		//				}
 		//				return Status.OK_STATUS;
 		//			}
 		//		};
 		//		invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);

 		// IWorkspace.build(IBuildConfiguration[],...)
 		j = new Job("IWorkspace.build(IBuildConfiguration[],...)") {
 			@Override
 			protected IStatus run(IProgressMonitor monitor) {
 				try {
 					getWorkspace().build(new IBuildConfiguration[] {project.getActiveBuildConfig()}, IncrementalProjectBuilder.FULL_BUILD, true, monitor);
 				} catch (CoreException e) {
 					fail(e.toString());
 				}
 				return Status.OK_STATUS;
 			}
 		};
 		invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);

 		// Test Auto-build
 		//		j = new Job("Auto-build") {
 		//			protected IStatus run(IProgressMonitor monitor) {
 		//				try {
 		//					getWorkspace().build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());
 		//				} catch (CoreException e) {
 		//					fail(e.toString());
 		//				}
 		//				return Status.OK_STATUS;
 		//			}
 		//		};
 		//		// Auto-build
 		//		setAutoBuilding(true);
 		//		// Wait for the build to transition
 		//		invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);
 	}

 	/**
 	 * Helper method do invoke a set of tests on Bug343256 using the different sets of builder API
 	 */
 	private void invokeTestBug343256(IProject project, ISchedulingRule[] getRules, ISchedulingRule[] buildRules, TestBarrier tb1, TestBarrier tb2, Job j) {
 		// Test 1 - build project sched rule
 		getRules[0] = getRules[1] = project;
 		buildRules[0] = buildRules[1] = new MultiRule(new ISchedulingRule[] {getRules[0]});
 		tb1.setStatus(TestBarrier.STATUS_START);
 		tb2.setStatus(TestBarrier.STATUS_START);
 		j.schedule();
 		tb1.waitForStatus(TestBarrier.STATUS_DONE);
 		tb2.waitForStatus(TestBarrier.STATUS_DONE);

 		// Test 2 - build null rule
 		getRules[0] = getRules[1] = null;
 		buildRules[0] = buildRules[1] = null;
 		tb1.setStatus(TestBarrier.STATUS_START);
 		tb2.setStatus(TestBarrier.STATUS_START);
 		j.schedule();
 		tb1.waitForStatus(TestBarrier.STATUS_DONE);
 		tb2.waitForStatus(TestBarrier.STATUS_DONE);

 		// Test 3 - build mixed projects
 		getRules[0] = buildRules[0] = project;
 		getRules[1] = buildRules[1] = getWorkspace().getRoot().getProject("other");
 		tb1.setStatus(TestBarrier.STATUS_START);
 		tb2.setStatus(TestBarrier.STATUS_START);
 		j.schedule();
 		tb1.waitForStatus(TestBarrier.STATUS_DONE);
 		tb2.waitForStatus(TestBarrier.STATUS_DONE);

 		// Test 4 - build project + null
 		getRules[0] = buildRules[0] = project;
 		getRules[1] = buildRules[1] = null;
 		// TODO: Fixed in Bug 331187 ; BuildManager#getRule is pessimistic when there's a mixed resource and null rule
 		buildRules[0] = buildRules[1] = getWorkspace().getRoot();
 		tb1.setStatus(TestBarrier.STATUS_START);
 		tb2.setStatus(TestBarrier.STATUS_START);
 		j.schedule();
 		tb1.waitForStatus(TestBarrier.STATUS_DONE);
 		tb2.waitForStatus(TestBarrier.STATUS_DONE);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2010, 2015 Broadcom 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:
	* James Blackburn (Broadcom Corp.) - initial API and implementation
	* Alexander Kurtakov <akurtako@redhat.com> - Bug 459343
	*******************************************************************************/
	package org.eclipse.core.tests.internal.builders;

	import java.io.ByteArrayInputStream;
	import java.util.*;
	import junit.framework.Test;
	import junit.framework.TestSuite;
	import org.eclipse.core.resources.*;
	import org.eclipse.core.runtime.*;
	import org.eclipse.core.runtime.jobs.*;
	import org.eclipse.core.tests.harness.TestBarrier;
	import org.eclipse.core.tests.internal.builders.TestBuilder.BuilderRuleCallback;

	/**
	* This class tests extended functionality (since 3.6) which allows
	* builders to be run with reduced (non-Workspace) scheduling rules.
	*
	* When one of these builders runs, other threads may modify the workspace
	* depending on the builder's scheduling rule
	*/
	public class RelaxedSchedRuleBuilderTest extends AbstractBuilderTest {
	public static Test suite() {
	return new TestSuite(RelaxedSchedRuleBuilderTest.class);
	}

	public RelaxedSchedRuleBuilderTest() {
	super(null);
	}

	public RelaxedSchedRuleBuilderTest(String name) {
	super(name);
	}

	@Override
	protected void setUp() throws Exception {
	super.setUp();
	}

	@Override
	protected void tearDown() throws Exception {
	super.tearDown();
	getWorkspace().getRoot().delete(true, null);
	TestBuilder builder = DeltaVerifierBuilder.getInstance();
	if (builder != null) {
	builder.reset();
	}
	builder = EmptyDeltaBuilder.getInstance();
	if (builder != null) {
	builder.reset();
	}
	builder = EmptyDeltaBuilder2.getInstance();
	if (builder != null) {
	builder.reset();
	}
	}

	/**
	* Test a simple builder with a relaxed scheduling rule
	* @throws Exception
	*/
	public void testBasicRelaxedSchedulingRules() throws Exception {
	String name = "TestRelaxed";
	setAutoBuilding(false);
	final IProject project = getWorkspace().getRoot().getProject(name);
	create(project, false);
	addBuilder(project, EmptyDeltaBuilder.BUILDER_NAME);

	// Ensure the builder is instantiated
	project.build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());

	final TestBarrier tb = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);

	// Create a builder set a null scheduling rule
	EmptyDeltaBuilder builder = EmptyDeltaBuilder.getInstance();
	builder.setRuleCallback(new BuilderRuleCallback() {
	@Override
	public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
	return null;
	}

	@Override
	public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
	assertTrue(Job.getJobManager().currentRule() == null);
	tb.setStatus(TestBarrier.STATUS_START);
	while (!monitor.isCanceled()) {
	try {
	Thread.sleep(10);
	} catch (InterruptedException e) {
	// Don't care
	}
	}
	tb.setStatus(TestBarrier.STATUS_DONE);
	return super.build(kind, args, monitor);
	}
	});

	Job j = new Job("build job") {
	@Override
	protected IStatus run(IProgressMonitor monitor) {
	try {
	project.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
	} catch (CoreException e) {
	fail();
	}
	return Status.OK_STATUS;
	}
	};
	j.schedule();

	// wait for build to be called
	tb.waitForStatus(TestBarrier.STATUS_START);

	// Should be able to write a file in the project
	create(project.getFile("foo.c"), false);
	assertTrue(project.getFile("foo.c").exists());

	// Cancel the builder
	j.cancel();
	tb.waitForStatus(TestBarrier.STATUS_DONE);
	}

	/**
	* Test two builders, each with relaxed scheduling rules, run in the same build operation
	* Each should be run with their own scheduling rule.
	* Tests:
	* Bug 306824 - null scheduling rule and non-null scheduling rule don't work together
	* Builders should have separate scheduling rules
	* @throws Exception
	*/
	public void testTwoBuildersRunInOneBuild() throws Exception {
	String name = "testTwoBuildersRunInOneBuild";
	setAutoBuilding(false);
	final IProject project = getWorkspace().getRoot().getProject(name);
	create(project, false);

	IProjectDescription desc = project.getDescription();
	desc.setBuildSpec(new ICommand[] {createCommand(desc, EmptyDeltaBuilder.BUILDER_NAME, "Project1Build1"), createCommand(desc, EmptyDeltaBuilder2.BUILDER_NAME, "Project1Build2")});
	project.setDescription(desc, getMonitor());

	// Ensure the builder is instantiated
	project.build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());

	final TestBarrier tb1 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);
	final TestBarrier tb2 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);

	// Create a builder set a null scheduling rule
	EmptyDeltaBuilder builder = EmptyDeltaBuilder.getInstance();
	EmptyDeltaBuilder2 builder2 = EmptyDeltaBuilder2.getInstance();

	// Set the rule call-back
	builder.setRuleCallback(new BuilderRuleCallback() {
	@Override
	public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
	tb1.setStatus(TestBarrier.STATUS_START);
	return project;
	}

	@Override
	public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
	// shared scheduling rule
	assertTrue(Job.getJobManager().currentRule().contains(project));
	tb1.setStatus(TestBarrier.STATUS_RUNNING);
	tb1.waitForStatus(TestBarrier.STATUS_WAIT_FOR_DONE);
	tb1.setStatus(TestBarrier.STATUS_DONE);
	return super.build(kind, args, monitor);
	}
	});
	// Set the rule call-back
	builder2.setRuleCallback(new BuilderRuleCallback() {
	@Override
	public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
	// get rule is called before starting
	tb2.setStatus(TestBarrier.STATUS_START);
	return null;
	}

	@Override
	public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
	// shared scheduling rule
	assertTrue(Job.getJobManager().currentRule() == null \|\| Job.getJobManager().currentRule().contains(getWorkspace().getRoot()));
	tb2.setStatus(TestBarrier.STATUS_RUNNING);
	tb2.waitForStatus(TestBarrier.STATUS_WAIT_FOR_DONE);
	tb2.setStatus(TestBarrier.STATUS_DONE);
	return super.build(kind, args, monitor);
	}
	});

	// Run the build
	Job j = new Job("build job1") {
	@Override
	protected IStatus run(IProgressMonitor monitor) {
	try {
	project.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
	} catch (CoreException e) {
	fail();
	}
	return Status.OK_STATUS;
	}
	};
	j.schedule();

	// Wait for the build to transition

	tb1.waitForStatus(TestBarrier.STATUS_RUNNING);
	tb1.setStatus(TestBarrier.STATUS_WAIT_FOR_DONE);
	tb1.waitForStatus(TestBarrier.STATUS_DONE);

	tb2.waitForStatus(TestBarrier.STATUS_RUNNING);
	tb2.setStatus(TestBarrier.STATUS_WAIT_FOR_DONE);
	tb2.waitForStatus(TestBarrier.STATUS_DONE);
	}

	HashSet<ISchedulingRule> getRulesAsSet(ISchedulingRule rule) {
	HashSet<ISchedulingRule> rules = new HashSet<>();
	if (rule == null) {
	return rules;
	}
	if (rule instanceof MultiRule) {
	rules.addAll(Arrays.asList(((MultiRule) rule).getChildren()));
	} else {
	rules.add(rule);
	}
	return rules;
	}

	/**
	* As the builder is run with a relaxed scheduling rule, we ensure that any changes made before
	* the build is actually run are present in the delta.
	* Acquiring the scheduling rule must be done outside of the WS lock, so this tests that
	* a change which sneaks in during the window or the build thread acquiring its scheduling
	* rule, is correctly present in the builder's delta.
	* @throws Exception
	*/
	public void testBuilderDeltaUsingRelaxedRuleBug343256() throws Exception {
	String name = "testBuildDeltaUsingRelaxedRuleBug343256";
	setAutoBuilding(false);
	final IProject project = getWorkspace().getRoot().getProject(name);
	final IFile foo = project.getFile("foo");
	create(project, false);

	IProjectDescription desc = project.getDescription();
	desc.setBuildSpec(new ICommand[] {createCommand(desc, EmptyDeltaBuilder.BUILDER_NAME, "Project1Build1")});
	project.setDescription(desc, getMonitor());

	// Ensure the builder is instantiated
	project.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());

	final TestBarrier tb1 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);

	// Create a builder set a null scheduling rule
	EmptyDeltaBuilder builder = EmptyDeltaBuilder.getInstance();

	// Set the rule call-back
	builder.setRuleCallback(new BuilderRuleCallback() {

	boolean called = false;

	@Override
	public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
	// Remove once Bug 331187 is fixed.
	// Currently #getRule is called twice when building a specific build configuration (so as to minimized change in
	// 3.7 end-game. As this test is trying to provoke a bug in the window between fetching a rule and applying it
	// to the build, we don't want to run the first time #getRule is called (in Workspace#build)
	if (!called) {
	called = true;
	return project;
	}
	// REMOVE
	tb1.setStatus(TestBarrier.STATUS_START);
	tb1.waitForStatus(TestBarrier.STATUS_WAIT_FOR_RUN);
	try {
	// Give the resource modification time be queued
	Thread.sleep(10);
	} catch (InterruptedException e) {
	fail();
	}
	return project;
	}

	@Override
	public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
	// shared scheduling rule
	assertTrue(Job.getJobManager().currentRule().equals(project));
	// assert that the delta contains the file foo
	IResourceDelta delta = getDelta(project);
	assertNotNull("1.1", delta);
	assertTrue("1.2", delta.getAffectedChildren().length == 1);
	assertTrue("1.3", delta.getAffectedChildren()[0].getResource().equals(foo));
	tb1.setStatus(TestBarrier.STATUS_DONE);
	return super.build(kind, args, monitor);
	}
	});

	// Run the incremental build
	Job j = new Job("IProject.build()") {
	@Override
	protected IStatus run(IProgressMonitor monitor) {
	try {
	getWorkspace().build(new IBuildConfiguration[] {project.getActiveBuildConfig()}, IncrementalProjectBuilder.INCREMENTAL_BUILD, true, monitor);
	} catch (CoreException e) {
	fail();
	}
	return Status.OK_STATUS;
	}
	};
	j.schedule();

	// Wait for the build to transition to getRule
	tb1.waitForStatus(TestBarrier.STATUS_START);
	// Modify a file in the project
	j = new Job("IProject.build()") {
	@Override
	protected IStatus run(IProgressMonitor monitor) {
	tb1.setStatus(TestBarrier.STATUS_WAIT_FOR_RUN);
	ensureExistsInWorkspace(foo, new ByteArrayInputStream(new byte[0]));
	return Status.OK_STATUS;
	}
	};
	j.schedule();
	tb1.waitForStatus(TestBarrier.STATUS_DONE);
	}

	/**
	* Tests for regression in running the build with reduced scheduling rules.
	* @throws Exception
	*/
	public void testBug343256() throws Exception {
	String name = "testBug343256";
	setAutoBuilding(false);
	final IProject project = getWorkspace().getRoot().getProject(name);
	create(project, false);

	IProjectDescription desc = project.getDescription();
	desc.setBuildSpec(new ICommand[] {createCommand(desc, EmptyDeltaBuilder.BUILDER_NAME, "Project1Build1"), createCommand(desc, EmptyDeltaBuilder2.BUILDER_NAME, "Project1Build2")});
	project.setDescription(desc, getMonitor());

	// Ensure the builder is instantiated
	project.build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());

	final TestBarrier tb1 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);
	final TestBarrier tb2 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);

	// Scheduling rules to returng from #getRule
	final ISchedulingRule[] getRules = new ISchedulingRule[2];
	final ISchedulingRule[] buildRules = new ISchedulingRule[2];

	// Create a builder set a null scheduling rule
	EmptyDeltaBuilder builder = EmptyDeltaBuilder.getInstance();
	EmptyDeltaBuilder2 builder2 = EmptyDeltaBuilder2.getInstance();

	// Set the rule call-back
	builder.setRuleCallback(new BuilderRuleCallback() {
	@Override
	public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
	tb1.waitForStatus(TestBarrier.STATUS_START);
	return getRules[0];
	}

	@Override
	public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
	HashSet<ISchedulingRule> h1 = getRulesAsSet(Job.getJobManager().currentRule());
	HashSet<ISchedulingRule> h2 = getRulesAsSet(buildRules[0]);
	// shared scheduling rule
	assertTrue(h1.equals(h2));
	tb1.setStatus(TestBarrier.STATUS_DONE);
	return super.build(kind, args, monitor);
	}
	});
	// Set the rule call-back
	builder2.setRuleCallback(new BuilderRuleCallback() {
	@Override
	public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
	tb2.waitForStatus(TestBarrier.STATUS_START);
	return getRules[1];
	}

	@Override
	public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
	HashSet<ISchedulingRule> h1 = getRulesAsSet(Job.getJobManager().currentRule());
	HashSet<ISchedulingRule> h2 = getRulesAsSet(buildRules[1]);
	assertTrue(h1.equals(h2));
	tb2.setStatus(TestBarrier.STATUS_DONE);
	return super.build(kind, args, monitor);
	}
	});

	Job j;

	// Enable for Bug 331187
	// // IProject.build()
	// j = new Job("IProject.build()") {
	// protected IStatus run(IProgressMonitor monitor) {
	// try {
	// project.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
	// } catch (CoreException e) {
	// fail(e.toString());
	// }
	// return Status.OK_STATUS;
	// }
	// };
	// invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);

	// // IWorkspace.build()
	// j = new Job("IWorkspace.build()") {
	// protected IStatus run(IProgressMonitor monitor) {
	// try {
	// getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, monitor);
	// } catch (CoreException e) {
	// fail(e.toString());
	// }
	// return Status.OK_STATUS;
	// }
	// };
	// invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);

	// IWorkspace.build(IBuildConfiguration[],...)
	j = new Job("IWorkspace.build(IBuildConfiguration[],...)") {
	@Override
	protected IStatus run(IProgressMonitor monitor) {
	try {
	getWorkspace().build(new IBuildConfiguration[] {project.getActiveBuildConfig()}, IncrementalProjectBuilder.FULL_BUILD, true, monitor);
	} catch (CoreException e) {
	fail(e.toString());
	}
	return Status.OK_STATUS;
	}
	};
	invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);

	// Test Auto-build
	// j = new Job("Auto-build") {
	// protected IStatus run(IProgressMonitor monitor) {
	// try {
	// getWorkspace().build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());
	// } catch (CoreException e) {
	// fail(e.toString());
	// }
	// return Status.OK_STATUS;
	// }
	// };
	// // Auto-build
	// setAutoBuilding(true);
	// // Wait for the build to transition
	// invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);
	}

	/**
	* Helper method do invoke a set of tests on Bug343256 using the different sets of builder API
	*/
	private void invokeTestBug343256(IProject project, ISchedulingRule[] getRules, ISchedulingRule[] buildRules, TestBarrier tb1, TestBarrier tb2, Job j) {
	// Test 1 - build project sched rule
	getRules[0] = getRules[1] = project;
	buildRules[0] = buildRules[1] = new MultiRule(new ISchedulingRule[] {getRules[0]});
	tb1.setStatus(TestBarrier.STATUS_START);
	tb2.setStatus(TestBarrier.STATUS_START);
	j.schedule();
	tb1.waitForStatus(TestBarrier.STATUS_DONE);
	tb2.waitForStatus(TestBarrier.STATUS_DONE);

	// Test 2 - build null rule
	getRules[0] = getRules[1] = null;
	buildRules[0] = buildRules[1] = null;
	tb1.setStatus(TestBarrier.STATUS_START);
	tb2.setStatus(TestBarrier.STATUS_START);
	j.schedule();
	tb1.waitForStatus(TestBarrier.STATUS_DONE);
	tb2.waitForStatus(TestBarrier.STATUS_DONE);

	// Test 3 - build mixed projects
	getRules[0] = buildRules[0] = project;
	getRules[1] = buildRules[1] = getWorkspace().getRoot().getProject("other");
	tb1.setStatus(TestBarrier.STATUS_START);
	tb2.setStatus(TestBarrier.STATUS_START);
	j.schedule();
	tb1.waitForStatus(TestBarrier.STATUS_DONE);
	tb2.waitForStatus(TestBarrier.STATUS_DONE);

	// Test 4 - build project + null
	getRules[0] = buildRules[0] = project;
	getRules[1] = buildRules[1] = null;
	// TODO: Fixed in Bug 331187 ; BuildManager#getRule is pessimistic when there's a mixed resource and null rule
	buildRules[0] = buildRules[1] = getWorkspace().getRoot();
	tb1.setStatus(TestBarrier.STATUS_START);
	tb2.setStatus(TestBarrier.STATUS_START);
	j.schedule();
	tb1.waitForStatus(TestBarrier.STATUS_DONE);
	tb2.waitForStatus(TestBarrier.STATUS_DONE);
	}
	}