Skip to main content
summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/synchronizers/SynchronousSynchronizerTests.java')
-rw-r--r--common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/synchronizers/SynchronousSynchronizerTests.java756
1 files changed, 0 insertions, 756 deletions
diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/synchronizers/SynchronousSynchronizerTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/synchronizers/SynchronousSynchronizerTests.java
deleted file mode 100644
index e7601bc657..0000000000
--- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/synchronizers/SynchronousSynchronizerTests.java
+++ /dev/null
@@ -1,756 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2010 Oracle. 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:
- * Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.common.utility.tests.internal.synchronizers;
-
-import org.eclipse.jpt.common.utility.Command;
-import org.eclipse.jpt.common.utility.internal.CompositeException;
-import org.eclipse.jpt.common.utility.internal.SynchronizedBoolean;
-import org.eclipse.jpt.common.utility.internal.synchronizers.SynchronousSynchronizer;
-import org.eclipse.jpt.common.utility.synchronizers.Synchronizer;
-import org.eclipse.jpt.common.utility.tests.internal.MultiThreadedTestCase;
-import org.eclipse.jpt.common.utility.tests.internal.TestTools;
-
-@SuppressWarnings("nls")
-public class SynchronousSynchronizerTests
- extends MultiThreadedTestCase
-{
- PrimaryModel1 primaryModel1;
- SecondaryModel1 secondaryModel1;
- Command command1;
- Synchronizer synchronizer1;
-
- PrimaryModel2 primaryModel2;
- SecondaryModel2 secondaryModel2;
- Command command2;
- Synchronizer synchronizer2;
-
- public SynchronousSynchronizerTests(String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- this.primaryModel1 = new PrimaryModel1();
- this.secondaryModel1 = new SecondaryModel1(this.primaryModel1);
- this.command1 = new SynchronizeSecondaryModelCommand1(this.secondaryModel1);
- this.synchronizer1 = new SynchronousSynchronizer(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 SynchronousSynchronizer(this.command2);
- this.primaryModel2.setSynchronizer(this.synchronizer2);
- }
-
- public void testInitialization() {
- assertEquals(4, this.secondaryModel1.getDoubleCount());
- }
-
- public void testToString() {
- assertNotNull(this.synchronizer1.toString());
- }
-
- public void testChange() {
- assertEquals(4, this.secondaryModel1.getDoubleCount());
- this.primaryModel1.setCount(7);
- assertEquals(14, this.secondaryModel1.getDoubleCount());
- }
-
- public void testStart() {
- assertEquals(4, this.secondaryModel1.getDoubleCount());
- this.primaryModel1.setSynchronizer(Synchronizer.Null.instance());
- this.primaryModel1.setCount(7);
- assertEquals(4, this.secondaryModel1.getDoubleCount());
- this.primaryModel1.setSynchronizer(this.synchronizer1);
- assertEquals(14, this.secondaryModel1.getDoubleCount());
- }
-
- public void testStop() {
- assertEquals(4, this.secondaryModel1.getDoubleCount());
- this.primaryModel1.dispose();
- this.primaryModel1.setCount(7);
- assertEquals(4, this.secondaryModel1.getDoubleCount());
- }
-
- public void testDoubleStart() {
- assertEquals(4, this.secondaryModel1.getDoubleCount());
- boolean exCaught = false;
- try {
- this.primaryModel1.startSynchronizer();
- fail();
- } catch (IllegalStateException ex) {
- exCaught = true;
- }
- assertTrue(exCaught);
- this.primaryModel1.setCount(7);
- assertEquals(14, this.secondaryModel1.getDoubleCount());
- }
-
- public void testDoubleStop() {
- assertEquals(4, this.secondaryModel1.getDoubleCount());
- this.primaryModel1.dispose();
- boolean exCaught = false;
- try {
- this.primaryModel1.dispose();
- fail();
- } catch (IllegalStateException ex) {
- exCaught = true;
- }
- assertTrue(exCaught);
- this.primaryModel1.setCount(7);
- assertEquals(4, this.secondaryModel1.getDoubleCount());
- }
-
- public void testRecursiveChange() {
- assertEquals(4, this.secondaryModel2.getDoubleCount());
- this.primaryModel2.setCount(7);
- assertEquals(10, this.primaryModel2.getCountPlus3());
- assertEquals(14, this.secondaryModel2.getDoubleCount());
- assertEquals(20, this.secondaryModel2.getDoubleCountPlus3());
- }
-
- /**
- * Call #stop() from another thread.
- * Verify that no further synchronizations occur.
- * Verify the call to #stop() does not return until the pending
- * synchronization is complete (must set {@link #DEBUG} to true and
- * look at the console).
- *
- * ticks:
- * 0 - start "sync" thread (which will sleep for 1 tick);
- * start "stop" thread (which will sleep for 2 ticks)
- * 1 - "sync" thread wakes up and calls PrimaryModel1.setCount(int)
- * which triggers call to Synchronizer.synchronize() to begin
- * synchronization of SecondaryModel (which will run for 2 ticks;
- * i.e. it will finish on tick 3)
- * 2 - "stop" thread wakes up and calls Synchronizer.stop() and should
- * wait until synchronization is complete
- * 3 - synchronization completes first execution and should stop;
- * "stop" thread should run to completion once the synchronization has stopped
- */
- public void testCallStopFromAnotherThread() throws Exception {
- log("=====" + this.getName() + "=====");
- PrimaryModel2 primaryModel3 = new PrimaryModel2();
- // a synchronize will occur here:
- SecondaryModel3 secondaryModel3 = new SecondaryModel3(primaryModel3);
- Command command3 = new SynchronizeSecondaryModelCommand2(primaryModel3, secondaryModel3);
- Synchronizer synchronizer3 = new SynchronousSynchronizer(command3);
- // another synchronize will occur here:
- primaryModel3.setSynchronizer(synchronizer3);
- secondaryModel3.setTicks(2);
-
- assertEquals(2, primaryModel3.getCount());
- assertEquals(5, primaryModel3.getCountPlus3());
- assertEquals(4, secondaryModel3.getDoubleCount());
- assertEquals(10, secondaryModel3.getDoubleCountPlus3());
-
- Thread syncThread = this.buildTriggerSynchronizeThread(primaryModel3, 1);
- Thread stopThread = this.buildStopThread(synchronizer3, 2);
-
- log("ALL threads start");
- stopThread.start();
- syncThread.start();
-
- stopThread.join();
- syncThread.join();
-
- // 'doubleCount' is synchronized; but the synchronization is stopped
- // while that is happening (by the 'stopThread'), so 'doubleCountPlus3'
- // does not get synchronized
- assertEquals(7, primaryModel3.getCount());
- assertEquals(10, primaryModel3.getCountPlus3());
- assertEquals(14, secondaryModel3.getDoubleCount());
-
- // this does not get updated because it would've been updated by the
- // recursive call to #synchronize(), but by that time #stop() had been called
- assertEquals(10, secondaryModel3.getDoubleCountPlus3());
- }
-
- private Thread buildTriggerSynchronizeThread(PrimaryModel2 primaryModel, long ticks) {
- return this.buildThread(this.buildTriggerSynchronizeRunnable(primaryModel, ticks), "trigger sync");
- }
-
- private Runnable buildTriggerSynchronizeRunnable(final PrimaryModel2 primaryModel, final long ticks) {
- return new Runnable() {
- public void run() {
- TestTools.sleep(ticks * TICK);
- primaryModel.setCount(7);
- }
- };
- }
-
- private Thread buildStopThread(Synchronizer synchronizer, long ticks) {
- return this.buildThread(this.buildStopRunnable(synchronizer, ticks), "stop");
- }
-
- private Runnable buildStopRunnable(final Synchronizer synchronizer, final long ticks) {
- return new Runnable() {
- public void run() {
- TestTools.sleep(ticks * TICK);
- log("STOP thread Synchronizer.stop()");
- synchronizer.stop();
- log("STOP thread stop");
- }
- };
- }
-
- /**
- * Code cloned from {@link #testStopCalledFromAnotherThread()}.
- *
- * Interrupt the "stop" thread while it is waiting for the "synch" thread to finish.
- * Verify that no further synchronizations occur.
- * Verify the call to #stop() returns *before*
- * synchronization is complete (must set {@link #DEBUG} to true and
- * look at the console).
- *
- * ticks:
- * 0 - start "sync" thread (which will sleep for 1 tick);
- * start "stop" thread (which will sleep for 2 ticks);
- * start "interrupt" thread (which will sleep for 3 ticks)
- * 1 - "sync" thread wakes up and calls PrimaryModel1.setCount(int)
- * which triggers call to Synchronizer.synchronize() to begin
- * synchronization of SecondaryModel (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 it is interrupted
- * 3 - "interrupt" thread wakes up and interrupts "stop" thread;
- * both will run to completion at that point
- * 4 - synchronization completes first execution and should stop since the
- * "stop" thread, before it was interrupted, told the "synch" thread to stop
- */
- public void testInterruptStopThread() throws Exception {
- log("=====" + this.getName() + "=====");
- PrimaryModel2 primaryModel3 = new PrimaryModel2();
- // a synchronize will occur here:
- SecondaryModel3 secondaryModel3 = new SecondaryModel3(primaryModel3);
- Command command3 = new SynchronizeSecondaryModelCommand2(primaryModel3, secondaryModel3);
- Synchronizer synchronizer3 = new SynchronousSynchronizer(command3);
- // another synchronize will occur here:
- primaryModel3.setSynchronizer(synchronizer3);
- secondaryModel3.setTicks(3);
-
- assertEquals(2, primaryModel3.getCount());
- assertEquals(5, primaryModel3.getCountPlus3());
- assertEquals(4, secondaryModel3.getDoubleCount());
- assertEquals(10, secondaryModel3.getDoubleCountPlus3());
-
- Thread syncThread = this.buildTriggerSynchronizeThread(primaryModel3, 1);
- Thread stopThread = this.buildStopThread(synchronizer3, 2);
- Thread interruptThread = this.buildInterruptThread(stopThread, 3);
-
- log("ALL threads start");
- stopThread.start();
- syncThread.start();
- interruptThread.start();
-
- stopThread.join();
- syncThread.join();
- interruptThread.join();
-
- // 'doubleCount' is synchronized; but the synchronization is stopped
- // while that is happening (by the 'stopThread'), so 'doubleCountPlus3'
- // does not get synchronized
- assertEquals(7, primaryModel3.getCount());
- assertEquals(10, primaryModel3.getCountPlus3());
- assertEquals(14, secondaryModel3.getDoubleCount());
-
- // this does not get updated because it would've been updated by the
- // recursive call to #synchronize(), but by that time #stop() had been called
- assertEquals(10, secondaryModel3.getDoubleCountPlus3());
- }
-
- /**
- * Code cloned from {@link #testStopCalledFromAnotherThread()}.
- *
- * Interrupt the "sync" thread while it is synchronizing, cutting short the synchronization.
- * Verify that no further synchronizations occur.
- * Verify the call to #stop() does not return until the pending
- * synchronization is stops after it is interrupted (must set {@link #DEBUG} to true and
- * look at the console).
- *
- * ticks:
- * 0 - start "sync" thread (which will sleep for 1 tick)
- * start "stop" thread (which will sleep for 2 ticks)
- * start "interrupt" thread (which will sleep for 3 ticks)
- * 1 - "sync" thread wakes up and calls PrimaryModel1.setCount(int)
- * which triggers call to Synchronizer.synchronize() to begin
- * synchronization of SecondaryModel (which will run for 4 ticks;
- * i.e. it will finish on tick 5)
- * 2 - "stop" thread wakes up and calls Synchronizer.stop() and should
- * wait until the synchronization is interrupted
- * 3 - "interrupt" thread wakes up and interrupts "sync" thread;
- * the "interrupt" thread runs to completion, while the "sync" thread keeps
- * going for another tick before it stops in "mid-synchronize"
- * 4 - the "sync" thread acknowledges the interrupt and stops in
- * "mid-synchronize"; it will stop since the "stop" thread told it to at tick 2;
- * the "sync" and "stop" threads run to completion
- */
- public void testInterruptSyncThread() throws Exception {
- log("=====" + this.getName() + "=====");
- PrimaryModel2 primaryModel3 = new PrimaryModel2();
- // a synchronize will occur here:
- SecondaryModel3 secondaryModel3 = new SecondaryModel3(primaryModel3);
- Command command3 = new SynchronizeSecondaryModelCommand2(primaryModel3, secondaryModel3);
- Synchronizer synchronizer3 = new SynchronousSynchronizer(command3);
- // another synchronize will occur here:
- primaryModel3.setSynchronizer(synchronizer3);
- secondaryModel3.setTicks(4);
-
- assertEquals(2, primaryModel3.getCount());
- assertEquals(5, primaryModel3.getCountPlus3());
- assertEquals(4, secondaryModel3.getDoubleCount());
- assertEquals(10, secondaryModel3.getDoubleCountPlus3());
-
- Thread syncThread = this.buildTriggerSynchronizeThread(primaryModel3, 1);
- Thread stopThread = this.buildStopThread(synchronizer3, 2);
- Thread interruptThread = this.buildInterruptThread(syncThread, 3);
-
- log("ALL threads start");
- stopThread.start();
- syncThread.start();
- interruptThread.start();
-
- stopThread.join();
- syncThread.join();
- interruptThread.join();
-
- assertEquals(7, primaryModel3.getCount());
- assertEquals(10, primaryModel3.getCountPlus3());
-
- // none of the secondary model is synchronized because the synchronize()
- // method was interrupted before any synchronization had occurred
- assertEquals(4, secondaryModel3.getDoubleCount());
- assertEquals(10, secondaryModel3.getDoubleCountPlus3());
- }
-
- private Thread buildInterruptThread(Thread thread, long ticks) {
- return this.buildThread(this.buildInterruptRunnable(thread, ticks), "interrupt");
- }
-
- private Runnable buildInterruptRunnable(final Thread thread, final long ticks) {
- return new Runnable() {
- public void run() {
- TestTools.sleep(ticks * TICK);
- log("INTERRUPT thread Thread.interrupt()");
- thread.interrupt();
- }
- };
- }
-
- /**
- * 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(int ticks) {
- return new DelayCommand(ticks);
- }
-
- class DelayCommand implements Command {
- final long ticks;
- boolean first = true;
- int count = 0;
-
- DelayCommand(int 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);
- TestTools.sleep(this.ticks * TICK);
- log("EXEC stop " + this.count);
- }
-
- }
-
- private Thread buildStartThread(Synchronizer synchronizer, long ticks, SynchronizedBoolean exCaught) {
- return this.buildThread(this.buildStartRunnable(synchronizer, ticks, exCaught), "start");
- }
-
- private Runnable buildStartRunnable(final Synchronizer synchronizer, final long ticks, final SynchronizedBoolean exCaught) {
- return new Runnable() {
- public void run() {
- TestTools.sleep(ticks * TICK);
- log("START thread Synchronizer.start()");
- try {
- synchronizer.start();
- } catch (IllegalStateException ex) {
- exCaught.setTrue();
- log("START thread exception");
- }
- log("START thread stop");
- }
- };
- }
-
- private Thread buildSynchronizeThread(Synchronizer synchronizer, long ticks) {
- return this.buildThread(this.buildSynchronizeRunnable(synchronizer, ticks), "synchronize");
- }
-
- private Runnable buildSynchronizeRunnable(final Synchronizer synchronizer, final long ticks) {
- return new Runnable() {
- public void run() {
- TestTools.sleep(ticks * TICK);
- log("SYNC thread Synchronizer.synchronize()");
- synchronizer.synchronize();
- log("SYNC thread stop");
- }
- };
- }
-
- public void testException() throws Exception {
- BogusCommand command = new BogusCommand();
- Synchronizer synchronizer = new SynchronousSynchronizer(command);
- synchronizer.start();
-
- try {
- synchronizer.synchronize();
- } catch (NullPointerException ex) {
- // ignore
- }
-
- boolean exCaught = false;
- try {
- // we used to hang here, before we began handling exceptions
- synchronizer.stop();
- fail();
- } catch (CompositeException ex) {
- assertEquals(1, ex.getExceptions().length);
- exCaught = true;
- }
- assertTrue(exCaught);
- // start + synchronize
- assertEquals(2, command.count);
- }
-
- public class BogusCommand implements Command {
- int count = 0;
- public void execute() {
- this.count++;
- if (this.count > 1) {
- throw new NullPointerException();
- }
- }
- }
-
-
- // ********** synchronize commands **********
- public static class SynchronizeSecondaryModelCommand1 implements Command {
- private final SecondaryModel1 secondaryModel;
-
- public SynchronizeSecondaryModelCommand1(SecondaryModel1 secondaryModel) {
- super();
- this.secondaryModel = secondaryModel;
- }
-
- public void execute() {
- this.secondaryModel.synchronize();
- }
-
- }
-
- /**
- * the primary model (subclass) has to synchronize with itself (superclass)
- */
- public static class SynchronizeSecondaryModelCommand2 extends SynchronizeSecondaryModelCommand1 {
- private final PrimaryModel2 primaryModel;
-
- public SynchronizeSecondaryModelCommand2(PrimaryModel2 primaryModel, SecondaryModel2 secondaryModel) {
- super(secondaryModel);
- this.primaryModel = primaryModel;
- }
-
- @Override
- public void execute() {
- super.execute();
- this.primaryModel.synchronize();
- }
-
- }
-
- // ********** primary models **********
- /**
- * this object will call the synchronizer whenever its count changes,
- * allowing interested parties to synchronize with the change
- */
- public static class PrimaryModel1 {
- protected Synchronizer synchronizer;
- protected int count = 2;
-
- public PrimaryModel1() {
- super();
- this.setSynchronizer_(Synchronizer.Null.instance());
- }
-
- public int getCount() {
- return this.count;
- }
- public void setCount(int count) {
- if (count != this.count) {
- this.count = count;
- this.stateChanged();
- }
- }
-
- protected void stateChanged() {
- this.synchronizer.synchronize();
- }
-
- public void setSynchronizer(Synchronizer synchronizer) {
- if (synchronizer == null) {
- throw new NullPointerException();
- }
- this.synchronizer.stop();
- this.setSynchronizer_(synchronizer);
- }
-
- protected void setSynchronizer_(Synchronizer synchronizer) {
- this.synchronizer = synchronizer;
- this.synchronizer.start();
- }
-
- public void startSynchronizer() {
- this.synchronizer.start(); // this should cause an exception
- }
- public void dispose() {
- this.synchronizer.stop();
- }
-
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder();
- sb.append(this.getClass().getSimpleName());
- sb.append('(');
- this.toString(sb);
- sb.append(')');
- return sb.toString();
- }
- public void toString(StringBuilder sb) {
- sb.append("count=");
- sb.append(this.count);
- }
-
- }
-
- /**
- * This model synchronizes with itself, triggering a recursive synchronization
- * with the change. Whenever the [inherited] 'count' changes, 'countPlus3'
- * is updated appropriately and another synchronize is initiated if appropriate.
- */
- public static class PrimaryModel2 extends PrimaryModel1 {
- private int countPlus3 = 0;
-
- public PrimaryModel2() {
- super();
- this.countPlus3 = this.count + 3;
- }
-
- public int getCountPlus3() {
- return this.countPlus3;
- }
- protected void setCountPlus3(int countPlus3) {
- if (countPlus3 != this.countPlus3) {
- this.countPlus3 = countPlus3;
- this.stateChanged();
- }
- }
-
- // synchronize with itself, so to speak
- public void synchronize() {
- this.setCountPlus3(this.count + 3);
- }
-
- @Override
- public void toString(StringBuilder sb) {
- super.toString(sb);
- sb.append(", countPlus3=");
- sb.append(this.countPlus3);
- }
-
- }
-
- // ********** secondary models **********
- /**
- * This dependent object updates its 'doubleCount' whenever the
- * PrimaryModel1's 'count' changes, via the 'synchronizer'.
- */
- public static class SecondaryModel1 {
- protected final PrimaryModel1 primaryModel;
- protected int doubleCount = 0;
-
- public SecondaryModel1(PrimaryModel1 primaryModel) {
- super();
- this.primaryModel = primaryModel;
- this.synchronize();
- }
-
- public void synchronize() {
- this.doubleCount = this.primaryModel.getCount() * 2;
- }
-
- public int getDoubleCount() {
- return this.doubleCount;
- }
-
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder();
- sb.append(this.getClass().getSimpleName());
- sb.append('(');
- this.toString(sb);
- sb.append(')');
- return sb.toString();
- }
- public void toString(StringBuilder sb) {
- sb.append("doubleCount=");
- sb.append(this.doubleCount);
- }
-
- }
-
- public static class SecondaryModel2 extends SecondaryModel1 {
- private int doubleCountPlus3 = 0;
-
- public SecondaryModel2(PrimaryModel2 extendedPrimaryModel) {
- super(extendedPrimaryModel);
- }
-
- protected PrimaryModel2 getExtendedPrimaryModel() {
- return (PrimaryModel2) this.primaryModel;
- }
-
- @Override
- public void synchronize() {
- super.synchronize();
- int temp = this.getExtendedPrimaryModel().getCountPlus3() * 2;
- if (this.doubleCountPlus3 != temp) {
- this.doubleCountPlus3 = temp;
- }
- }
-
- public int getDoubleCountPlus3() {
- return this.doubleCountPlus3;
- }
-
- @Override
- public void toString(StringBuilder sb) {
- super.toString(sb);
- sb.append(", doubleCountPlus3=");
- sb.append(this.doubleCountPlus3);
- }
-
- }
-
- /**
- * Allow the time required to synchronize to be specified.
- * A (non-delayed) synchronize will execute before we have a chance to
- * change the tick count. (It is called in the SecondaryModel1 constructor.)
- */
- public static class SecondaryModel3 extends SecondaryModel2 {
- private long delay = 0;
- public SecondaryModel3(PrimaryModel2 primaryModel) {
- super(primaryModel);
- }
-
- public void setTicks(long ticks) {
- this.delay = ticks * TICK;
- }
-
- @Override
- public void synchronize() {
- // don't log anything until 'ticks' is set
- if (this.delay == 0) {
- super.synchronize();
- } else {
- log("SYNC thread start - sync duration will be: " + (this.delay / TICK) + " ticks");
- try {
- Thread.sleep(this.delay);
- } catch (InterruptedException ex) {
- log("SYNC thread interrupted");
- TestTools.sleep(TICK);
- return; // stop synchronize (i.e. don't call super.synchronize())
- }
- super.synchronize();
- log("SYNC thread stop");
- }
- }
-
- }
-
- public void testDEBUG() {
- assertFalse(DEBUG);
- }
-
- public static final boolean DEBUG = false;
- public static void log(String message) {
- if (DEBUG) {
- log_(message);
- }
- }
-
- private static void log_(String message) {
- System.out.print(timestamp());
- System.out.print(' ');
- System.out.print(message);
- System.out.println();
- }
-
- public static String timestamp() {
- return String.valueOf((System.currentTimeMillis() % 10000) / 1000f);
- }
-
-}

Back to the top