Menu
▾
▴
rails-commits
|
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(n...
[truncated message content] |
Thanks for helping keep SourceForge clean.
X