Skip to main content
summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorBrian Vosburgh2015-10-21 17:51:58 -0400
committerBrian Vosburgh2015-10-21 18:55:40 -0400
commitd0cee112178efe7228b5b150221014d980a2d78c (patch)
tree87da95621eeb735548ff69c97e87e29c5f8ed78a
parentc2516c02cc1bd79ce11638488acc088d25cf6748 (diff)
downloadwebtools.dali-d0cee112178efe7228b5b150221014d980a2d78c.tar.gz
webtools.dali-d0cee112178efe7228b5b150221014d980a2d78c.tar.xz
webtools.dali-d0cee112178efe7228b5b150221014d980a2d78c.zip
add SynchronizedInt tests
-rw-r--r--common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/reference/SynchronizedInt.java5
-rw-r--r--common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/reference/SynchronizedBooleanTests.java1
-rw-r--r--common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/reference/SynchronizedIntTests.java674
3 files changed, 653 insertions, 27 deletions
diff --git a/common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/reference/SynchronizedInt.java b/common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/reference/SynchronizedInt.java
index 02a5781f67..554415c8ec 100644
--- a/common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/reference/SynchronizedInt.java
+++ b/common/plugins/org.eclipse.jpt.common.utility/src/org/eclipse/jpt/common/utility/internal/reference/SynchronizedInt.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2009, 2012 Oracle. All rights reserved.
+ * Copyright (c) 2009, 2015 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.
@@ -599,7 +599,8 @@ public class SynchronizedInt
return thisValue; // nothing changes
}
other.setChangedValue_(thisValue);
- return this.setChangedValue_(otherValue);
+ this.setChangedValue_(otherValue);
+ return otherValue;
}
}
}
diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/reference/SynchronizedBooleanTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/reference/SynchronizedBooleanTests.java
index 0a31ad2244..df0ee38392 100644
--- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/reference/SynchronizedBooleanTests.java
+++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/reference/SynchronizedBooleanTests.java
@@ -694,6 +694,7 @@ public class SynchronizedBooleanTests
public void testClone() {
SynchronizedBoolean clone = this.sb.clone();
assertFalse(clone.getValue());
+ assertNotSame(clone, this.sb);
}
public void testToString() {
diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/reference/SynchronizedIntTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/reference/SynchronizedIntTests.java
index df921544c6..a3791e3f08 100644
--- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/reference/SynchronizedIntTests.java
+++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/reference/SynchronizedIntTests.java
@@ -9,8 +9,13 @@
******************************************************************************/
package org.eclipse.jpt.common.utility.tests.internal.reference;
+import org.eclipse.jpt.common.utility.internal.predicate.int_.IntPredicateTools;
+import org.eclipse.jpt.common.utility.internal.reference.SimpleIntReference;
import org.eclipse.jpt.common.utility.internal.reference.SynchronizedInt;
+import org.eclipse.jpt.common.utility.reference.IntReference;
+import org.eclipse.jpt.common.utility.reference.ModifiableIntReference;
import org.eclipse.jpt.common.utility.tests.internal.MultiThreadedTestCase;
+import org.eclipse.jpt.common.utility.tests.internal.TestTools;
@SuppressWarnings("nls")
public class SynchronizedIntTests
@@ -38,20 +43,46 @@ public class SynchronizedIntTests
this.sIntValue = 0;
}
+ public void testCtorIntObject() throws Exception {
+ String mutex = "mutex";
+ SynchronizedInt syncInt = new SynchronizedInt(22, mutex);
+ assertEquals(22, syncInt.getValue());
+ assertEquals(mutex, syncInt.getMutex());
+ }
+
+ public void testCtorInt() throws Exception {
+ SynchronizedInt syncInt = new SynchronizedInt(22);
+ assertEquals(22, syncInt.getValue());
+ assertEquals(syncInt, syncInt.getMutex());
+ }
+
+ public void testCtorObject() throws Exception {
+ String mutex = "mutex";
+ SynchronizedInt syncInt = new SynchronizedInt(mutex);
+ assertEquals(0, syncInt.getValue());
+ assertEquals(mutex, syncInt.getMutex());
+ }
+
public void testGetValue() throws Exception {
assertEquals(0, this.si.getValue());
}
public void testEqualsInt() throws Exception {
assertTrue(this.si.equals(0));
+ assertFalse(this.si.equals(7));
+
this.si.setValue(this.value);
+ assertFalse(this.si.equals(0));
assertTrue(this.si.equals(7));
}
public void testNotEqualInt() throws Exception {
assertTrue(this.si.notEqual(7));
+ assertFalse(this.si.notEqual(0));
+
this.si.setValue(this.value);
assertTrue(this.si.notEqual(0));
+ assertFalse(this.si.notEqual(7));
}
public void testIsZero() throws Exception {
@@ -138,6 +169,22 @@ public class SynchronizedIntTests
assertFalse(this.si.isNotNegative());
}
+ public void testIsMemberOfIntPredicate() throws Exception {
+ assertTrue(this.si.isMemberOf(IntPredicateTools.isEven()));
+ assertFalse(this.si.isMemberOf(IntPredicateTools.isGreaterThan(2)));
+ this.si.setValue(this.value);
+ assertFalse(this.si.isMemberOf(IntPredicateTools.isEven()));
+ assertTrue(this.si.isMemberOf(IntPredicateTools.isGreaterThan(2)));
+ }
+
+ public void testIsNotMemberOfIntPredicate() throws Exception {
+ assertFalse(this.si.isNotMemberOf(IntPredicateTools.isEven()));
+ assertTrue(this.si.isNotMemberOf(IntPredicateTools.isGreaterThan(2)));
+ this.si.setValue(this.value);
+ assertTrue(this.si.isNotMemberOf(IntPredicateTools.isEven()));
+ assertFalse(this.si.isNotMemberOf(IntPredicateTools.isGreaterThan(2)));
+ }
+
public void testSetValue() throws Exception {
this.si.setValue(0);
assertEquals(0, this.si.getValue());
@@ -150,6 +197,67 @@ public class SynchronizedIntTests
assertFalse(this.si.isZero());
}
+ public void testSetZero() throws Exception {
+ this.si.setZero();
+ assertEquals(0, this.si.getValue());
+ assertFalse(this.si.isNotZero());
+ assertTrue(this.si.isZero());
+ }
+
+ public void testIncrement() throws Exception {
+ assertEquals(0, this.si.getValue());
+ assertEquals(1, this.si.increment());
+ assertEquals(1, this.si.getValue());
+ }
+
+ public void testIncrementExact() throws Exception {
+ assertEquals(0, this.si.getValue());
+ assertEquals(1, this.si.incrementExact());
+ assertEquals(1, this.si.getValue());
+ }
+
+ public void testDecrement() throws Exception {
+ assertEquals(0, this.si.getValue());
+ assertEquals(-1, this.si.decrement());
+ assertEquals(-1, this.si.getValue());
+ }
+
+ public void testDecrementExact() throws Exception {
+ assertEquals(0, this.si.getValue());
+ assertEquals(-1, this.si.decrementExact());
+ assertEquals(-1, this.si.getValue());
+ }
+
+ public void testHalve() throws Exception {
+ assertEquals(0, this.si.getValue());
+ assertEquals(0, this.si.halve());
+ this.si.setValue(22);
+ assertEquals(11, this.si.halve());
+ assertEquals(11, this.si.getValue());
+ assertEquals(5, this.si.halve());
+ assertEquals(5, this.si.getValue());
+ }
+
+ public void testTwice() throws Exception {
+ assertEquals(0, this.si.getValue());
+ assertEquals(0, this.si.twice());
+ this.si.setValue(11);
+ assertEquals(22, this.si.twice());
+ assertEquals(22, this.si.getValue());
+ assertEquals(44, this.si.twice());
+ assertEquals(44, this.si.getValue());
+ }
+
+ public void testTwiceExact() throws Exception {
+ assertEquals(0, this.si.getValue());
+ assertEquals(0, this.si.twiceExact());
+ this.si.setValue(11);
+ assertEquals(22, this.si.twiceExact());
+ assertEquals(22, this.si.getValue());
+ assertEquals(44, this.si.twiceExact());
+ assertEquals(44, this.si.getValue());
+ }
+
public void testAbs() throws Exception {
assertEquals(0, this.si.abs());
assertEquals(0, this.si.getValue());
@@ -158,32 +266,275 @@ public class SynchronizedIntTests
assertEquals(this.value, this.si.getValue());
this.si.setValue(-this.value);
assertEquals(this.value, this.si.abs());
+ assertEquals(this.value, this.si.getValue());
}
- public void testNeg() throws Exception {
+ public void testNegate() throws Exception {
assertEquals(0, this.si.negate());
assertEquals(0, this.si.getValue());
this.si.setValue(this.value);
assertEquals(-this.value, this.si.negate());
+ assertEquals(-this.value, this.si.getValue());
this.si.setValue(-this.value);
assertEquals(this.value, this.si.negate());
+ assertEquals(this.value, this.si.getValue());
}
- public void testSetZero() throws Exception {
- this.si.setZero();
+ public void testNegateExact() throws Exception {
+ assertEquals(0, this.si.negateExact());
assertEquals(0, this.si.getValue());
- assertFalse(this.si.isNotZero());
- assertTrue(this.si.isZero());
+ this.si.setValue(this.value);
+ assertEquals(-this.value, this.si.negateExact());
+ assertEquals(-this.value, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(this.value, this.si.negateExact());
+ assertEquals(this.value, this.si.getValue());
+ }
+
+ public void testAddInt() throws Exception {
+ assertEquals(0, this.si.add(0));
+ assertEquals(0, this.si.getValue());
+ assertEquals(3, this.si.add(3));
+ assertEquals(3, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(10, this.si.add(3));
+ assertEquals(10, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(-4, this.si.add(3));
+ assertEquals(-4, this.si.getValue());
+ }
+
+ public void testAddExactInt() throws Exception {
+ assertEquals(0, this.si.addExact(0));
+ assertEquals(0, this.si.getValue());
+ assertEquals(3, this.si.addExact(3));
+ assertEquals(3, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(10, this.si.addExact(3));
+ assertEquals(10, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(-4, this.si.addExact(3));
+ assertEquals(-4, this.si.getValue());
+ }
+
+ public void testSubtractInt() throws Exception {
+ assertEquals(0, this.si.subtract(0));
+ assertEquals(0, this.si.getValue());
+ assertEquals(-3, this.si.subtract(3));
+ assertEquals(-3, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(4, this.si.subtract(3));
+ assertEquals(4, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(-10, this.si.subtract(3));
+ assertEquals(-10, this.si.getValue());
+ }
+
+ public void testSubtractExactInt() throws Exception {
+ assertEquals(0, this.si.subtractExact(0));
+ assertEquals(0, this.si.getValue());
+ assertEquals(-3, this.si.subtractExact(3));
+ assertEquals(-3, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(4, this.si.subtractExact(3));
+ assertEquals(4, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(-10, this.si.subtractExact(3));
+ assertEquals(-10, this.si.getValue());
+ }
+
+ public void testMultiplyInt() throws Exception {
+ assertEquals(0, this.si.multiply(0));
+ assertEquals(0, this.si.getValue());
+ assertEquals(0, this.si.multiply(3));
+ assertEquals(0, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(21, this.si.multiply(3));
+ assertEquals(21, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(-21, this.si.multiply(3));
+ assertEquals(-21, this.si.getValue());
+ }
+
+ public void testMultiplyExactInt() throws Exception {
+ assertEquals(0, this.si.multiplyExact(0));
+ assertEquals(0, this.si.getValue());
+ assertEquals(0, this.si.multiplyExact(3));
+ assertEquals(0, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(21, this.si.multiplyExact(3));
+ assertEquals(21, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(-21, this.si.multiplyExact(3));
+ assertEquals(-21, this.si.getValue());
+ }
+
+ public void testDivideInt() throws Exception {
+// assertEquals(0, this.si.divide(0)); // no divide by zero
+// assertEquals(0, this.si.getValue());
+ assertEquals(0, this.si.divide(3));
+ assertEquals(0, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(2, this.si.divide(3));
+ assertEquals(2, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(-2, this.si.divide(3));
+ assertEquals(-2, this.si.getValue());
+ }
+
+ public void testFloorDivideInt() throws Exception {
+// assertEquals(0, this.si.floorDivide(0)); // no divide by zero
+// assertEquals(0, this.si.getValue());
+ assertEquals(0, this.si.floorDivide(3));
+ assertEquals(0, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(2, this.si.floorDivide(3));
+ assertEquals(2, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(-3, this.si.floorDivide(3));
+ assertEquals(-3, this.si.getValue());
+ }
+
+ public void testRemainderInt() throws Exception {
+// assertEquals(0, this.si.remainder(0)); // no divide by zero
+// assertEquals(0, this.si.getValue());
+ assertEquals(0, this.si.remainder(3));
+ assertEquals(0, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(1, this.si.remainder(3));
+ assertEquals(1, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(-1, this.si.remainder(3));
+ assertEquals(-1, this.si.getValue());
+ }
+
+ public void testFloorRemainderInt() throws Exception {
+// assertEquals(0, this.si.floorRemainder(0)); // no divide by zero
+// assertEquals(0, this.si.getValue());
+ assertEquals(0, this.si.floorRemainder(3));
+ assertEquals(0, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(1, this.si.floorRemainder(3));
+ assertEquals(1, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(2, this.si.floorRemainder(3));
+ assertEquals(2, this.si.getValue());
+ }
+
+ public void testMinInt() throws Exception {
+ assertEquals(0, this.si.min(0));
+ assertEquals(0, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(3, this.si.min(3));
+ assertEquals(3, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(-7, this.si.min(3));
+ assertEquals(-7, this.si.getValue());
+ }
+
+ public void testMaxInt() throws Exception {
+ assertEquals(0, this.si.max(0));
+ assertEquals(0, this.si.getValue());
+ this.si.setValue(this.value);
+ assertEquals(7, this.si.max(3));
+ assertEquals(7, this.si.getValue());
+ this.si.setValue(-this.value);
+ assertEquals(3, this.si.max(3));
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testCommitIntInt() throws Exception {
+ assertFalse(this.si.commit(0, -3));
+ assertEquals(0, this.si.getValue());
+
+ assertFalse(this.si.commit(0, 3));
+ assertEquals(0, this.si.getValue());
+
+ assertTrue(this.si.commit(0, 0));
+ assertEquals(0, this.si.getValue());
+
+ this.si.setValue(this.value);
+ assertTrue(this.si.commit(3, 7));
+ assertEquals(3, this.si.getValue());
+
+ this.si.setValue(-this.value);
+ assertTrue(this.si.commit(3, -7));
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testSwapRef() throws Exception {
+ ModifiableIntReference temp = this.si;
+ assertEquals(0, this.si.swap(temp));
+
+ ModifiableIntReference ref = new SimpleIntReference(42);
+ assertEquals(42, this.si.swap(ref));
+ assertEquals(42, this.si.getValue());
+ assertEquals(0, ref.getValue());
+
+ this.si.setValue(42);
+ ref.setValue(42);
+ assertEquals(42, this.si.swap(ref));
+ assertEquals(42, this.si.getValue());
+ assertEquals(42, ref.getValue());
+ }
+
+ public void testSwapSyncInt() throws Exception {
+ assertEquals(0, this.si.swap(this.si));
+
+ ModifiableIntReference ref = new SynchronizedInt(42);
+ assertEquals(42, this.si.swap(ref));
+ assertEquals(42, this.si.getValue());
+ assertEquals(0, ref.getValue());
+
+ this.si.setValue(42);
+ ref.setValue(42);
+ assertEquals(42, this.si.swap(ref));
+ assertEquals(42, this.si.getValue());
+ assertEquals(42, ref.getValue());
+
+ ref.setValue(33);
+ assertEquals(42, ref.swap(this.si));
+ assertEquals(33, this.si.getValue());
+ assertEquals(42, ref.getValue());
+ }
+
+ public void testSwapSyncInt2() throws Exception {
+ assertEquals(0, this.si.swap(this.si));
+
+ SynchronizedInt ref = new SynchronizedInt(42);
+ assertEquals(42, this.si.swap(ref));
+ assertEquals(42, this.si.getValue());
+ assertEquals(0, ref.getValue());
+
+ this.si.setValue(42);
+ ref.setValue(42);
+ assertEquals(42, this.si.swap(ref));
+ assertEquals(42, this.si.getValue());
+ assertEquals(42, ref.getValue());
}
public void testGetMutexThis() throws Exception {
assertSame(this.si, this.si.getMutex());
}
+
+ // ********** indefinite waits **********
+
/**
* t2 will wait indefinitely until t1 sets the value to 0
*/
public void testWaitUntilZero() throws Exception {
+ this.verifyWaitUntilZero(-1); // explicit indefinite wait
+ // no timeout occurs...
+ assertFalse(this.timeoutOccurred);
+ // ...and the value should be set to 0 by t2
+ assertEquals(0, this.si.getValue());
+ // make a reasonable guess about how long t2 took
+ long time = this.calculateElapsedTime();
+ assertTrue("t2 finished a bit early (expected value should be > " + TICK + "): " + time, time > TICK);
+ }
+
+ public void testWaitUntilZero2() throws Exception {
this.verifyWaitUntilZero(0); // 0 = indefinite wait
// no timeout occurs...
assertFalse(this.timeoutOccurred);
@@ -208,15 +559,197 @@ public class SynchronizedIntTests
assertTrue("t2 finished a bit late (expected value should be < " + THREE_TICKS + "): " + time, time < THREE_TICKS);
}
+ /**
+ * t2 will NOT time out waiting for t1 to set the value to 0
+ */
+ public void testWaitUntilZeroTimeout2() throws Exception {
+ this.verifyWaitUntilZero(THREE_TICKS);
+ // no timeout occurs...
+ assertFalse(this.timeoutOccurred);
+ // ...and the value should be set to 0 by t2
+ assertEquals(0, this.si.getValue());
+ // make a reasonable guess about how long t2 took
+ long time = this.calculateElapsedTime();
+ assertTrue("t2 finished a bit early (expected value should be >= " + TWO_TICKS + "): " + time, time >= TWO_TICKS);
+ }
+
private void verifyWaitUntilZero(long t2Timeout) throws Exception {
this.executeThreads(this.buildSetZeroCommand(), this.buildWaitUntilZeroCommand(t2Timeout));
}
+ private Command buildWaitUntilZeroCommand(final long timeout) {
+ return new Command() {
+ public void execute(SynchronizedInt sInt) throws InterruptedException {
+ SynchronizedIntTests.this.startTime = System.currentTimeMillis();
+ SynchronizedIntTests.this.timeoutOccurred = this.timeoutOccurred(sInt);
+ SynchronizedIntTests.this.endTime = System.currentTimeMillis();
+ }
+ private boolean timeoutOccurred(SynchronizedInt sInt) throws InterruptedException {
+ if (timeout < 0) {
+ sInt.waitUntilZero();
+ return false;
+ }
+ return ! sInt.waitUntilZero(timeout);
+ }
+ };
+ }
+
+ public void testWaitUntilNotPredicate() throws Exception {
+ this.si.waitUntilNot(IntPredicateTools.isEqual(7));
+ assertEquals(0, this.si.getValue());
+ }
+
+ public void testWaitUntilNotPredicateTimeout() throws Exception {
+ this.si.waitUntilNot(IntPredicateTools.isEqual(7), TWO_TICKS);
+ assertEquals(0, this.si.getValue());
+ }
+
+ public void testWaitUntilNotEqualInt() throws Exception {
+ this.si.waitUntilNotEqual(7);
+ assertEquals(0, this.si.getValue());
+ }
+
+ public void testWaitUntilNotEqualIntTimeout() throws Exception {
+ this.si.waitUntilNotEqual(7, TWO_TICKS);
+ assertEquals(0, this.si.getValue());
+ }
+
+ public void testWaitUntilNotZero() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilNotZero();
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilNotZeroTimeout() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilNotZero(TWO_TICKS);
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilGreaterThanInt() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilGreaterThan(2);
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilGreaterThanIntTimeout() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilGreaterThan(2, TWO_TICKS);
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilGreaterThanOrEqualInt() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilGreaterThanOrEqual(2);
+ assertEquals(3, this.si.getValue());
+ this.si.waitUntilGreaterThanOrEqual(3);
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilGreaterThanOrEqualIntTimeout() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilGreaterThanOrEqual(2, TWO_TICKS);
+ assertEquals(3, this.si.getValue());
+ this.si.waitUntilGreaterThanOrEqual(3, TWO_TICKS);
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilLessThanInt() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilLessThan(4);
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilLessThanIntTimeout() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilLessThan(4, TWO_TICKS);
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilLessThanOrEqualInt() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilLessThanOrEqual(4);
+ assertEquals(3, this.si.getValue());
+ this.si.waitUntilLessThanOrEqual(3);
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilLessThanOrEqualIntTimeout() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilLessThanOrEqual(4, TWO_TICKS);
+ assertEquals(3, this.si.getValue());
+ this.si.waitUntilLessThanOrEqual(3, TWO_TICKS);
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilPositive() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilPositive();
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilPositiveTimeout() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilPositive(TWO_TICKS);
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilNotPositive() throws Exception {
+ this.si.setValue(-3);
+ this.si.waitUntilNotPositive();
+ assertEquals(-3, this.si.getValue());
+ }
+
+ public void testWaitUntilNotPositiveTimeout() throws Exception {
+ this.si.setValue(-3);
+ this.si.waitUntilNotPositive(TWO_TICKS);
+ assertEquals(-3, this.si.getValue());
+ }
+
+ public void testWaitUntilNegative() throws Exception {
+ this.si.setValue(-3);
+ this.si.waitUntilNegative();
+ assertEquals(-3, this.si.getValue());
+ }
+
+ public void testWaitUntilNegativeTimeout() throws Exception {
+ this.si.setValue(-3);
+ this.si.waitUntilNegative(TWO_TICKS);
+ assertEquals(-3, this.si.getValue());
+ }
+
+ public void testWaitUntilNotNegative() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilNotNegative();
+ assertEquals(3, this.si.getValue());
+ }
+
+ public void testWaitUntilNotNegativeTimeout() throws Exception {
+ this.si.setValue(3);
+ this.si.waitUntilNotNegative(TWO_TICKS);
+ assertEquals(3, this.si.getValue());
+ }
+
/**
* t2 will wait indefinitely until t1 sets the value to 0;
* then t2 will set the value to 7
*/
public void testWaitToSetValue() throws Exception {
+ this.verifyWaitToSetValue(-1); // explicit indefinite wait
+ // no timeout occurs...
+ assertFalse(this.timeoutOccurred);
+ // ...and the value should be set to an object by t2
+ assertTrue(this.si.isNotZero());
+ // make a reasonable guess about how long t2 took
+ long time = this.calculateElapsedTime();
+ assertTrue("t2 finished a bit early (expected value should be > " + TICK + "): " + time, time > TICK);
+ }
+
+ /**
+ * t2 will wait indefinitely until t1 sets the value to 0;
+ * then t2 will set the value to 7
+ */
+ public void testWaitToSetValue2() throws Exception {
this.verifyWaitToSetValue(0); // 0 = indefinite wait
// no timeout occurs...
assertFalse(this.timeoutOccurred);
@@ -241,10 +774,71 @@ public class SynchronizedIntTests
assertTrue("t2 finished a bit late (expected value should be < " + THREE_TICKS + "): " + time, time < THREE_TICKS);
}
+ /**
+ * t2 will time out waiting for t1 to set the value to 0
+ */
+ public void testWaitToSetValueTimeout2() throws Exception {
+ this.verifyWaitToSetValue(THREE_TICKS);
+ // no timeout occurs...
+ assertFalse(this.timeoutOccurred);
+ // ...and the value should be set to zero by t2
+ assertFalse(this.si.isZero());
+ // make a reasonable guess about how long t2 took
+ long time = this.calculateElapsedTime();
+ assertTrue("t2 finished a bit early (expected value should be >= " + TWO_TICKS + "): " + time, time >= TWO_TICKS);
+ }
+
private void verifyWaitToSetValue(long t2Timeout) throws Exception {
this.executeThreads(this.buildSetZeroCommand(), this.buildWaitToSetValueCommand(t2Timeout));
}
+ private Command buildWaitToSetValueCommand(final long timeout) {
+ return new Command() {
+ public void execute(SynchronizedInt sInt) throws InterruptedException {
+ SynchronizedIntTests.this.startTime = System.currentTimeMillis();
+ SynchronizedIntTests.this.timeoutOccurred = this.timeoutOccurred(sInt);
+ SynchronizedIntTests.this.endTime = System.currentTimeMillis();
+ }
+ private boolean timeoutOccurred(SynchronizedInt sInt) throws InterruptedException {
+ if (timeout < 0) {
+ sInt.waitToSetValue(SynchronizedIntTests.this.value);
+ return false;
+ }
+ return ! sInt.waitToSetValue(SynchronizedIntTests.this.value, timeout);
+ }
+ };
+ }
+
+ public void testWaitToSetZero() throws Exception {
+ this.si.setValue(3);
+ this.si.waitToSetZero();
+ assertEquals(0, this.si.getValue());
+ }
+
+ public void testWaitToSetZeroTimeout() throws Exception {
+ this.si.setValue(3);
+ this.si.waitToSetZero(TWO_TICKS);
+ assertEquals(0, this.si.getValue());
+ }
+
+ public void testWaitToCommit() throws Exception {
+ this.si.setValue(3);
+ this.si.waitToCommit(7, 3);
+ assertEquals(7, this.si.getValue());
+ }
+
+ public void testWaitToCommitTimeout() throws Exception {
+ this.si.setValue(3);
+ assertTrue(this.si.waitToCommit(7, 3, TWO_TICKS));
+ assertEquals(7, this.si.getValue());
+ }
+
+ public void testWaitToCommitTimeout2() throws Exception {
+ this.si.setValue(3);
+ assertFalse(this.si.waitToCommit(7, 333, TWO_TICKS));
+ assertEquals(3, this.si.getValue());
+ }
+
/**
* t2 will wait until t1 is finished "initializing" the value;
* then t2 will get the newly-initialized value (42)
@@ -287,26 +881,6 @@ public class SynchronizedIntTests
};
}
- private Command buildWaitUntilZeroCommand(final long timeout) {
- return new Command() {
- public void execute(SynchronizedInt sInt) throws InterruptedException {
- SynchronizedIntTests.this.startTime = System.currentTimeMillis();
- SynchronizedIntTests.this.timeoutOccurred = ! sInt.waitUntilZero(timeout);
- SynchronizedIntTests.this.endTime = System.currentTimeMillis();
- }
- };
- }
-
- private Command buildWaitToSetValueCommand(final long timeout) {
- return new Command() {
- public void execute(SynchronizedInt sInt) throws InterruptedException {
- SynchronizedIntTests.this.startTime = System.currentTimeMillis();
- SynchronizedIntTests.this.timeoutOccurred = ! sInt.waitToSetValue(SynchronizedIntTests.this.value, timeout);
- SynchronizedIntTests.this.endTime = System.currentTimeMillis();
- }
- };
- }
-
private Command buildInitializeValueCommand() {
return new Command() {
public void execute(final SynchronizedInt sInt) throws InterruptedException {
@@ -353,10 +927,60 @@ public class SynchronizedIntTests
return this.endTime - this.startTime;
}
+ public void testCompareTo() throws Exception {
+ IntReference ref = this.si;
+ assertEquals(0, this.si.compareTo(ref));
+
+ ModifiableIntReference other = new SimpleIntReference(42);
+ assertTrue(this.si.compareTo(other) < 0);
+ assertTrue(other.compareTo(this.si) > 0);
+
+ this.si.setValue(44);
+ assertTrue(this.si.compareTo(other) > 0);
+ assertTrue(other.compareTo(this.si) < 0);
+ }
+
// ********** Command interface **********
private interface Command {
void execute(SynchronizedInt sInt) throws InterruptedException;
}
+
+
+ // ********** standard methods **********
+
+ public void testEquals() {
+ SynchronizedInt si2 = new SynchronizedInt();
+ assertTrue(this.si.equals(this.si));
+ assertFalse(this.si.equals(si2));
+ }
+
+ public void testHashCode() {
+ assertEquals(this.si.hashCode(), this.si.hashCode());
+ }
+
+ public void testClone() {
+ SynchronizedInt clone = this.si.clone();
+ assertEquals(0, clone.getValue());
+ assertNotSame(clone, this.si);
+
+ this.si.setValue(42);
+ clone = this.si.clone();
+ assertEquals(42, clone.getValue());
+ assertNotSame(clone, this.si);
+ }
+
+ public void testSerialization() throws Exception {
+ this.si.setValue(44);
+ SynchronizedInt clone = TestTools.serialize(this.si);
+ assertNotSame(this.si, clone);
+ assertEquals(44, clone.getValue());
+ }
+
+ public void testToString() {
+ assertEquals("[0]", this.si.toString());
+ this.si.setValue(42);
+ assertEquals("[42]", this.si.toString());
+ }
}

Back to the top