Menu
▾
▴
[Rails-commits] Branch 'rails2.0' - 6 commits - junit/rails src/rails
|
From: Stefan F. <ste...@us...> - 2012-07-26 06:06:32
|
junit/rails/game/state/ArrayListMultimapStateTest.java | 89 ++++++
junit/rails/game/state/ArrayListStateTest.java | 12
junit/rails/game/state/BooleanStateTest.java | 16 -
junit/rails/game/state/FormatterTest.java | 60 ----
junit/rails/game/state/GenericStateTest.java | 16 -
junit/rails/game/state/HashMapStateTest.java | 9
junit/rails/game/state/HashMultimapStateTest.java | 185 ++++++++++++++
junit/rails/game/state/HashSetStateTest.java | 9
junit/rails/game/state/IntegerStateTest.java | 14 -
junit/rails/game/state/OwnableItemImpl.java | 16 +
junit/rails/game/state/OwnerImpl.java | 22 +
junit/rails/game/state/PortfolioListTest.java | 114 ++++++++
junit/rails/game/state/PortfolioManagerTest.java | 104 +++++++
junit/rails/game/state/StateTestUtils.java | 22 +
junit/rails/game/state/StringStateTest.java | 22 -
src/rails/game/Bank.java | 17 -
src/rails/game/BankPortfolio.java | 6
src/rails/game/BonusToken.java | 4
src/rails/game/Company.java | 10
src/rails/game/CompanyManager.java | 2
src/rails/game/GameManager.java | 5
src/rails/game/MapHex.java | 9
src/rails/game/OperatingRound.java | 3
src/rails/game/Player.java | 3
src/rails/game/PrivateCompany.java | 28 --
src/rails/game/PublicCertificate.java | 4
src/rails/game/PublicCompany.java | 32 +-
src/rails/game/Round.java | 15 -
src/rails/game/StartItem.java | 10
src/rails/game/StockRound.java | 12
src/rails/game/Stop.java | 6
src/rails/game/Token.java | 2
src/rails/game/Train.java | 5
src/rails/game/TrainManager.java | 11
src/rails/game/TreasuryShareRound.java | 2
src/rails/game/action/BuyBonusToken.java | 2
src/rails/game/action/BuyCertificate.java | 9
src/rails/game/action/BuyPrivate.java | 2
src/rails/game/action/BuyTrain.java | 5
src/rails/game/model/BaseTokensModel.java | 4
src/rails/game/model/CertificatesModel.java | 2
src/rails/game/model/PortfolioModel.java | 7
src/rails/game/model/PrivatesModel.java | 2
src/rails/game/model/TrainsModel.java | 2
src/rails/game/special/ExchangeForShare.java | 2
src/rails/game/special/SpecialProperty.java | 2
src/rails/game/special/SpecialRight.java | 2
src/rails/game/specific/_1835/PrussianFormationRound.java | 2
src/rails/game/specific/_1835/StockRound_1835.java | 2
src/rails/game/specific/_1856/OperatingRound_1856.java | 2
src/rails/game/specific/_1856/PublicCompany_CGR.java | 6
src/rails/game/specific/_1856/StockRound_1856.java | 4
src/rails/game/specific/_1889/OperatingRound_1889.java | 8
src/rails/game/specific/_18EU/GameManager_18EU.java | 3
src/rails/game/specific/_18EU/StockRound_18EU.java | 9
src/rails/game/specific/_18TN/OperatingRound_18TN.java | 2
src/rails/game/state/ArrayListMultimapChange.java | 48 +++
src/rails/game/state/ArrayListMultimapState.java | 18 -
src/rails/game/state/ArrayListState.java | 10
src/rails/game/state/ChangeStack.java | 1
src/rails/game/state/DelayedItem.java | 8
src/rails/game/state/Formatter.java | 23 -
src/rails/game/state/HashMapState.java | 5
src/rails/game/state/HashMultimapChange.java | 37 ++
src/rails/game/state/HashMultimapState.java | 25 +
src/rails/game/state/Manager.java | 6
src/rails/game/state/MultimapChange.java | 37 --
src/rails/game/state/MultimapState.java | 18 -
src/rails/game/state/Observable.java | 3
src/rails/game/state/Ownable.java | 13
src/rails/game/state/OwnableItem.java | 45 ++-
src/rails/game/state/OwnableManager.java | 5
src/rails/game/state/Portfolio.java | 54 ++--
src/rails/game/state/PortfolioChange.java | 2
src/rails/game/state/PortfolioHolder.java | 10
src/rails/game/state/PortfolioList.java | 32 +-
src/rails/game/state/PortfolioManager.java | 81 +++++-
src/rails/game/state/PortfolioMap.java | 23 -
src/rails/game/state/Root.java | 31 +-
src/rails/game/state/StateManager.java | 26 -
src/rails/game/state/UnknownOwner.java | 17 +
src/rails/ui/swing/GameStatus.java | 22 -
src/rails/ui/swing/ORUIManager.java | 2
83 files changed, 1102 insertions(+), 475 deletions(-)
New commits:
commit 428eefc5b1ebcd1f7b33634512b1a671f539f320
Author: Stefan Frey <ste...@we...>
Date: Thu Jul 26 07:31:26 2012 +0200
refined MultiMap states and added tests
diff --git a/junit/rails/game/state/ArrayListMultimapStateTest.java b/junit/rails/game/state/ArrayListMultimapStateTest.java
new file mode 100644
index 0000000..2960dbb
--- /dev/null
+++ b/junit/rails/game/state/ArrayListMultimapStateTest.java
@@ -0,0 +1,89 @@
+package rails.game.state;
+
+import static org.fest.assertions.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class ArrayListMultimapStateTest {
+
+ private final static String STATE_ID = "State";
+ private final static String ITEM_A_ID = "ItemA";
+ private final static String ITEM_B_ID = "ItemB";
+ private final static String ITEM_C_ID = "ItemC";
+
+ private Root root;
+ private ArrayListMultimapState<String, Item> state;
+ private Item itemA, itemB, itemC;
+
+ @Before
+ public void setUp() {
+ root = StateTestUtils.setUpRoot();
+ state = ArrayListMultimapState.create(root, STATE_ID);
+ itemA = OwnableItemImpl.create(root, ITEM_A_ID);
+ itemB = OwnableItemImpl.create(root, ITEM_B_ID);
+ itemC = OwnableItemImpl.create(root, ITEM_C_ID);
+ StateTestUtils.startActionChangeSet(root);
+ }
+
+ @Test
+ public void testPut() {
+ state.put(ITEM_A_ID, itemA);
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemA);
+ state.put(ITEM_A_ID, itemA);
+ assertThat(state.get(ITEM_A_ID)).containsExactly(itemA, itemA);
+ state.put(ITEM_A_ID, itemB);
+ assertThat(state.get(ITEM_A_ID)).containsExactly(itemA, itemA, itemB);
+ // test undo
+ StateTestUtils.closeAndUndo(root);
+ assertTrue(state.isEmpty());
+ // test redo
+ StateTestUtils.redo(root);
+ assertThat(state.get(ITEM_A_ID)).containsExactly(itemA, itemA, itemB);
+ }
+
+ @Test
+ public void testRemove() {
+ // initialize state
+ state.put(ITEM_A_ID, itemA);
+ state.put(ITEM_A_ID, itemB);
+ state.put(ITEM_A_ID, itemA);
+ StateTestUtils.startActionChangeSet(root);
+ assertThat(state.get(ITEM_A_ID)).containsExactly(itemA, itemB, itemA);
+ // remove items
+ state.remove(ITEM_A_ID, itemA);
+ assertThat(state.get(ITEM_A_ID)).containsExactly(itemB, itemA);
+ state.remove(ITEM_A_ID, itemA);
+ assertThat(state.get(ITEM_A_ID)).containsExactly(itemB);
+ // test undo
+ StateTestUtils.closeAndUndo(root);
+ assertThat(state.get(ITEM_A_ID)).containsExactly(itemA, itemB, itemA);
+ // test redo
+ StateTestUtils.redo(root);
+ assertThat(state.get(ITEM_A_ID)).containsExactly(itemB);
+ }
+
+ @Test
+ public void testGet() {
+ state.put(ITEM_A_ID, itemA);
+ state.put(ITEM_A_ID, itemB);
+ state.put(ITEM_C_ID, itemC);
+ assertThat(state.get(ITEM_A_ID)).containsExactly(itemA, itemB);
+ assertThat(state.get(ITEM_C_ID)).containsExactly(itemC);
+ }
+
+ @Test
+ public void testContainsEntry() {
+ state.put(ITEM_A_ID, itemA);
+ state.put(ITEM_C_ID, itemB);
+ assertTrue(state.containsEntry(ITEM_A_ID, itemA));
+ assertTrue(state.containsEntry(ITEM_C_ID, itemB));
+
+ assertFalse(state.containsEntry(ITEM_B_ID, itemA));
+ assertFalse(state.containsEntry(ITEM_A_ID, itemB));
+ assertFalse(state.containsEntry(ITEM_B_ID, itemB));
+ assertFalse(state.containsEntry(ITEM_C_ID, itemC));
+ }
+
+}
diff --git a/junit/rails/game/state/HashMultimapStateTest.java b/junit/rails/game/state/HashMultimapStateTest.java
new file mode 100644
index 0000000..67a91a1
--- /dev/null
+++ b/junit/rails/game/state/HashMultimapStateTest.java
@@ -0,0 +1,185 @@
+package rails.game.state;
+
+import static org.fest.assertions.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+
+public class HashMultimapStateTest {
+
+ private final static String STATE_ID = "State";
+ private final static String ITEM_A_ID = "ItemA";
+ private final static String ITEM_B_ID = "ItemB";
+ private final static String ITEM_C_ID = "ItemC";
+
+ private Root root;
+ private HashMultimapState<String, Item> state;
+ private Item itemA, itemB, itemC;
+ private List<Item> initContents;
+
+ @Before
+ public void setUp() {
+ root = StateTestUtils.setUpRoot();
+ state = HashMultimapState.create(root, STATE_ID);
+ itemA = OwnableItemImpl.create(root, ITEM_A_ID);
+ itemB = OwnableItemImpl.create(root, ITEM_B_ID);
+ itemC = OwnableItemImpl.create(root, ITEM_C_ID);
+ StateTestUtils.startActionChangeSet(root);
+ }
+
+ private void initState() {
+ // initialize state
+ state.put(ITEM_A_ID, itemA);
+ state.put(ITEM_A_ID, itemB);
+ state.put(ITEM_A_ID, itemC);
+ state.put(ITEM_B_ID, itemB);
+ state.put(ITEM_C_ID, itemC);
+ StateTestUtils.startActionChangeSet(root);
+ initContents = Lists.newArrayList(itemA, itemB, itemC, itemB, itemC);
+ }
+
+ @Test
+ public void testPut() {
+ state.put(ITEM_A_ID, itemA);
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemA);
+ assertFalse(state.put(ITEM_A_ID, itemA)); // cannot add identical tuple
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemA);
+ state.put(ITEM_A_ID, itemB);
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemA, itemB);
+ // test undo
+ StateTestUtils.closeAndUndo(root);
+ assertTrue(state.isEmpty());
+ // test redo
+ StateTestUtils.redo(root);
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemA, itemB);
+ }
+
+ @Test
+ public void testRemove() {
+ initState();
+ // remove items
+ state.remove(ITEM_A_ID, itemA);
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemB, itemC);
+ state.remove(ITEM_A_ID, itemC);
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemB);
+ // test undo
+ StateTestUtils.closeAndUndo(root);
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemA, itemB, itemC);
+ // test redo
+ StateTestUtils.redo(root);
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemB);
+ }
+
+ @Test
+ public void testRemoveAll() {
+ initState();
+ Set<Item> removed = state.removeAll(ITEM_A_ID);
+ assertThat(removed).containsOnly(itemA, itemB, itemC);
+ assertThat(state.get(ITEM_A_ID)).isEmpty();
+ // test undo
+ StateTestUtils.closeAndUndo(root);
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemA, itemB, itemC);
+ // test redo
+ StateTestUtils.redo(root);
+ assertThat(state.get(ITEM_A_ID)).isEmpty();
+ }
+
+ @Test
+ public void testGet() {
+ initState();
+ assertThat(state.get(ITEM_A_ID)).containsOnly(itemA, itemB, itemC);
+ assertThat(state.get(ITEM_C_ID)).containsOnly(itemC);
+ }
+
+ @Test
+ public void testContainsEntry() {
+ state.put(ITEM_A_ID, itemA);
+ state.put(ITEM_C_ID, itemB);
+ assertTrue(state.containsEntry(ITEM_A_ID, itemA));
+ assertTrue(state.containsEntry(ITEM_C_ID, itemB));
+
+ assertFalse(state.containsEntry(ITEM_B_ID, itemA));
+ assertFalse(state.containsEntry(ITEM_A_ID, itemB));
+ assertFalse(state.containsEntry(ITEM_B_ID, itemB));
+ assertFalse(state.containsEntry(ITEM_C_ID, itemC));
+ }
+
+ @Test
+ public void testContainsKey() {
+ state.put(ITEM_A_ID, itemA);
+ state.put(ITEM_C_ID, itemB);
+ assertTrue(state.containsKey(ITEM_A_ID));
+ assertFalse(state.containsKey(ITEM_B_ID));
+ assertTrue(state.containsKey(ITEM_C_ID));
+ }
+
+ @Test
+ public void testContainsValue() {
+ state.put(ITEM_A_ID, itemA);
+ state.put(ITEM_C_ID, itemB);
+ assertTrue(state.containsValue(itemA));
+ assertTrue(state.containsValue(itemB));
+ assertFalse(state.containsValue(itemC));
+ }
+
+ @Test
+ public void testSize() {
+ assertEquals(0, state.size());
+ initState();
+ assertEquals(5, state.size());
+ }
+
+ @Test
+ public void testIsEmpty() {
+ assertTrue(state.isEmpty());
+ initState();
+ assertFalse(state.isEmpty());
+ }
+
+ @Test
+ public void testKeySet() {
+ state.put(ITEM_A_ID, itemA);
+ state.put(ITEM_C_ID, itemB);
+ assertThat(state.keySet()).containsOnly(ITEM_A_ID, ITEM_C_ID);
+ }
+
+ @Test
+ public void testValues() {
+ initState();
+ assertThat(state.values()).containsAll(initContents);
+ }
+
+ private void assertTestIterator(Item thirdItem) {
+ // no order is defined, so store them
+ Set<Item> iterated = Sets.newHashSet();
+
+ Iterator<Item> it = state.iterator();
+ while (it.hasNext()) {
+ iterated.add(it.next());
+ }
+ assertThat(iterated).containsAll(initContents);
+ // iterator is an immutable copy, thus not changed by adding a new item
+ state.put(ITEM_C_ID, itemA);
+ assertFalse(it.hasNext());
+ // remove the last added item
+ state.remove(ITEM_C_ID, itemA);
+ }
+
+ @Test
+ public void testIterator() {
+ initState();
+ Item thirdItem = AbstractItemImpl.create(root, "Third");
+ assertTestIterator(thirdItem);
+ }
+
+
+
+}
diff --git a/src/rails/game/state/ArrayListMultimapChange.java b/src/rails/game/state/ArrayListMultimapChange.java
new file mode 100644
index 0000000..5d10ee0
--- /dev/null
+++ b/src/rails/game/state/ArrayListMultimapChange.java
@@ -0,0 +1,48 @@
+package rails.game.state;
+
+final class ArrayListMultimapChange<K,V> extends Change {
+ private final ArrayListMultimapState<K,V> state;
+ private final K key;
+ private final V value;
+ private final int index;
+ private final boolean addToList;
+
+ ArrayListMultimapChange(ArrayListMultimapState<K,V> state, K key, V value, int index) {
+ this.state = state;
+ this.key = key;
+ this.value = value;
+ this.index = index;
+ this.addToList = true;
+ super.init(state);
+ }
+
+ ArrayListMultimapChange(ArrayListMultimapState<K,V> state, K key, int index) {
+ this.state = state;
+ this.key = key;
+ this.value = state.get(key).get(index);
+ this.index = index;
+ this.addToList = false;
+ super.init(state);
+ }
+
+ @Override void execute() {
+ state.change(key, value, index, addToList);
+ }
+
+ @Override void undo() {
+ state.change(key, value, index, !addToList);
+ }
+
+ @Override ArrayListMultimapState<K,V> getState() {
+ return state;
+ }
+
+ @Override
+ public String toString() {
+ if (addToList) {
+ return "Change for " + state + ": Add key = " + key + " with value " + value + " at index " + index;
+ } else {
+ return "Change for " + state + ": Remove object with key = " + key + " at index " + index ;
+ }
+ }
+}
diff --git a/src/rails/game/state/ArrayListMultimapState.java b/src/rails/game/state/ArrayListMultimapState.java
index 8dd69c1..3e3c7aa 100644
--- a/src/rails/game/state/ArrayListMultimapState.java
+++ b/src/rails/game/state/ArrayListMultimapState.java
@@ -4,7 +4,7 @@ import java.util.List;
import com.google.common.collect.ArrayListMultimap;
-public final class ArrayListMultimapState<K,V> extends MultimapState<K,V> {
+public final class ArrayListMultimapState<K,V> extends State {
private final ArrayListMultimap<K,V> map = ArrayListMultimap.create(); ;
@@ -27,7 +27,7 @@ public final class ArrayListMultimapState<K,V> extends MultimapState<K,V> {
*/
public boolean put(K key, V value) {
- |
