clean up synchronizers

2 files changed, 118 insertions, 63 deletions

diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/synchronizers/AsynchronousSynchronizerTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/synchronizers/AsynchronousSynchronizerTests.java
index 82903869c5..d7f3e84e46 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/synchronizers/AsynchronousSynchronizerTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/synchronizers/AsynchronousSynchronizerTests.java
@@ -9,29 +9,24 @@
  ******************************************************************************/
 package org.eclipse.jpt.utility.tests.internal.synchronizers;
 
+import junit.framework.TestCase;
+
 import org.eclipse.jpt.utility.Command;
 import org.eclipse.jpt.utility.internal.ClassTools;
 import org.eclipse.jpt.utility.internal.ExceptionHandler;
-import org.eclipse.jpt.utility.internal.SynchronizedBoolean;
 import org.eclipse.jpt.utility.internal.synchronizers.AsynchronousSynchronizer;
 import org.eclipse.jpt.utility.internal.synchronizers.Synchronizer;
 
-import junit.framework.TestCase;
-
 @SuppressWarnings("nls")
 public class AsynchronousSynchronizerTests extends TestCase {
 	PrimaryModel1 primaryModel1;
 	SecondaryModel1 secondaryModel1;
 	Command command1;
-	SynchronizedBoolean startFlag1 = new SynchronizedBoolean(false);
-	SynchronizedBoolean completeFlag1 = new SynchronizedBoolean(false);
 	Synchronizer synchronizer1;
 
 	PrimaryModel2 primaryModel2;
 	SecondaryModel2 secondaryModel2;
 	Command command2;
-	SynchronizedBoolean startFlag2 = new SynchronizedBoolean(false);
-	SynchronizedBoolean completeFlag2 = new SynchronizedBoolean(false);
 	Synchronizer synchronizer2;
 
 	public AsynchronousSynchronizerTests(String name) {
@@ -44,13 +39,13 @@ public class AsynchronousSynchronizerTests extends TestCase {
 		this.primaryModel1 = new PrimaryModel1();
 		this.secondaryModel1 = new SecondaryModel1(this.primaryModel1);
 		this.command1 = new SynchronizeSecondaryModelCommand1(this.secondaryModel1);
-		this.synchronizer1 = new TestAsynchronousSynchronizer(this.command1, this.startFlag1, this.completeFlag1);
+		this.synchronizer1 = new AsynchronousSynchronizer(this.command1);
 		this.primaryModel1.setSynchronizer(this.synchronizer1);
 
 		this.primaryModel2 = new PrimaryModel2();
 		this.secondaryModel2 = new SecondaryModel2(this.primaryModel2);
 		this.command2 = new SynchronizeSecondaryModelCommand2(this.primaryModel2, this.secondaryModel2);
-		this.synchronizer2 = new TestAsynchronousSynchronizer(this.command2, this.startFlag2, this.completeFlag2);
+		this.synchronizer2 = new AsynchronousSynchronizer(this.command2);
 		this.primaryModel2.setSynchronizer(this.synchronizer2);
 	}
 
@@ -79,9 +74,9 @@ public class AsynchronousSynchronizerTests extends TestCase {
 		assertEquals(4, this.secondaryModel1.getDoubleCount());
 		this.primaryModel1.setCount(7);
 
-		this.startFlag1.waitUntilTrue();
+		delay(1);
 		this.synchronizer1.stop();
-		this.completeFlag1.waitUntilTrue();
+		delay(1);
 
 		assertEquals(14, this.secondaryModel1.getDoubleCount());
 	}
@@ -97,9 +92,9 @@ public class AsynchronousSynchronizerTests extends TestCase {
 
 		this.primaryModel1.setCount(8);
 
-		this.startFlag1.waitUntilTrue();
+		delay(1);
 		this.synchronizer1.stop();
-		this.completeFlag1.waitUntilTrue();
+		delay(1);
 
 		assertEquals(16, this.secondaryModel1.getDoubleCount());
 	}
@@ -123,9 +118,9 @@ public class AsynchronousSynchronizerTests extends TestCase {
 		assertTrue(exCaught);
 		this.primaryModel1.setCount(7);
 
-		this.startFlag1.waitUntilTrue();
+		delay(1);
 		this.synchronizer1.stop();
-		this.completeFlag1.waitUntilTrue();
+		delay(1);
 
 		assertEquals(14, this.secondaryModel1.getDoubleCount());
 	}
@@ -417,45 +412,4 @@ public class AsynchronousSynchronizerTests extends TestCase {
 		}
 	}
 
-
-	// ********** custom async synchronizer **********
-
-	/**
-	 * Hopefully, we don't modify the behavior too much....
-	 */
-	public static class TestAsynchronousSynchronizer extends AsynchronousSynchronizer {
-		public TestAsynchronousSynchronizer(Command command, SynchronizedBoolean startFlag, SynchronizedBoolean completeFlag) {
-			super(command);
-			((TestRunnableSynchronization) this.runnable).setStartFlag(startFlag);
-			((TestRunnableSynchronization) this.runnable).setCompleteFlag(completeFlag);
-		}
-		@Override
-		protected Runnable buildRunnable(Command command) {
-			return new TestRunnableSynchronization(command, this.synchronizeFlag);
-		}
-		protected static class TestRunnableSynchronization extends RunnableSynchronization {
-			private SynchronizedBoolean startFlag;
-			private SynchronizedBoolean completeFlag;
-			protected TestRunnableSynchronization(Command command, SynchronizedBoolean synchronizeFlag) {
-				super(command, synchronizeFlag);
-			}
-			public void setStartFlag(SynchronizedBoolean startFlag) {
-				this.startFlag = startFlag;
-			}
-			public void setCompleteFlag(SynchronizedBoolean completeFlag) {
-				this.completeFlag = completeFlag;
-			}
-			@Override
-			public void run() {
-				super.run();
-				this.completeFlag.setTrue();
-			}
-			@Override
-			protected void execute() {
-				this.startFlag.setTrue();
-				super.execute();
-			}
-		}
-	}
-
 }
diff --git a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/synchronizers/SynchronousSynchronizerTests.java b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/synchronizers/SynchronousSynchronizerTests.java
index f92e8bc307..472fb46e45 100644
--- a/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/synchronizers/SynchronousSynchronizerTests.java
+++ b/jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/synchronizers/SynchronousSynchronizerTests.java
@@ -13,6 +13,7 @@ import junit.framework.TestCase;
 
 import org.eclipse.jpt.utility.Command;
 import org.eclipse.jpt.utility.internal.ClassTools;
+import org.eclipse.jpt.utility.internal.SynchronizedBoolean;
 import org.eclipse.jpt.utility.internal.synchronizers.Synchronizer;
 import org.eclipse.jpt.utility.internal.synchronizers.SynchronousSynchronizer;
 
@@ -150,7 +151,7 @@ public class SynchronousSynchronizerTests extends TestCase {
 		assertEquals(4, secondaryModel3.getDoubleCount());
 		assertEquals(10, secondaryModel3.getDoubleCountPlus3());
 
-		Thread syncThread = this.buildSynchronizeThread(primaryModel3, 1);
+		Thread syncThread = this.buildTriggerSynchronizeThread(primaryModel3, 1);
 		Thread stopThread = this.buildStopThread(synchronizer3, 2);
 
 		log("ALL threads start");
@@ -172,8 +173,8 @@ public class SynchronousSynchronizerTests extends TestCase {
 		assertEquals(10, secondaryModel3.getDoubleCountPlus3());
 	}
 
-	private Thread buildSynchronizeThread(final PrimaryModel2 primaryModel, final long ticks) {
-		return new Thread() {
+	private Thread buildTriggerSynchronizeThread(final PrimaryModel2 primaryModel, final long ticks) {
+		return new Thread("trigger sync") {
 			@Override
 			public void run() {
 				delay(ticks);
@@ -183,7 +184,7 @@ public class SynchronousSynchronizerTests extends TestCase {
 	}
 
 	private Thread buildStopThread(final Synchronizer synchronizer, final long ticks) {
-		return new Thread() {
+		return new Thread("stop") {
 			@Override
 			public void run() {
 				delay(ticks);
@@ -234,7 +235,7 @@ public class SynchronousSynchronizerTests extends TestCase {
 		assertEquals(4, secondaryModel3.getDoubleCount());
 		assertEquals(10, secondaryModel3.getDoubleCountPlus3());
 
-		Thread syncThread = this.buildSynchronizeThread(primaryModel3, 1);
+		Thread syncThread = this.buildTriggerSynchronizeThread(primaryModel3, 1);
 		Thread stopThread = this.buildStopThread(synchronizer3, 2);
 		Thread interruptThread = this.buildInterruptThread(stopThread, 3);
 
@@ -301,7 +302,7 @@ public class SynchronousSynchronizerTests extends TestCase {
 		assertEquals(4, secondaryModel3.getDoubleCount());
 		assertEquals(10, secondaryModel3.getDoubleCountPlus3());
 
-		Thread syncThread = this.buildSynchronizeThread(primaryModel3, 1);
+		Thread syncThread = this.buildTriggerSynchronizeThread(primaryModel3, 1);
 		Thread stopThread = this.buildStopThread(synchronizer3, 2);
 		Thread interruptThread = this.buildInterruptThread(syncThread, 3);
 
@@ -324,7 +325,7 @@ public class SynchronousSynchronizerTests extends TestCase {
 	}
 
 	private Thread buildInterruptThread(final Thread thread, final long ticks) {
-		return new Thread() {
+		return new Thread("interrupt") {
 			@Override
 			public void run() {
 				delay(ticks);
@@ -334,6 +335,106 @@ public class SynchronousSynchronizerTests extends TestCase {
 		};
 	}
 
+	/**
+	 * Call #stop() during a long-running "synchronize"; then call #start()
+	 * while the #stop() is waiting for the "synchronize" to complete.
+	 * 
+	 * ticks:
+	 * 0 - start "sync" thread (which will sleep for 1 tick)
+	 *      start "stop" thread (which will sleep for 2 ticks)
+	 *      start "start" thread (which will sleep for 3 ticks)
+	 * 1 - "sync" thread wakes up and calls Synchronizer.synchronize() to begin
+	 *      synchronization (which will run for 3 ticks; i.e. it will finish on tick 4)
+	 * 2 - "stop" thread wakes up and calls Synchronizer.stop() and should
+	 *      wait until the synchronization is finished (i.e. tick 4)
+	 * 3 - "start" thread wakes up and calls Synchronizer.start()
+	 *      which will throw an exception
+	 * 4 - the "sync" thread finishes execution;
+	 *      it will stop since the "stop" thread told it to at tick 2;
+	 *      the "sync" and "stop" threads run to completion
+	 */
+	public void testCallStartDuringStop() throws Exception {
+		log("=====" + this.getName() + "=====");
+		DelayCommand command = this.buildDelayCommand(3);
+		Synchronizer synchronizer = new SynchronousSynchronizer(command);
+		synchronizer.start();
+
+		Thread syncThread = this.buildSynchronizeThread(synchronizer, 1);
+		Thread stopThread = this.buildStopThread(synchronizer, 2);
+		SynchronizedBoolean exCaught = new SynchronizedBoolean(false);
+		Thread startThread = this.buildStartThread(synchronizer, 3, exCaught);
+
+		log("ALL threads start");
+		syncThread.start();
+		stopThread.start();
+		startThread.start();
+
+		syncThread.join();
+		stopThread.join();
+		startThread.join();
+
+		assertTrue(exCaught.getValue());
+		assertEquals(2, command.count);
+	}
+
+	private DelayCommand buildDelayCommand(float ticks) {
+		return new DelayCommand(ticks);
+	}
+
+	class DelayCommand implements Command {
+		final float ticks;
+		boolean first = true;
+		int count = 0;
+
+		DelayCommand(float ticks) {
+			super();
+			this.ticks = ticks;
+		}
+
+		public void execute() {
+			this.count++;
+			// do nothing for the first call (from #start())
+			if (this.first) {
+				log("EXEC first");
+				this.first = false;
+				return;
+			}
+			log("EXEC start " + this.count);
+			delay(this.ticks);
+			log("EXEC stop " + this.count);
+		}
+
+	}
+
+	private Thread buildStartThread(final Synchronizer synchronizer, final long ticks, final SynchronizedBoolean exCaught) {
+		return new Thread("start") {
+			@Override
+			public void run() {
+				delay(ticks);
+				log("START thread Synchronizer.start()");
+				try {
+					synchronizer.start();
+				} catch (IllegalStateException ex) {
+					exCaught.setTrue();
+					log("START thread exception");
+				}
+				log("START thread stop");
+			}
+		};
+	}
+
+	private Thread buildSynchronizeThread(final Synchronizer synchronizer, final long ticks) {
+		return new Thread("synchronize") {
+			@Override
+			public void run() {
+				delay(ticks);
+				log("SYNC thread Synchronizer.synchronize()");
+				synchronizer.synchronize();
+				log("SYNC thread stop");
+			}
+		};
+	}
+
 
 	// ********** synchronize commands **********
 	public static class SynchronizeSecondaryModelCommand1 implements Command {