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

 /*******************************************************************************
  * Copyright (c) 2004, 2017 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 - Initial API and implementation
  *******************************************************************************/
 package org.eclipse.core.tests.internal.resources;

 import junit.framework.Test;
 import junit.framework.TestSuite;
 import org.eclipse.core.resources.*;
 import org.eclipse.core.runtime.*;
 import org.eclipse.core.runtime.jobs.ISchedulingRule;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.core.tests.harness.CancelingProgressMonitor;
 import org.eclipse.core.tests.harness.TestBarrier;
 import org.eclipse.core.tests.resources.ResourceTest;

 /**
  * Tests concurrency issues when dealing with operations on the workspace
  */
 public class WorkspaceConcurrencyTest extends ResourceTest {

 	public static Test suite() {
 		return new TestSuite(WorkspaceConcurrencyTest.class);
 	}

 	public WorkspaceConcurrencyTest() {
 		super("");
 	}

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

 	private void sleep(long duration) {
 		try {
 			Thread.sleep(duration);
 		} catch (InterruptedException e) {
 			//ignore
 		}
 	}

 	public void testEndRuleInWorkspaceOperation() {
 		try {
 			final IProject project = getWorkspace().getRoot().getProject("testEndRuleInWorkspaceOperation");
 			getWorkspace().run((IWorkspaceRunnable) monitor -> Job.getJobManager().endRule(project), project, IResource.NONE, getMonitor());
 			//should have failed
 			fail("1.0");
 		} catch (CoreException e) {
 			fail("1.99", e);
 		} catch (RuntimeException e) {
 			//expected
 		}
 	}

 	/**
 	 * Tests that it is possible to cancel a workspace operation when it is blocked
 	 * by activity in another thread. This is a regression test for bug 56118.
 	 */
 	public void testCancelOnBlocked() {
 		//create a dummy project
 		ensureExistsInWorkspace(getWorkspace().getRoot().getProject("P1"), true);
 		//add a resource change listener that blocks forever, thus
 		//simulating a scenario where workspace lock is held indefinitely
 		final int[] barrier = new int[1];
 		final Throwable[] error = new Throwable[1];
 		IResourceChangeListener listener = event -> {
 			//block until we are told to do otherwise
 			barrier[0] = TestBarrier.STATUS_START;
 			try {
 				TestBarrier.waitForStatus(barrier, TestBarrier.STATUS_DONE);
 			} catch (Throwable e) {
 				error[0] = e;
 			}
 		};
 		getWorkspace().addResourceChangeListener(listener);
 		try {
 			//create a thread that modifies the workspace. This should
 			//hang indefinitely due to the misbehaving listener
 			TestWorkspaceJob testJob = new TestWorkspaceJob(10);
 			testJob.setTouch(true);
 			testJob.setRule(getWorkspace().getRoot());
 			testJob.schedule();

 			//wait until blocked on the listener
 			TestBarrier.waitForStatus(barrier, TestBarrier.STATUS_START);

 			//create a second thread that attempts to modify the workspace, but immediately
 			//cancels itself. This thread should terminate immediately with a cancelation exception
 			final boolean[] canceled = new boolean[] {false};
 			Thread t2 = new Thread(() -> {
 				try {
 					getWorkspace().run((IWorkspaceRunnable) monitor -> {
 						//no-op
 					}, new CancelingProgressMonitor());
 				} catch (CoreException e1) {
 					fail("1.99", e1);
 				} catch (OperationCanceledException e2) {
 					canceled[0] = true;
 				}
 			});
 			t2.start();
 			try {
 				t2.join();
 			} catch (InterruptedException e) {
 				fail("1.88", e);
 			}
 			//should have canceled
 			assertTrue("2.0", canceled[0]);

 			//finally release the listener and ensure the first thread completes
 			barrier[0] = TestBarrier.STATUS_DONE;
 			try {
 				testJob.join();
 			} catch (InterruptedException e1) {
 				//ignore
 			}
 			if (error[0] != null) {
 				fail("3.0", error[0]);
 			}
 		} finally {
 			getWorkspace().removeResourceChangeListener(listener);
 		}
 	}

 	/**
 	 * Tests calling IWorkspace.run with a non-workspace rule.  This should be
 	 * allowed. This is a regression test for bug 60114.
 	 */
 	public void testRunnableWithOtherRule() {
 		ISchedulingRule rule = new ISchedulingRule() {
 			@Override
 			public boolean contains(ISchedulingRule rule) {
 				return rule == this;
 			}

 			@Override
 			public boolean isConflicting(ISchedulingRule rule) {
 				return rule == this;
 			}
 		};
 		try {
 			getWorkspace().run((IWorkspaceRunnable) monitor -> {
 				//noop
 			}, rule, IResource.NONE, getMonitor());
 		} catch (CoreException e) {
 			fail("1.99", e);
 		}
 	}

 	/**
 	 * Tests three overlapping jobs
 	 *  - Job 1 (root rule) does a build.
 	 *  - Job 2 (null rule) overlaps Job 1 and has null scheduling rule
 	 *  - Job 3 (project rule) overlaps Job 2
 	 *
 	 * The POST_BUILD event should occur at the end of Job 1. If it
 	 * is delayed until the end of Job 3, an appropriate scheduling rule
 	 * will not be available and it will fail.
 	 * This is a regression test for bug 	62927.
 	 */
 	public void testRunWhileBuilding() {
 		final IWorkspace workspace = ResourcesPlugin.getWorkspace();
 		//create a POST_BUILD listener that will touch a project
 		final IProject touch = workspace.getRoot().getProject("ToTouch");
 		final IProject rule = workspace.getRoot().getProject("jobThree");
 		final IFile ruleFile = rule.getFile("somefile.txt");
 		ensureExistsInWorkspace(rule, true);
 		ensureExistsInWorkspace(touch, true);
 		ensureExistsInWorkspace(ruleFile, true);
 		final Throwable[] failure = new Throwable[1];
 		IResourceChangeListener listener = event -> {
 			try {
 				touch.touch(null);
 			} catch (CoreException e1) {
 				failure[0] = e1;
 			} catch (RuntimeException e2) {
 				failure[0] = e2;
 			}
 		};
 		workspace.addResourceChangeListener(listener, IResourceChangeEvent.POST_BUILD);
 		try {
 			//create one job that does a build, and then waits
 			final int[] status = new int[3];
 			Job jobOne = new Job("jobOne") {
 				@Override
 				protected IStatus run(IProgressMonitor monitor) {
 					try {
 						workspace.run((IWorkspaceRunnable) monitor1 -> {
 							//do a build
 							workspace.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor1);
 							//signal that the job has done the build
 							status[0] = TestBarrier.STATUS_RUNNING;
 							//wait for job two to start
 							TestBarrier.waitForStatus(status, 0, TestBarrier.STATUS_WAIT_FOR_DONE);
 						}, null);
 					} catch (CoreException e) {
 						return e.getStatus();
 					}
 					return Status.OK_STATUS;
 				}
 			};
 			//schedule and wait for job one to start
 			jobOne.schedule();
 			TestBarrier.waitForStatus(status, 0, TestBarrier.STATUS_RUNNING);

 			//create job two that does an empty workspace operation
 			Job jobTwo = new Job("jobTwo") {
 				@Override
 				protected IStatus run(IProgressMonitor monitor) {
 					try {
 						workspace.run((IWorkspaceRunnable) monitor1 -> {
 							//signal that this job has started
 							status[1] = TestBarrier.STATUS_RUNNING;
 							//let job one finish
 							status[0] = TestBarrier.STATUS_WAIT_FOR_DONE;
 							//wait for job three to start
 							TestBarrier.waitForStatus(status, 1, TestBarrier.STATUS_WAIT_FOR_DONE);
 						}, null, IResource.NONE, null);
 					} catch (CoreException e) {
 						return e.getStatus();
 					}
 					return Status.OK_STATUS;
 				}
 			};
 			jobTwo.schedule();
 			//create job three that has a non-null rule
 			Job jobThree = new Job("jobThree") {
 				@Override
 				protected IStatus run(IProgressMonitor monitor) {
 					try {
 						workspace.run((IWorkspaceRunnable) monitor1 -> {
 							//signal that this job has started
 							status[2] = TestBarrier.STATUS_RUNNING;
 							//let job two finish
 							status[1] = TestBarrier.STATUS_WAIT_FOR_DONE;
 							//ensure this job does something so the build listener runs
 							ruleFile.touch(null);
 							//wait for the ok to complete
 							TestBarrier.waitForStatus(status, 2, TestBarrier.STATUS_WAIT_FOR_DONE);
 						}, workspace.getRuleFactory().modifyRule(ruleFile), IResource.NONE, null);
 					} catch (CoreException e) {
 						return e.getStatus();
 					}
 					return Status.OK_STATUS;
 				}
 			};
 			jobThree.schedule();
 			//wait for job two to complete
 			waitForCompletion(jobTwo);

 			//let job three complete
 			status[2] = TestBarrier.STATUS_WAIT_FOR_DONE;

 			//wait for job three to complete
 			waitForCompletion(jobThree);

 			//ensure no jobs failed
 			IStatus result = jobOne.getResult();
 			if (!result.isOK()) {
 				fail("1.0", new CoreException(result));
 			}
 			result = jobTwo.getResult();
 			if (!result.isOK()) {
 				fail("1.1", new CoreException(result));
 			}
 			result = jobThree.getResult();
 			if (!result.isOK()) {
 				fail("1.2", new CoreException(result));
 			}

 			if (failure[0] != null) {
 				fail("1.3", failure[0]);
 			}
 		} finally {
 			//ensure listener is removed
 			workspace.removeResourceChangeListener(listener);
 		}
 	}

 	private void waitForCompletion(Job job) {
 		int i = 0;
 		while (job.getState() != Job.NONE) {
 			sleep(100);
 			//sanity test to avoid hanging tests
 			assertTrue("Timeout waiting for job to complete", i++ < 1000);
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2004, 2017 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 - Initial API and implementation
	*******************************************************************************/
	package org.eclipse.core.tests.internal.resources;

	import junit.framework.Test;
	import junit.framework.TestSuite;
	import org.eclipse.core.resources.*;
	import org.eclipse.core.runtime.*;
	import org.eclipse.core.runtime.jobs.ISchedulingRule;
	import org.eclipse.core.runtime.jobs.Job;
	import org.eclipse.core.tests.harness.CancelingProgressMonitor;
	import org.eclipse.core.tests.harness.TestBarrier;
	import org.eclipse.core.tests.resources.ResourceTest;

	/**
	* Tests concurrency issues when dealing with operations on the workspace
	*/
	public class WorkspaceConcurrencyTest extends ResourceTest {

	public static Test suite() {
	return new TestSuite(WorkspaceConcurrencyTest.class);
	}

	public WorkspaceConcurrencyTest() {
	super("");
	}

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

	private void sleep(long duration) {
	try {
	Thread.sleep(duration);
	} catch (InterruptedException e) {
	//ignore
	}
	}

	public void testEndRuleInWorkspaceOperation() {
	try {
	final IProject project = getWorkspace().getRoot().getProject("testEndRuleInWorkspaceOperation");
	getWorkspace().run((IWorkspaceRunnable) monitor -> Job.getJobManager().endRule(project), project, IResource.NONE, getMonitor());
	//should have failed
	fail("1.0");
	} catch (CoreException e) {
	fail("1.99", e);
	} catch (RuntimeException e) {
	//expected
	}
	}

	/**
	* Tests that it is possible to cancel a workspace operation when it is blocked
	* by activity in another thread. This is a regression test for bug 56118.
	*/
	public void testCancelOnBlocked() {
	//create a dummy project
	ensureExistsInWorkspace(getWorkspace().getRoot().getProject("P1"), true);
	//add a resource change listener that blocks forever, thus
	//simulating a scenario where workspace lock is held indefinitely
	final int[] barrier = new int[1];
	final Throwable[] error = new Throwable[1];
	IResourceChangeListener listener = event -> {
	//block until we are told to do otherwise
	barrier[0] = TestBarrier.STATUS_START;
	try {
	TestBarrier.waitForStatus(barrier, TestBarrier.STATUS_DONE);
	} catch (Throwable e) {
	error[0] = e;
	}
	};
	getWorkspace().addResourceChangeListener(listener);
	try {
	//create a thread that modifies the workspace. This should
	//hang indefinitely due to the misbehaving listener
	TestWorkspaceJob testJob = new TestWorkspaceJob(10);
	testJob.setTouch(true);
	testJob.setRule(getWorkspace().getRoot());
	testJob.schedule();

	//wait until blocked on the listener
	TestBarrier.waitForStatus(barrier, TestBarrier.STATUS_START);

	//create a second thread that attempts to modify the workspace, but immediately
	//cancels itself. This thread should terminate immediately with a cancelation exception
	final boolean[] canceled = new boolean[] {false};
	Thread t2 = new Thread(() -> {
	try {
	getWorkspace().run((IWorkspaceRunnable) monitor -> {
	//no-op
	}, new CancelingProgressMonitor());
	} catch (CoreException e1) {
	fail("1.99", e1);
	} catch (OperationCanceledException e2) {
	canceled[0] = true;
	}
	});
	t2.start();
	try {
	t2.join();
	} catch (InterruptedException e) {
	fail("1.88", e);
	}
	//should have canceled
	assertTrue("2.0", canceled[0]);

	//finally release the listener and ensure the first thread completes
	barrier[0] = TestBarrier.STATUS_DONE;
	try {
	testJob.join();
	} catch (InterruptedException e1) {
	//ignore
	}
	if (error[0] != null) {
	fail("3.0", error[0]);
	}
	} finally {
	getWorkspace().removeResourceChangeListener(listener);
	}
	}

	/**
	* Tests calling IWorkspace.run with a non-workspace rule. This should be
	* allowed. This is a regression test for bug 60114.
	*/
	public void testRunnableWithOtherRule() {
	ISchedulingRule rule = new ISchedulingRule() {
	@Override
	public boolean contains(ISchedulingRule rule) {
	return rule == this;
	}

	@Override
	public boolean isConflicting(ISchedulingRule rule) {
	return rule == this;
	}
	};
	try {
	getWorkspace().run((IWorkspaceRunnable) monitor -> {
	//noop
	}, rule, IResource.NONE, getMonitor());
	} catch (CoreException e) {
	fail("1.99", e);
	}
	}

	/**
	* Tests three overlapping jobs
	* - Job 1 (root rule) does a build.
	* - Job 2 (null rule) overlaps Job 1 and has null scheduling rule
	* - Job 3 (project rule) overlaps Job 2
	*
	* The POST_BUILD event should occur at the end of Job 1. If it
	* is delayed until the end of Job 3, an appropriate scheduling rule
	* will not be available and it will fail.
	* This is a regression test for bug 62927.
	*/
	public void testRunWhileBuilding() {
	final IWorkspace workspace = ResourcesPlugin.getWorkspace();
	//create a POST_BUILD listener that will touch a project
	final IProject touch = workspace.getRoot().getProject("ToTouch");
	final IProject rule = workspace.getRoot().getProject("jobThree");
	final IFile ruleFile = rule.getFile("somefile.txt");
	ensureExistsInWorkspace(rule, true);
	ensureExistsInWorkspace(touch, true);
	ensureExistsInWorkspace(ruleFile, true);
	final Throwable[] failure = new Throwable[1];
	IResourceChangeListener listener = event -> {
	try {
	touch.touch(null);
	} catch (CoreException e1) {
	failure[0] = e1;
	} catch (RuntimeException e2) {
	failure[0] = e2;
	}
	};
	workspace.addResourceChangeListener(listener, IResourceChangeEvent.POST_BUILD);
	try {
	//create one job that does a build, and then waits
	final int[] status = new int[3];
	Job jobOne = new Job("jobOne") {
	@Override
	protected IStatus run(IProgressMonitor monitor) {
	try {
	workspace.run((IWorkspaceRunnable) monitor1 -> {
	//do a build
	workspace.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, monitor1);
	//signal that the job has done the build
	status[0] = TestBarrier.STATUS_RUNNING;
	//wait for job two to start
	TestBarrier.waitForStatus(status, 0, TestBarrier.STATUS_WAIT_FOR_DONE);
	}, null);
	} catch (CoreException e) {
	return e.getStatus();
	}
	return Status.OK_STATUS;
	}
	};
	//schedule and wait for job one to start
	jobOne.schedule();
	TestBarrier.waitForStatus(status, 0, TestBarrier.STATUS_RUNNING);

	//create job two that does an empty workspace operation
	Job jobTwo = new Job("jobTwo") {
	@Override
	protected IStatus run(IProgressMonitor monitor) {
	try {
	workspace.run((IWorkspaceRunnable) monitor1 -> {
	//signal that this job has started
	status[1] = TestBarrier.STATUS_RUNNING;
	//let job one finish
	status[0] = TestBarrier.STATUS_WAIT_FOR_DONE;
	//wait for job three to start
	TestBarrier.waitForStatus(status, 1, TestBarrier.STATUS_WAIT_FOR_DONE);
	}, null, IResource.NONE, null);
	} catch (CoreException e) {
	return e.getStatus();
	}
	return Status.OK_STATUS;
	}
	};
	jobTwo.schedule();
	//create job three that has a non-null rule
	Job jobThree = new Job("jobThree") {
	@Override
	protected IStatus run(IProgressMonitor monitor) {
	try {
	workspace.run((IWorkspaceRunnable) monitor1 -> {
	//signal that this job has started
	status[2] = TestBarrier.STATUS_RUNNING;
	//let job two finish
	status[1] = TestBarrier.STATUS_WAIT_FOR_DONE;
	//ensure this job does something so the build listener runs
	ruleFile.touch(null);
	//wait for the ok to complete
	TestBarrier.waitForStatus(status, 2, TestBarrier.STATUS_WAIT_FOR_DONE);
	}, workspace.getRuleFactory().modifyRule(ruleFile), IResource.NONE, null);
	} catch (CoreException e) {
	return e.getStatus();
	}
	return Status.OK_STATUS;
	}
	};
	jobThree.schedule();
	//wait for job two to complete
	waitForCompletion(jobTwo);

	//let job three complete
	status[2] = TestBarrier.STATUS_WAIT_FOR_DONE;

	//wait for job three to complete
	waitForCompletion(jobThree);

	//ensure no jobs failed
	IStatus result = jobOne.getResult();
	if (!result.isOK()) {
	fail("1.0", new CoreException(result));
	}
	result = jobTwo.getResult();
	if (!result.isOK()) {
	fail("1.1", new CoreException(result));
	}
	result = jobThree.getResult();
	if (!result.isOK()) {
	fail("1.2", new CoreException(result));
	}

	if (failure[0] != null) {
	fail("1.3", failure[0]);
	}
	} finally {
	//ensure listener is removed
	workspace.removeResourceChangeListener(listener);
	}
	}

	private void waitForCompletion(Job job) {
	int i = 0;
	while (job.getState() != Job.NONE) {
	sleep(100);
	//sanity test to avoid hanging tests
	assertTrue("Timeout waiting for job to complete", i++ < 1000);
	}
	}
	}