Menu
▾
▴
[Rails-commits] Branch 'rails2.0' - 6 commits - .classpath junit/lib junit/rails src/rails
|
From: Stefan F. <ste...@us...> - 2012-07-20 07:59:18
|
.classpath | 4
dev/null |binary
junit/lib/fest-2.0M6/fest-assert-core-2.0M6.jar |binary
junit/lib/fest-2.0M6/fest-util-1.2.1.jar |binary
junit/rails/game/state/AbstractItemImpl.java | 8
junit/rails/game/state/ArrayListStateTest.java | 245 +++++++++++++++++++++++
junit/rails/game/state/BooleanStateTest.java | 38 +--
junit/rails/game/state/GenericStateTest.java | 54 ++---
junit/rails/game/state/HashMapStateTest.java | 177 ++++++++++++++++
junit/rails/game/state/HashSetStateTest.java | 166 +++++++++++++++
junit/rails/game/state/IntegerStateTest.java | 54 ++---
junit/rails/game/state/StateImpl.java | 6
junit/rails/game/state/StateTestUtils.java | 7
junit/rails/game/state/StringStateTest.java | 72 +++---
src/rails/game/state/AbstractItem.java | 5
src/rails/game/state/ArrayListChange.java | 30 +-
src/rails/game/state/ArrayListMultimapState.java | 5
src/rails/game/state/ArrayListState.java | 73 +++++-
src/rails/game/state/BooleanChange.java | 11 -
src/rails/game/state/BooleanState.java | 2
src/rails/game/state/Context.java | 6
src/rails/game/state/GenericState.java | 5
src/rails/game/state/GenericStateChange.java | 23 --
src/rails/game/state/HashMapChange.java | 19 +
src/rails/game/state/HashMapState.java | 113 ++++++++--
src/rails/game/state/HashMultimapState.java | 2
src/rails/game/state/HashSetChange.java | 21 +
src/rails/game/state/HashSetState.java | 6
src/rails/game/state/IntegerChange.java | 11 -
src/rails/game/state/IntegerState.java | 2
src/rails/game/state/Manager.java | 5
src/rails/game/state/MultimapChange.java | 15 -
src/rails/game/state/Observable.java | 11 +
src/rails/game/state/PortfolioChange.java | 13 -
src/rails/game/state/PortfolioList.java | 5
src/rails/game/state/PortfolioMap.java | 4
src/rails/game/state/Root.java | 6
src/rails/game/state/State.java | 11 -
src/rails/game/state/StringChange.java | 11 -
src/rails/game/state/StringState.java | 2
src/rails/game/state/Wallet.java | 6
src/rails/game/state/WalletChange.java | 13 -
42 files changed, 983 insertions(+), 284 deletions(-)
New commits:
commit 4cc7610949e6fa611f086e2d89b7c2540c18e2a8
Author: Stefan Frey <ste...@we...>
Date: Thu Jul 19 16:48:19 2012 +0200
changed only variable names
diff --git a/junit/rails/game/state/ArrayListStateTest.java b/junit/rails/game/state/ArrayListStateTest.java
index fb11df0..e858570 100644
--- a/junit/rails/game/state/ArrayListStateTest.java
+++ b/junit/rails/game/state/ArrayListStateTest.java
@@ -26,8 +26,8 @@ public class ArrayListStateTest {
private Root root;
private ChangeStack stack;
- private ArrayListState<Item> state_default;
- private ArrayListState<Item> state_init;
+ private ArrayListState<Item> stateDefault;
+ private ArrayListState<Item> stateInit;
private Item oneItem;
private Item anotherItem;
@@ -41,8 +41,8 @@ public class ArrayListStateTest {
oneItem = AbstractItemImpl.create(root, ONE_ITEM_ID);
anotherItem = AbstractItemImpl.create(root, ANOTHER_ITEM_ID);
- state_default = ArrayListState.create(root, DEFAULT_ID);
- state_init = ArrayListState.create(root, INIT_ID, Lists.newArrayList(oneItem));
+ stateDefault = ArrayListState.create(root, DEFAULT_ID);
+ stateInit = ArrayListState.create(root, INIT_ID, Lists.newArrayList(oneItem));
}
// helper function to check the initial state after undo
@@ -50,21 +50,21 @@ public class ArrayListStateTest {
private void assertInitialStateAfterUndo() {
stack.closeCurrentChangeSet();
stack.undo();
- assertEquals(state_default.view(), Lists.newArrayList());
- assertEquals(state_init.view(), Lists.newArrayList(oneItem));
+ assertEquals(stateDefault.view(), Lists.newArrayList());
+ assertEquals(stateInit.view(), Lists.newArrayList(oneItem));
stack.redo();
}
private void assertTestAdd() {
// TODO: replace with containsExactly, this does not work yet
- assertThat(state_default).containsOnly(oneItem);
- assertThat(state_init).containsSequence(oneItem, anotherItem);
+ assertThat(stateDefault).containsOnly(oneItem);
+ assertThat(stateInit).containsSequence(oneItem, anotherItem);
}
@Test
public void testAdd() {
- state_default.add(oneItem);
- state_init.add(anotherItem);
+ stateDefault.add(oneItem);
+ stateInit.add(anotherItem);
assertTestAdd();
// check undo
@@ -74,20 +74,20 @@ public class ArrayListStateTest {
@Test
public void testAddIndex() {
- state_init.add(0, anotherItem);
+ stateInit.add(0, anotherItem);
// TODO: replace with containsExactly, this does not work yet
- assertThat(state_init).containsSequence(anotherItem, oneItem);
- state_init.add(2, anotherItem);
+ assertThat(stateInit).containsSequence(anotherItem, oneItem);
+ stateInit.add(2, anotherItem);
// TODO: replace with containsExactly, this does not work yet
- assertThat(state_init).containsSequence(anotherItem, oneItem, anotherItem);
- state_init.add(1, oneItem);
+ assertThat(stateInit).containsSequence(anotherItem, oneItem, anotherItem);
+ stateInit.add(1, oneItem);
// TODO: replace with containsExactly, this does not work yet
- assertThat(state_init).containsSequence(anotherItem, oneItem, oneItem, anotherItem);
+ assertThat(stateInit).containsSequence(anotherItem, oneItem, oneItem, anotherItem);
// Check undo
assertInitialStateAfterUndo();
// TODO: replace with containsExactly, this does not work yet
- assertThat(state_init).containsSequence(anotherItem, oneItem, oneItem, anotherItem);
+ assertThat(stateInit).containsSequence(anotherItem, oneItem, oneItem, anotherItem);
}
@Test
@@ -95,13 +95,13 @@ public class ArrayListStateTest {
// open new ChangeSet to test if it is still empty
StateTestUtils.startActionChangeSet(root);
try {
- state_init.add(2, anotherItem);
+ stateInit.add(2, anotherItem);
failBecauseExceptionWasNotThrown(IndexOutOfBoundsException.class);
} catch (Exception e) {
assertThat(e).isInstanceOf(IndexOutOfBoundsException.class);
}
try {
- state_init.add(-1, anotherItem);
+ stateInit.add(-1, anotherItem);
failBecauseExceptionWasNotThrown(IndexOutOfBoundsException.class);
} catch (Exception e) {
assertThat(e).isInstanceOf(IndexOutOfBoundsException.class);
@@ -114,105 +114,105 @@ public class ArrayListStateTest {
@Test
public void testRemove() {
// remove a non-existing item
- assertFalse(state_default.remove(oneItem));
+ assertFalse(stateDefault.remove(oneItem));
// remove an existing item
- assertTrue(state_init.remove(oneItem));
+ assertTrue(stateInit.remove(oneItem));
- assertThat(state_init).doesNotContain(oneItem);
+ assertThat(stateInit).doesNotContain(oneItem);
// check undo
assertInitialStateAfterUndo();
// ... and the redo
- assertThat(state_init).doesNotContain(oneItem);
+ assertThat(stateInit).doesNotContain(oneItem);
}
@Test
public void testMove() {
- state_init.add(0, anotherItem);
+ stateInit.add(0, anotherItem);
// TODO: replace with containsExactly, this does not work yet
- assertThat(state_init).containsSequence(anotherItem, oneItem);
+ assertThat(stateInit).containsSequence(anotherItem, oneItem);
- state_init.move(oneItem, 0);
+ stateInit.move(oneItem, 0);
// TODO: replace with containsExactly, this does not work yet
- assertThat(state_init).containsSequence(oneItem, anotherItem);
+ assertThat(stateInit).containsSequence(oneItem, anotherItem);
- state_init.move(oneItem, 1);
+ stateInit.move(oneItem, 1);
// TODO: replace with containsExactly, this does not work yet
- assertThat(state_init).containsSequence(anotherItem, oneItem);
+ assertThat(stateInit).containsSequence(anotherItem, oneItem);
// try illegal move and check if nothing has changed
try {
- state_init.move(oneItem, 2);
+ stateInit.move(oneItem, 2);
failBecauseExceptionWasNotThrown(IndexOutOfBoundsException.class);
} catch (Exception e) {
assertThat(e).isInstanceOf(IndexOutOfBoundsException.class);
}
// TODO: replace with containsExactly, this does not work yet
- assertThat(state_init).containsSequence(anotherItem, oneItem);
+ assertThat(stateInit).containsSequence(anotherItem, oneItem);
// check undo
assertInitialStateAfterUndo();
// ... and the redo
// TODO: replace with containsExactly, this does not work yet
- assertThat(state_init).containsSequence(anotherItem, oneItem);
+ assertThat(stateInit).containsSequence(anotherItem, oneItem);
}
@Test
public void testContains() {
- assertTrue(state_init.contains(oneItem));
- assertFalse(state_init.contains(anotherItem));
+ assertTrue(stateInit.contains(oneItem));
+ assertFalse(stateInit.contains(anotherItem));
}
@Test
public void testClear() {
- state_init.add(anotherItem);
- state_init.clear();
- assertTrue(state_init.isEmpty());
+ stateInit.add(anotherItem);
+ stateInit.clear();
+ assertTrue(stateInit.isEmpty());
// check undo and redo
assertInitialStateAfterUndo();
- assertTrue(state_init.isEmpty());
+ assertTrue(stateInit.isEmpty());
}
@Test
public void testView() {
ImmutableList<Item> list = ImmutableList.of(oneItem);
- assertEquals(list, state_init.view());
+ assertEquals(list, stateInit.view());
}
@Test
public void testSize() {
- assertEquals(0, state_default.size());
- assertEquals(1, state_init.size());
- state_init.add(anotherItem);
- state_init.add(oneItem);
- assertEquals(3, state_init.size());
+ assertEquals(0, stateDefault.size());
+ assertEquals(1, stateInit.size());
+ stateInit.add(anotherItem);
+ stateInit.add(oneItem);
+ assertEquals(3, stateInit.size());
}
@Test
public void testIsEmpty() {
- assertTrue(state_default.isEmpty());
- assertFalse(state_init.isEmpty());
+ assertTrue(stateDefault.isEmpty());
+ assertFalse(stateInit.isEmpty());
}
@Test
public void testIndexOf() {
- state_init.add(anotherItem);
- assertEquals(0, state_init.indexOf(oneItem));
- assertEquals(1, state_init.indexOf(anotherItem));
+ stateInit.add(anotherItem);
+ assertEquals(0, stateInit.indexOf(oneItem));
+ assertEquals(1, stateInit.indexOf(anotherItem));
// check if not included
- assertEquals(-1, state_default.indexOf(oneItem));
+ assertEquals(-1, stateDefault.indexOf(oneItem));
}
@Test
public void testGet() {
- state_init.add(anotherItem);
- assertSame(oneItem, state_init.get(0));
- assertSame(anotherItem, state_init.get(1));
+ stateInit.add(anotherItem);
+ assertSame(oneItem, stateInit.get(0));
+ assertSame(anotherItem, stateInit.get(1));
// check index out of bound
try {
- state_init.get(2);
+ stateInit.get(2);
failBecauseExceptionWasNotThrown(IndexOutOfBoundsException.class);
} catch (Exception e) {
assertThat(e).isInstanceOf(IndexOutOfBoundsException.class);
@@ -220,21 +220,21 @@ public class ArrayListStateTest {
}
private void assertTestIterator() {
- Iterator<Item> it = state_init.iterator();
+ Iterator<Item> it = stateInit.iterator();
assertSame(oneItem,it.next());
assertSame(anotherItem,it.next());
// iterator is finished
assertFalse(it.hasNext());
// iterator is an immutable copy, thus not changed by adding a new item
- state_init.add(oneItem);
+ stateInit.add(oneItem);
assertFalse(it.hasNext());
// remove the last added item
- state_init.remove(state_init.size()-1);
+ stateInit.remove(stateInit.size()-1);
}
@Test
public void testIterator() {
- state_init.add(anotherItem);
+ stateInit.add(anotherItem);
assertTestIterator();
// check initial state after undo
assertInitialStateAfterUndo();
diff --git a/junit/rails/game/state/BooleanStateTest.java b/junit/rails/game/state/BooleanStateTest.java
index 51427af..c40fce5 100644
--- a/junit/rails/game/state/BooleanStateTest.java
+++ b/junit/rails/game/state/BooleanStateTest.java
@@ -13,50 +13,50 @@ public class BooleanStateTest {
private Root root;
private ChangeStack stack;
- private BooleanState state_default;
- private BooleanState state_init;
+ private BooleanState stateDefault;
+ private BooleanState stateInit;
@Before
public void setUp() {
root = StateTestUtils.setUpRoot();
- state_default = BooleanState.create(root, DEFAULT_ID);
- state_init = BooleanState.create(root, INIT_ID, true);
+ stateDefault = BooleanState.create(root, DEFAULT_ID);
+ stateInit = BooleanState.create(root, INIT_ID, true);
stack = root.getStateManager().getChangeStack();
}
@Test
public void testValue() {
- assertFalse(state_default.value());
- assertTrue(state_init.value());
+ assertFalse(stateDefault.value());
+ assertTrue(stateInit.value());
}
@Test
public void testSet() {
- state_default.set(true);
- assertTrue(state_default.value());
- state_init.set(false);
- assertFalse(state_init.value());
+ stateDefault.set(true);
+ assertTrue(stateDefault.value());
+ stateInit.set(false);
+ assertFalse(stateInit.value());
}
@Test
public void testSetSameIgnored() {
- state_default.set(false);
- state_init.set(true);
+ stateDefault.set(false);
+ stateInit.set(true);
stack.closeCurrentChangeSet();
- assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(state_default, state_init);
+ assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(stateDefault, stateInit);
}
@Test
public void testUndoRedo() {
- assertFalse(state_default.value());
- state_default.set(true);
- assertTrue(state_default.value());
+ assertFalse(stateDefault.value());
+ stateDefault.set(true);
+ assertTrue(stateDefault.value());
stack.closeCurrentChangeSet();
- assertThat(stack.getLastClosedChangeSet().getStates()).contains(state_default);
+ assertThat(stack.getLastClosedChangeSet().getStates()).contains(stateDefault);
stack.undo();
- assertFalse(state_default.value());
+ assertFalse(stateDefault.value());
stack.redo();
- assertTrue(state_default.value());
+ assertTrue(stateDefault.value());
}
}
diff --git a/junit/rails/game/state/GenericStateTest.java b/junit/rails/game/state/GenericStateTest.java
index aaccd90..b423e3c 100644
--- a/junit/rails/game/state/GenericStateTest.java
+++ b/junit/rails/game/state/GenericStateTest.java
@@ -15,8 +15,8 @@ public class GenericStateTest {
private Root root;
private ChangeStack stack;
- private GenericState<Item> state_default;
- private GenericState<Item> state_init;
+ private GenericState<Item> stateDefault;
+ private GenericState<Item> stateInit;
private Item item, another_item;
@@ -28,55 +28,55 @@ public class GenericStateTest {
item = new AbstractItemImpl(root, ITEM_ID);
another_item = new AbstractItemImpl(root, ANOTHER_ID);
- state_default = GenericState.create(root, DEFAULT_ID);
- state_init = GenericState.create(root, INIT_ID, item);
+ stateDefault = GenericState.create(root, DEFAULT_ID);
+ stateInit = GenericState.create(root, INIT_ID, item);
}
@Test
public void testValue() {
- assertNull(state_default.value());
- assertSame(item, state_init.value());
+ assertNull(stateDefault.value());
+ assertSame(item, stateInit.value());
}
@Test
public void testSet() {
- state_default.set(item);
- assertSame(item, state_default.value());
- state_default.set(null);
- assertNull(state_default.value());
- state_init.set(another_item);
- assertSame(another_item, state_init.value());
+ stateDefault.set(item);
+ assertSame(item, stateDefault.value());
+ stateDefault.set(null);
+ assertNull(stateDefault.value());
+ stateInit.set(another_item);
+ assertSame(another_item, stateInit.value());
}
@Test
public void testSetSameIgnored() {
- state_default.set(null);
- state_init.set(item);
+ stateDefault.set(null);
+ stateInit.set(item);
stack.closeCurrentChangeSet();
- assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(state_default, state_init);
+ assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(stateDefault, stateInit);
}
@Test
public void testUndoRedo() {
- assertNull(state_default.value());
- assertSame(item, state_init.value());
+ assertNull(stateDefault.value());
+ assertSame(item, stateInit.value());
- state_default.set(item);
- state_init.set(another_item);
- assertSame(item, state_default.value());
- assertSame(another_item, state_init.value());
+ stateDefault.set(item);
+ stateInit.set(another_item);
+ assertSame(item, stateDefault.value());
+ assertSame(another_item, stateInit.value());
stack.closeCurrentChangeSet();
- // remark: state_init is an internal (isObservable = false)
- assertThat(stack.getLastClosedChangeSet().getStates()).contains(state_default);
+ // remark: stateInit is an internal (isObservable = false)
+ assertThat(stack.getLastClosedChangeSet().getStates()).contains(stateDefault);
stack.undo();
- assertNull(state_default.value());
- assertSame(item, state_init.value());
+ assertNull(stateDefault.value());
+ assertSame(item, stateInit.value());
stack.redo();
- assertSame(item, state_default.value());
- assertSame(another_item, state_init.value());
+ assertSame(item, stateDefault.value());
+ assertSame(another_item, stateInit.value());
}
}
diff --git a/junit/rails/game/state/HashSetStateTest.java b/junit/rails/game/state/HashSetStateTest.java
index f30d078..02d76ff 100644
--- a/junit/rails/game/state/HashSetStateTest.java
+++ b/junit/rails/game/state/HashSetStateTest.java
@@ -26,8 +26,8 @@ public class HashSetStateTest {
private Root root;
private ChangeStack stack;
- private HashSetState<Item> state_default;
- private HashSetState<Item> state_init;
+ private HashSetState<Item> stateDefault;
+ private HashSetState<Item> stateInit;
private Item oneItem;
private Item anotherItem;
@@ -41,8 +41,8 @@ public class HashSetStateTest {
oneItem = AbstractItemImpl.create(root, ONE_ITEM_ID);
anotherItem = AbstractItemImpl.create(root, ANOTHER_ITEM_ID);
- state_default = HashSetState.create(root, DEFAULT_ID);
- state_init = HashSetState.create(root, INIT_ID, Sets.newHashSet(oneItem));
+ stateDefault = HashSetState.create(root, DEFAULT_ID);
+ stateInit = HashSetState.create(root, INIT_ID, Sets.newHashSet(oneItem));
}
@@ -59,20 +59,20 @@ public class HashSetStateTest {
private void assertInitialStateAfterUndo() {
stack.closeCurrentChangeSet();
stack.undo();
- assertEquals(state_default.view(), Sets.newHashSet());
- assertEquals(state_init.view(), Sets.newHashSet(oneItem));
+ assertEquals(stateDefault.view(), Sets.newHashSet());
+ assertEquals(stateInit.view(), Sets.newHashSet(oneItem));
stack.redo();
}
private void assertTestAdd() {
- assertThat(state_default).containsOnly(oneItem);
- assertThat(state_init).containsOnly(oneItem, anotherItem);
+ assertThat(stateDefault).containsOnly(oneItem);
+ assertThat(stateInit).containsOnly(oneItem, anotherItem);
}
@Test
public void testAdd() {
- state_default.add(oneItem);
- state_init.add(anotherItem);
+ stateDefault.add(oneItem);
+ stateInit.add(anotherItem);
assertTestAdd();
// check undo
@@ -83,62 +83,62 @@ public class HashSetStateTest {
@Test
public void testRemove() {
// remove a non-existing item
- assertFalse(state_default.remove(oneItem));
+ assertFalse(stateDefault.remove(oneItem));
// remove an existing item
- assertTrue(state_init.remove(oneItem));
+ assertTrue(stateInit.remove(oneItem));
- assertThat(state_init).doesNotContain(oneItem);
+ assertThat(stateInit).doesNotContain(oneItem);
// check undo
assertInitialStateAfterUndo();
// ... and the redo
- assertThat(state_init).doesNotContain(oneItem);
+ assertThat(stateInit).doesNotContain(oneItem);
}
@Test
public void testContains() {
- assertTrue(state_init.contains(oneItem));
- assertFalse(state_init.contains(anotherItem));
+ assertTrue(stateInit.contains(oneItem));
+ assertFalse(stateInit.contains(anotherItem));
}
@Test
public void testClear() {
- state_init.add(anotherItem);
- state_init.clear();
- assertTrue(state_init.isEmpty());
+ stateInit.add(anotherItem);
+ stateInit.clear();
+ assertTrue(stateInit.isEmpty());
// check undo and redo
assertInitialStateAfterUndo();
- assertTrue(state_init.isEmpty());
+ assertTrue(stateInit.isEmpty());
}
@Test
public void testView() {
ImmutableSet<Item> list = ImmutableSet.of(oneItem);
- assertEquals(list, state_init.view());
+ assertEquals(list, stateInit.view());
}
@Test
public void testSize() {
- assertEquals(0, state_default.size());
- assertEquals(1, state_init.size());
- state_init.add(anotherItem);
- assertEquals(2, state_init.size());
- state_init.add(oneItem);
- assertEquals(2, state_init.size());
+ assertEquals(0, stateDefault.size());
+ assertEquals(1, stateInit.size());
+ stateInit.add(anotherItem);
+ assertEquals(2, stateInit.size());
+ stateInit.add(oneItem);
+ assertEquals(2, stateInit.size());
}
@Test
public void testIsEmpty() {
- assertTrue(state_default.isEmpty());
- assertFalse(state_init.isEmpty());
+ assertTrue(stateDefault.isEmpty());
+ assertFalse(stateInit.isEmpty());
}
private void assertTestIterator(Item thirdItem) {
// no order is defined, so store them
Set<Item> iterated = Sets.newHashSet();
- Iterator<Item> it = state_init.iterator();
+ Iterator<Item> it = stateInit.iterator();
iterated.add(it.next());
iterated.add(it.next());
@@ -146,15 +146,15 @@ public class HashSetStateTest {
// iterator is finished
assertFalse(it.hasNext());
// iterator is an immutable copy, thus not changed by adding a new item
- state_init.add(thirdItem);
+ stateInit.add(thirdItem);
assertFalse(it.hasNext());
// remove the last added item
- state_init.remove(thirdItem);
+ stateInit.remove(thirdItem);
}
@Test
public void testIterator() {
- state_init.add(anotherItem);
+ stateInit.add(anotherItem);
Item thirdItem = AbstractItemImpl.create(root, "Third");
assertTestIterator(thirdItem);
// check initial state after undo
diff --git a/junit/rails/game/state/IntegerStateTest.java b/junit/rails/game/state/IntegerStateTest.java
index 9c183a3..fed226c 100644
--- a/junit/rails/game/state/IntegerStateTest.java
+++ b/junit/rails/game/state/IntegerStateTest.java
@@ -15,8 +15,8 @@ public class IntegerStateTest {
private Root root;
private ChangeStack stack;
- private IntegerState state_default;
- private IntegerState state_init;
+ private IntegerState stateDefault;
+ private IntegerState stateInit;
@Before
@@ -24,62 +24,62 @@ public class IntegerStateTest {
root = StateTestUtils.setUpRoot();
stack = root.getStateManager().getChangeStack();
- state_default = IntegerState.create(root, DEFAULT_ID);
- state_init = IntegerState.create(root, INIT_ID, INIT);
+ stateDefault = IntegerState.create(root, DEFAULT_ID);
+ stateInit = IntegerState.create(root, INIT_ID, INIT);
}
@Test
public void testValue() {
- assertEquals(state_default.value(), 0);
- assertEquals(state_init.value(), INIT);
+ assertEquals(stateDefault.value(), 0);
+ assertEquals(stateInit.value(), INIT);
}
@Test
public void testSet() {
- state_default.set(OTHER);
- assertEquals(state_default.value(), OTHER);
- state_init.set(0);
- assertEquals(state_init.value(), 0);
+ stateDefault.set(OTHER);
+ assertEquals(stateDefault.value(), OTHER);
+ stateInit.set(0);
+ assertEquals(stateInit.value(), 0);
}
@Test
public void testAdd() {
- state_default.add(OTHER);
- assertEquals(state_default.value(), OTHER);
- state_init.add(OTHER);
- assertEquals(state_init.value(), INIT + OTHER);
+ stateDefault.add(OTHER);
+ assertEquals(stateDefault.value(), OTHER);
+ stateInit.add(OTHER);
+ assertEquals(stateInit.value(), INIT + OTHER);
}
@Test
public void testSetSameIgnored() {
- state_default.set(0);
- state_init.set((INIT));
+ stateDefault.set(0);
+ stateInit.set((INIT));
stack.closeCurrentChangeSet();
- assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(state_default, state_init);
+ assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(stateDefault, stateInit);
}
@Test
public void testUndoRedo() {
- state_default.set(INIT);
- state_default.add(OTHER);
+ stateDefault.set(INIT);
+ stateDefault.add(OTHER);
- state_init.add(OTHER);
- state_init.set(0);
+ stateInit.add(OTHER);
+ stateInit.set(0);
stack.closeCurrentChangeSet();
- assertEquals(state_default.value(), INIT+OTHER);
- assertEquals(state_init.value(), 0);
+ assertEquals(stateDefault.value(), INIT+OTHER);
+ assertEquals(stateInit.value(), 0);
stack.undo();
- assertEquals(state_default.value(), 0);
- assertEquals(state_init.value(), INIT);
+ assertEquals(stateDefault.value(), 0);
+ assertEquals(stateInit.value(), INIT);
stack.redo();
- assertEquals(state_default.value(), INIT+OTHER);
- assertEquals(state_init.value(), 0);
+ assertEquals(stateDefault.value(), INIT+OTHER);
+ assertEquals(stateInit.value(), 0);
}
}
diff --git a/junit/rails/game/state/StringStateTest.java b/junit/rails/game/state/StringStateTest.java
index 814706d..31bff01 100644
--- a/junit/rails/game/state/StringStateTest.java
+++ b/junit/rails/game/state/StringStateTest.java
@@ -17,8 +17,8 @@ public class StringStateTest {
private Root root;
private ChangeStack stack;
- private StringState state_default;
- private StringState state_init;
+ private StringState stateDefault;
+ private StringState stateInit;
@Before
@@ -26,73 +26,73 @@ public class StringStateTest {
root = StateTestUtils.setUpRoot();
stack = root.getStateManager().getChangeStack();
- state_default = StringState.create(root, DEFAULT_ID);
- state_init = StringState.create(root, INIT_ID, INIT);
+ stateDefault = StringState.create(root, DEFAULT_ID);
+ stateInit = StringState.create(root, INIT_ID, INIT);
}
@Test
public void testValue() {
- assertEquals(state_default.value(), "");
- assertEquals(state_init.value(), INIT);
+ assertEquals(stateDefault.value(), "");
+ assertEquals(stateInit.value(), INIT);
}
@Test
public void testSet() {
- state_default.set(OTHER);
- assertEquals(state_default.value(), OTHER);
- state_init.set("");
- assertEquals(state_init.value(), "");
- state_init.set(null);
- assertEquals(state_init.value(), null);
+ stateDefault.set(OTHER);
+ assertEquals(stateDefault.value(), OTHER);
+ stateInit.set("");
+ assertEquals(stateInit.value(), "");
+ stateInit.set(null);
+ assertEquals(stateInit.value(), null);
}
@Test
public void testAppend() {
- state_default.append(OTHER, null);
- assertEquals(state_default.value(), OTHER);
- state_default.append(OTHER, "");
- assertEquals(state_default.value(), OTHER + OTHER);
+ stateDefault.append(OTHER, null);
+ assertEquals(stateDefault.value(), OTHER);
+ stateDefault.append(OTHER, "");
+ assertEquals(stateDefault.value(), OTHER + OTHER);
- state_init.append(OTHER, ",");
- assertEquals(state_init.value(), INIT + "," + OTHER);
+ stateInit.append(OTHER, ",");
+ assertEquals(stateInit.value(), INIT + "," + OTHER);
}
@Test
public void testSetSameIgnored() {
- state_default.set("");
- state_init.set(null);
+ stateDefault.set("");
+ stateInit.set(null);
stack.closeCurrentChangeSet();
- assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(state_default);
- assertThat(stack.getLastClosedChangeSet().getStates()).contains(state_init);
+ assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(stateDefault);
+ assertThat(stack.getLastClosedChangeSet().getStates()).contains(stateInit);
- state_default.set(null);
- state_init.set(null);
+ stateDefault.set(null);
+ stateInit.set(null);
stack.closeCurrentChangeSet();
- assertThat(stack.getLastClosedChangeSet().getStates()).contains(state_default);
- assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(state_init);
+ assertThat(stack.getLastClosedChangeSet().getStates()).contains(stateDefault);
+ assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(stateInit);
}
@Test
public void testUndoRedo() {
- state_default.set(OTHER);
- state_default.append(OTHER, null);
+ stateDefault.set(OTHER);
+ stateDefault.append(OTHER, null);
- state_init.append(OTHER, "");
- state_init.set(null);
+ stateInit.append(OTHER, "");
+ stateInit.set(null);
stack.closeCurrentChangeSet();
- assertEquals(state_default.value(), OTHER+OTHER);
- assertNull(state_init.value());
+ assertEquals(stateDefault.value(), OTHER+OTHER);
+ assertNull(stateInit.value());
stack.undo();
- assertEquals(state_default.value(), "");
- assertEquals(state_init.value(), INIT);
+ assertEquals(stateDefault.value(), "");
+ assertEquals(stateInit.value(), INIT);
stack.redo();
- assertEquals(state_default.value(), OTHER+OTHER);
- assertNull(state_init.value());
+ assertEquals(stateDefault.value(), OTHER+OTHER);
+ assertNull(stateInit.value());
}
commit 24d0379866ab5428a071d255151025e4fafd7340
Author: Stefan Frey <ste...@we...>
Date: Thu Jul 19 16:46:04 2012 +0200
added tests for HashMapState
diff --git a/junit/rails/game/state/HashMapStateTest.java b/junit/rails/game/state/HashMapStateTest.java
new file mode 100644
index 0000000..959e1f9
--- /dev/null
+++ b/junit/rails/game/state/HashMapStateTest.java
@@ -0,0 +1,177 @@
+package rails.game.state;
+
+import static org.fest.assertions.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+
+public class HashMapStateTest {
+
+ private final static String DEFAULT_ID = "Default";
+ private final static String INIT_ID = "Init";
+
+ private final static String FIRST_ITEM_ID = "FirstItem";
+ private final static String SECOND_ITEM_ID = "SecondItem";
+ private final static String THIRD_ITEM_ID = "ThirdItem";
+
+ private Root root;
+ private ChangeStack stack;
+ private HashMapState<String, Item> state_default;
+ private HashMapState<String, Item> stateInit;
+ private Map<String, Item> initMap, testMap;
+
+ private Item firstItem, secondItem, thirdItem;
+
+ @Before
+ public void setUp() {
+ root = StateTestUtils.setUpRoot();
+ stack = root.getStateManager().getChangeStack();
+
+ firstItem = AbstractItemImpl.create(root, FIRST_ITEM_ID);
+ secondItem = AbstractItemImpl.create(root, SECOND_ITEM_ID);
+ thirdItem = AbstractItemImpl.create(root, THIRD_ITEM_ID);
+
+ state_default = HashMapState.create(root, DEFAULT_ID);
+
+ // intialize stateInit with initMap and create testMap
+ testMap = Maps.newHashMap();
+ testMap.put(FIRST_ITEM_ID, firstItem);
+ initMap = ImmutableMap.copyOf(testMap);
+ stateInit = HashMapState.create(root, INIT_ID, testMap);
+ testMap.put(SECOND_ITEM_ID, secondItem);
+ }
+
+
+ @Test
+ public void testCreate() {
+ HashMapState<String, Item> state = HashMapState.create(root, "Test");
+ assertThat(state.viewMap()).isEmpty();
+ }
+
+ @Test
+ public void testCreateMapOfKV() {
+ HashMapState<String, Item> state = HashMapState.create(root, "Test", testMap);
+ assertEquals(state.viewMap(), testMap);
+ }
+
+ // helper function to check the initial state after undo
+ // includes redo, so after returning the state should be unchanged
+ private void assertInitialStateAfterUndo() {
+ stack.closeCurrentChangeSet();
+ stack.undo();
+ assertThat(state_default.viewMap()).isEmpty();
+ assertEquals(stateInit.viewMap(), initMap);
+ stack.redo();
+ }
+
+
+ @Test
+ public void testPut() {
+ for (String key: testMap.keySet()) {
+ state_default.put(key, testMap.get(key));
+ stateInit.put(key, testMap.get(key));
+ }
+ assertEquals(state_default.viewMap(), testMap);
+ assertEquals(stateInit.viewMap(), testMap);
+
+ // check undo and redo
+ assertInitialStateAfterUndo();
+ assertEquals(state_default.viewMap(), testMap);
+ assertEquals(stateInit.viewMap(), testMap);
+ }
+
+ // includes tests for viewMap
+ @Test
+ public void testPutAll() {
+ stateInit.putAll(testMap);
+ state_default.putAll(testMap);
+ assertEquals(state_default.viewMap(), testMap);
+ assertEquals(stateInit.viewMap(), testMap);
+
+ // check undo and redo
+ assertInitialStateAfterUndo();
+ assertEquals(testMap, state_default.viewMap());
+ assertEquals(testMap, stateInit.viewMap());
+ }
+
+ @Test
+ public void testGet() {
+ assertEquals(firstItem, stateInit.get(FIRST_ITEM_ID));
+ assertNull(stateInit.get(SECOND_ITEM_ID));
+ }
+
+ @Test
+ public void testRemove() {
+ stateInit.remove(FIRST_ITEM_ID);
+ assertNull(stateInit.get(FIRST_ITEM_ID));
+
+ // check undo and redo
+ assertInitialStateAfterUndo();
+ assertNull(stateInit.get(FIRST_ITEM_ID));
+ }
+
+ @Test
+ public void testContainsKey() {
+ state_default.put(THIRD_ITEM_ID, thirdItem);
+ assertTrue(state_default.containsKey(THIRD_ITEM_ID));
+
+ assertTrue(stateInit.containsKey(FIRST_ITEM_ID));
+ assertFalse(stateInit.containsKey(SECOND_ITEM_ID));
+ }
+
+ @Test
+ public void testClear() {
+ state_default.putAll(testMap);
+ state_default.clear();
+ assertTrue(state_default.isEmpty());
+
+ // check undo and redo
+ assertInitialStateAfterUndo();
+ assertTrue(state_default.isEmpty());
+ }
+
+ @Test
+ public void testIsEmpty() {
+ assertTrue(state_default.isEmpty());
+ state_default.put(FIRST_ITEM_ID, firstItem);
+ assertFalse(state_default.isEmpty());
+
+ assertFalse(stateInit.isEmpty());
+ stateInit.remove(FIRST_ITEM_ID);
+ assertTrue(stateInit.isEmpty());
+ }
+
+
+ @Test
+ public void testInitFromMap() {
+ state_default.put(THIRD_ITEM_ID, thirdItem);
+ state_default.initFromMap(testMap);
+ assertEquals(testMap, state_default.viewMap());
+
+ // check undo and redo
+ assertInitialStateAfterUndo();
+ assertEquals(ImmutableMap.copyOf(testMap), state_default.viewMap());
+ }
+
+ @Test
+ public void testViewKeySet() {
+ state_default.putAll(testMap);
+ assertThat(state_default.viewKeySet()).containsAll(testMap.keySet());
+ }
+
+ @Test
+ public void testViewValues() {
+ state_default.putAll(testMap);
+ assertThat(state_default.viewValues()).containsAll(testMap.values());
+ }
+
+}
diff --git a/junit/rails/game/state/HashSetStateTest.java b/junit/rails/game/state/HashSetStateTest.java
index 004b147..f30d078 100644
--- a/junit/rails/game/state/HashSetStateTest.java
+++ b/junit/rails/game/state/HashSetStateTest.java
@@ -3,10 +3,10 @@ package rails.game.state;
import static org.fest.assertions.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import java.util.Iterator;
+import java.util.Set;
import org.junit.Before;
@@ -135,9 +135,14 @@ public class HashSetStateTest {
}
private void assertTestIterator(Item thirdItem) {
+ // no order is defined, so store them
+ Set<Item> iterated = Sets.newHashSet();
+
Iterator<Item> it = state_init.iterator();
- assertSame(oneItem,it.next());
- assertSame(anotherItem,it.next());
+ iterated.add(it.next());
+ iterated.add(it.next());
+
+ assertThat(iterated).containsOnly(oneItem, anotherItem);
// iterator is finished
assertFalse(it.hasNext());
// iterator is an immutable copy, thus not changed by adding a new item
diff --git a/src/rails/game/state/HashMapState.java b/src/rails/game/state/HashMapState.java
index ab4ae57..be193b1 100644
--- a/src/rails/game/state/HashMapState.java
+++ b/src/rails/game/state/HashMapState.java
@@ -8,8 +8,12 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
+import static com.google.common.base.Preconditions.checkNotNull;
/**
* A stateful version of a HashMap
@@ -25,6 +29,7 @@ public final class HashMapState<K,V> extends State {
}
/**
+ * creates an empty HashMapState
* @return empty HashMapState
*/
public static <K,V> HashMapState<K,V> create(Item parent, String id){
@@ -32,78 +37,132 @@ public final class HashMapState<K,V> extends State {
}
/**
- * @return prefilled HashMapState
+ * creates an initialized (filled) HashMapState
+ * @param map used for initialization
+ * @return initialized HashMapState
*/
public static <K,V> HashMapState<K,V> create(Item parent, String id, Map<K,V> map){
return new HashMapState<K,V>(parent, id, map);
}
- public void put(K key, V value) {
- // check if element already has the specified value
- if (map.containsKey(key) && map.get(key).equals(value)) return;
- new HashMapChange<K,V>(this, key, value);
+ /**
+ * Add key,value pair to map
+ * @param key for mapping
+ * @param value associated with key
+ * @return previous value associated with specified key, or null if there was no mapping for the key (or null was the value).
+ */
+ public V put(K key, V value) {
+ // check if the key is in the map
+ if (map.containsKey(key)) {
+ V oldValue = map.get(key);
+ // check if element already has the specified value
+ if (!oldValue.equals(value)) {
+ new HashMapChange<K,V>(this, key, value);
+ }
+ return oldValue;
+ } else {
+ // if not in map, add tuple and return null
+ new HashMapChange<K,V>(this, key, value);
+ return null;
+ }
}
-
+
+ /**
+ * Adds all (key,value) pairs
+ * @param map that gets added
+ * @throws NullPointerException if map is null
+ */
+
public void putAll(Map<K,V> map) {
+ checkNotNull(map);
for (K key:map.keySet()) {
put(key, map.get(key));
}
}
-
+
+ /**
+ * return value for specified key
+ * @param key used to retrieve value
+ * @return value associated with the key, null if map does not contain key
+ */
public V get(K key) {
return map.get(key);
}
- public void remove(K key) {
+ /**
+ * removes key from mapping
+ * @param key to be removed from map
+ * @return value previously associated with key, null if map did not contain key
+ */
+ public V remove(K key) {
// check if map contains key
- if (!map.containsKey(key)) return;
+ if (!map.containsKey(key)) return null;
+ V old = map.get(key);
new HashMapChange<K,V>(this, key);
+ return old;
}
+ /**
+ * test if key is present in mapping
+ * @param key whose presence is tested
+ * @return true if key is present
+ */
public boolean containsKey(K key) {
return map.containsKey(key);
}
+ /**
+ * removes all mappings from the map
+ */
public void clear() {
- // Two-step process to avoid concurrent modification exception
- List<K> keys = new ArrayList<K>(map.keySet());
- for (K key : keys) {
+ for (K key : ImmutableSet.copyOf(map.keySet())) {
remove (key);
}
}
/**
- * (re)intializes the state map from another map
+ * checks if map is empty
+ * @return true if map is empty
+ */
+ public boolean isEmpty() {
+ return map.isEmpty();
+ }
+
+ /**
+ * (re)initializes the state map from another map
+ * @param map used for initialization
*/
public void initFromMap(Map<K,V> initMap) {
// all from initMap get added
putAll(initMap);
// remove those only in current map
- for (K key:Sets.difference(map.keySet(), initMap.keySet())) {
+ for (K key:ImmutableSet.copyOf(Sets.difference(map.keySet(), initMap.keySet()))) {
remove(key);
}
}
/**
- * @return unmodifiable view of map
+ * creates an immutable copy of the map
+ * @return immutable version of the map
*/
- public Map<K,V> viewMap() {
- return Collections.unmodifiableMap(map);
+ public ImmutableMap<K,V> viewMap() {
+ return ImmutableMap.copyOf(map);
}
/**
- * @return unmodifiable view of keyset
+ * creates an immutable copy of the keyset
+ * @return immutable keyset of the map
*/
- public Set<K> viewKeySet() {
- return Collections.unmodifiableSet(map.keySet());
- }
-
- public Collection<V> viewValues() {
- return Collections.unmodifiableCollection(map.values());
+ public ImmutableSet<K> viewKeySet() {
+ return ImmutableSet.copyOf(map.keySet());
}
- public boolean isEmpty() {
- return map.isEmpty();
+ /**
+ * creates an immutable copy of the values
+ * @return immutable list of values
+ */
+ public ImmutableList<V> viewValues() {
+ return ImmutableList.copyOf(map.values());
}
public String getData() {
commit 80ad59a1182f0a841fb6c1ab945b3ebf4412478a
Author: Stefan Frey <ste...@we...>
Date: Thu Jul 19 11:05:49 2012 +0200
changed Change methods from public to default visibility
diff --git a/src/rails/game/state/ArrayListChange.java b/src/rails/game/state/ArrayListChange.java
index 832d387..54fa91f 100644
--- a/src/rails/game/state/ArrayListChange.java
+++ b/src/rails/game/state/ArrayListChange.java
@@ -32,18 +32,15 @@ final class ArrayListChange<E> extends Change {
super.init(state);
}
- @Override
- public void execute() {
+ @Override void execute() {
state.change(object, index, addToList);
}
- @Override
- public void undo() {
+ @Override void undo() {
state.change(object, index, !addToList);
}
- @Override
- public ArrayListState<E> getState() {
+ @Override ArrayListState<E> getState() {
return state;
}
diff --git a/src/rails/game/state/BooleanChange.java b/src/rails/game/state/BooleanChange.java
index 824aeb7..6002069 100644
--- a/src/rails/game/state/BooleanChange.java
+++ b/src/rails/game/state/BooleanChange.java
@@ -17,18 +17,15 @@ final class BooleanChange extends Change {
super.init(state);
}
- @Override
- public void execute() {
+ @Override void execute() {
state.change(newValue);
}
- @Override
- public void undo() {
+ @Override void undo() {
state.change(oldValue);
}
- @Override
- public BooleanState getState() {
+ @Override BooleanState getState() {
return state;
}
diff --git a/src/rails/game/state/GenericStateChange.java b/src/rails/game/state/GenericStateChange.java
index 86289ea..f6e1434 100644
--- a/src/rails/game/state/GenericStateChange.java
+++ b/src/rails/game/state/GenericStateChange.java
@@ -12,18 +12,15 @@ final class GenericStateChange<E> extends Change {
super.init(state);
}
- @Override
- public void execute() {
+ @Override void execute() {
state.change(next);
}
- @Override
- public void undo() {
+ @Override void undo() {
state.change(previous);
}
- @Override
- public GenericState<E> getState() {
+ @Override GenericState<E> getState() {
return state;
}
diff --git a/src/rails/game/state/HashMapChange.java b/src/rails/game/state/HashMapChange.java
index c04edad..933a3c7 100644
--- a/src/rails/game/state/HashMapChange.java
+++ b/src/rails/game/state/HashMapChange.java
@@ -38,18 +38,15 @@ final class HashMapChange<K,V> extends Change {
super.init(state);
}
- @Override
- public void execute() {
+ @Override void execute() {
state.change(key, newValue, remove);
}
- @Override
- public void undo() {
+ @Override void undo() {
state.change(key, oldValue, !existed);
}
- @Override
- public HashMapState<K,V> getState() {
+ @Override HashMapState<K,V> getState() {
return state;
}
diff --git a/src/rails/game/state/HashSetChange.java b/src/rails/game/state/HashSetChange.java
index 7f1c2d5..30f8bcb 100644
--- a/src/rails/game/state/HashSetChange.java
+++ b/src/rails/game/state/HashSetChange.java
@@ -18,18 +18,15 @@ final class HashSetChange<E> extends Change {
super.init(state);
}
- @Override
- public void execute() {
+ @Override void execute() {
state.change(element, addToSet);
}
- @Override
- public void undo() {
+ @Override void undo() {
state.change(element, !addToSet);
}
- @Override
- public HashSetState<E> getState() {
+ @Override HashSetState<E> getState() {
return state;
}
diff --git a/src/rails/game/state/IntegerChange.java b/src/rails/game/state/IntegerChange.java
index b6e55e6..01d3030 100644
--- a/src/rails/game/state/IntegerChange.java
+++ b/src/rails/game/state/IntegerChange.java
@@ -16,18 +16,15 @@ final class IntegerChange extends Change {
super.init(state);
}
- @Override
- public void execute() {
+ @Override void execute() {
state.change(newValue);
}
- @Override
- public void undo() {
+ @Override void undo() {
state.change(oldValue);
}
- @Override
- public IntegerState getState() {
+ @Override IntegerState getState() {
return state;
}
diff --git a/src/rails/game/state/MultimapChange.java b/src/rails/game/state/MultimapChange.java
index 2783a8f..36dcd5e 100644
--- a/src/rails/game/state/MultimapChange.java
+++ b/src/rails/game/state/MultimapChange.java
@@ -14,18 +14,15 @@ final class MultimapChange<K,V> extends Change {
super.init(state);
}
- @Override
- public void execute() {
+ @Override void execute() {
state.change(key, value, addToMap);
}
- @Override
- public void undo() {
+ @Override void undo() {
state.change(key, value, !addToMap);
}
- @Override
- public MultimapState<K,V> getState() {
+ @Override MultimapState<K,V> getState() {
return state;
}
diff --git a/src/rails/game/state/PortfolioChange.java b/src/rails/game/state/PortfolioChange.java
index 5c3e21a..bb8624a 100644
--- a/src/rails/game/state/PortfolioChange.java
+++ b/src/rails/game/state/PortfolioChange.java
@@ -13,24 +13,21 @@ final class PortfolioChange<T extends Ownable<T>> extends Change {
super.init(in);
}
- @Override
- public void execute() {
+ @Override void execute() {
in.change(item, true);
if (out != null) {
out.change(item, false);
}
}
- @Override
- public void undo() {
+ @Override void undo() {
in.change(item, false);
if (out != null) {
out.change(item, true);
}
}
- @Override
- public Portfolio<? super T> getState() {
+ @Override Portfolio<? super T> getState() {
return in;
}
diff --git a/src/rails/game/state/StringChange.java b/src/rails/game/state/StringChange.java
index b1909e9..c327796 100644
--- a/src/rails/game/state/StringChange.java
+++ b/src/rails/game/state/StringChange.java
@@ -18,18 +18,15 @@ final class StringChange extends Change {
super.init(state);
}
- @Override
- public void execute() {
+ @Override void execute() {
state.change(newValue);
}
- @Override
- public void undo() {
+ @Override void undo() {
state.change(oldValue);
}
- @Override
- public StringState getState() {
+ @Override StringState getState() {
return state;
}
diff --git a/src/rails/game/state/WalletChange.java b/src/rails/game/state/WalletChange.java
index 6e3b089..62082ae 100644
--- a/src/rails/game/state/WalletChange.java
+++ b/src/rails/game/state/WalletChange.java
@@ -15,24 +15,21 @@ final class WalletChange<T extends CountableItem> extends Change {
super.init(in);
}
- @Override
- public void execute() {
+ @Override void execute() {
in.change(item, amount);
if (out != null) {
out.change(item, - amount);
}
}
- @Override
- public void undo() {
+ @Override void undo() {
in.change(item, - amount);
if (out != null) {
out.change(item, amount);
}
}
- @Override
- public Wallet<T> getState() {
+ @Override Wallet<T> getState() {
return in;
}
commit 1a7522c88b0effb42bd6bce4dd3d80d7bee83c02
Author: Stefan Frey <ste...@we...>
Date: Thu Jul 19 11:02:40 2012 +0200
added tests for HashSetState
diff --git a/junit/rails/game/state/ArrayListStateTest.java b/junit/rails/game/state/ArrayListStateTest.java
index 0745f7c..fb11df0 100644
--- a/junit/rails/game/state/ArrayListStateTest.java
+++ b/junit/rails/game/state/ArrayListStateTest.java
@@ -44,7 +44,9 @@ public class ArrayListStateTest {
state_default = ArrayListState.create(root, DEFAULT_ID);
state_init = ArrayListState.create(root, INIT_ID, Lists.newArrayList(oneItem));
}
-
+
+ // helper function to check the initial state after undo
+ // includes redo, so after returning the state should be unchanged
private void assertInitialStateAfterUndo() {
stack.closeCurrentChangeSet();
stack.undo();
@@ -168,6 +170,9 @@ public class ArrayListStateTest {
state_init.add(anotherItem);
state_init.clear();
assertTrue(state_init.isEmpty());
+ // check undo and redo
+ assertInitialStateAfterUndo();
+ assertTrue(state_init.isEmpty());
}
@Test
diff --git a/junit/rails/game/state/HashSetStateTest.java b/junit/rails/game/state/HashSetStateTest.java
new file mode 100644
index 0000000..004b147
--- /dev/null
+++ b/junit/rails/game/state/HashSetStateTest.java
@@ -0,0 +1,161 @@
+package rails.game.state;
+
+import static org.fest.assertions.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Iterator;
+
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+
+public class HashSetStateTest {
+
+ private final static String DEFAULT_ID = "Default";
+ private final static String INIT_ID = "Init";
+
+ private final static String ONE_ITEM_ID = "OneItem";
+ private final static String ANOTHER_ITEM_ID = "AnotherItem";
+
+ private Root root;
+ private ChangeStack stack;
+ private HashSetState<Item> state_default;
+ private HashSetState<Item> state_init;
+
+ private Item oneItem;
+ private Item anotherItem;
+
+
+ @Before
+ public void setUp() {
+ root = StateTestUtils.setUpRoot();
+ stack = root.getStateManager().getChangeStack();
+
+ oneItem = AbstractItemImpl.create(root, ONE_ITEM_ID);
+ anotherItem = AbstractItemImpl.create(root, ANOTHER_ITEM_ID);
+
+ state_default = HashSetState.create(root, DEFAULT_ID);
+ state_init = HashSetState.create(root, INIT_ID, Sets.newHashSet(oneItem));
+ }
+
+
+ @Test
+ public void testCreationWithList() {
+ // checks if the set is created with a list, that it only contains non-unique elements
+ HashSetState<Item> state = HashSetState.create(root, null, Lists.newArrayList(oneItem, oneItem));
+ assertThat(state).containsOnly(oneItem);
+ assertThat(state).hasSize(1);
+ }
+
+ // helper function to check the initial state after undo
+ // includes redo, so after returning the state should be unchanged
+ private void assertInitialStateAfterUndo() {
+ stack.closeCurrentChangeSet();
+ stack.undo();
+ assertEquals(state_default.view(), Sets.newHashSet());
+ assertEquals(state_init.view(), Sets.newHashSet(oneItem));
+ stack.redo();
+ }
+
+ private void assertTestAdd() {
+ assertThat(state_default).containsOnly(oneItem);
+ assertThat(state_init).containsOnly(oneItem, anotherItem);
+ }
+
+ @Test
+ public void testAdd() {
+ state_default.add(oneItem);
+ state_init.add(anotherItem);
+ assertTestAdd();
+
+ // check undo
+ assertInitialStateAfterUndo();
+ assertTestAdd();
+ }
+
+ @Test
+ public void testRemove() {
+ // rem |
