Menu
▾
▴
[Rails-commits] Branch 'rails2.0' - 5 commits - junit/rails src/rails
|
From: Stefan F. <ste...@us...> - 2012-07-07 06:55:17
|
junit/rails/game/state/AbstractItemImpl.java | 1
junit/rails/game/state/AbstractItemTest.java | 24 +--
junit/rails/game/state/ActionChangeSetTest.java | 5
junit/rails/game/state/BooleanStateTest.java | 61 ++++++++
junit/rails/game/state/ChangeStackTest.java | 38 ++---
junit/rails/game/state/FormatterTest.java | 40 +++++
junit/rails/game/state/GenericStateTest.java | 80 +++++++++++
junit/rails/game/state/ManagerImpl.java | 1
junit/rails/game/state/ManagerTest.java | 39 ++---
junit/rails/game/state/ModelImpl.java | 17 ++
junit/rails/game/state/ObservableTest.java | 166 ++++++++++++++++++++++++
junit/rails/game/state/RootTest.java | 24 +--
junit/rails/game/state/StateImpl.java | 18 ++
junit/rails/game/state/StateTest.java | 54 +++++++
junit/rails/game/state/StateTestUtils.java | 21 +++
src/rails/game/state/BooleanChange.java | 1
src/rails/game/state/BooleanState.java | 11 +
src/rails/game/state/GenericState.java | 14 --
src/rails/game/state/GenericStateChange.java | 14 +-
src/rails/game/state/Observable.java | 12 +
src/rails/game/state/State.java | 9 -
21 files changed, 562 insertions(+), 88 deletions(-)
New commits:
commit 8d420cfb229c5a0883b5cdef9eebb68141612dec
Author: Stefan Frey <ste...@we...>
Date: Fri Jul 6 15:40:46 2012 +0200
added GenericStateTest
diff --git a/junit/rails/game/state/BooleanStateTest.java b/junit/rails/game/state/BooleanStateTest.java
index e5d9f77..1e4b6f5 100644
--- a/junit/rails/game/state/BooleanStateTest.java
+++ b/junit/rails/game/state/BooleanStateTest.java
@@ -38,6 +38,14 @@ public class BooleanStateTest {
}
@Test
+ public void testSetSameIgnored() {
+ state_default.set(false);
+ state_init.set(true);
+ stack.closeCurrentChangeSet();
+ assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(state_default, state_init);
+ }
+
+ @Test
public void testUndoRedo() {
assertFalse(state_default.value());
state_default.set(true);
diff --git a/junit/rails/game/state/GenericStateTest.java b/junit/rails/game/state/GenericStateTest.java
new file mode 100644
index 0000000..c25424c
--- /dev/null
+++ b/junit/rails/game/state/GenericStateTest.java
@@ -0,0 +1,80 @@
+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 GenericStateTest {
+
+ private final static String STATE_ID = "Generic";
+ private final static String ITEM_ID = "Item";
+ private final static String ANOTHER_ID = "Another";
+
+ private Root root;
+ private ChangeStack stack;
+ private GenericState<Item> state_default;
+ private GenericState<Item> state_init;
+
+ private Item item, another_item;
+
+ @Before
+ public void setUp() {
+ root = StateTestUtils.setUpRoot();
+ stack = root.getStateManager().getChangeStack();
+
+ item = new AbstractItemImpl(root, ITEM_ID);
+ another_item = new AbstractItemImpl(root, ANOTHER_ID);
+
+ state_default = GenericState.create(root, STATE_ID);
+ state_init = GenericState.create(root, null, item);
+ }
+
+ @Test
+ public void testValue() {
+ assertNull(state_default.get());
+ assertSame(item, state_init.get());
+ }
+
+ @Test
+ public void testSet() {
+ state_default.set(item);
+ assertSame(item, state_default.get());
+ state_default.set(null);
+ assertNull(state_default.get());
+ state_init.set(another_item);
+ assertSame(another_item, state_init.get());
+ }
+
+ @Test
+ public void testSetSameIgnored() {
+ state_default.set(null);
+ state_init.set(item);
+ stack.closeCurrentChangeSet();
+ assertThat(stack.getLastClosedChangeSet().getStates()).doesNotContain(state_default, state_init);
+ }
+
+ @Test
+ public void testUndoRedo() {
+ assertNull(state_default.get());
+ assertSame(item, state_init.get());
+
+ state_default.set(item);
+ state_init.set(another_item);
+ assertSame(item, state_default.get());
+ assertSame(another_item, state_init.get());
+
+ stack.closeCurrentChangeSet();
+ assertThat(stack.getLastClosedChangeSet().getStates()).contains(state_default, state_init);
+
+ stack.undo();
+ assertNull(state_default.get());
+ assertSame(item, state_init.get());
+
+ stack.redo();
+ assertSame(item, state_default.get());
+ assertSame(another_item, state_init.get());
+ }
+
+}
diff --git a/src/rails/game/state/BooleanState.java b/src/rails/game/state/BooleanState.java
index f2da4c2..301e1dd 100644
--- a/src/rails/game/state/BooleanState.java
+++ b/src/rails/game/state/BooleanState.java
@@ -31,7 +31,7 @@ public final class BooleanState extends State {
* @param value set state to this value
*/
public void set(boolean value) {
- new BooleanChange(this, value);
+ if (value != this.value) new BooleanChange(this, value);
}
/**
diff --git a/src/rails/game/state/GenericState.java b/src/rails/game/state/GenericState.java
index 6003c40..ea79cb6 100644
--- a/src/rails/game/state/GenericState.java
+++ b/src/rails/game/state/GenericState.java
@@ -29,24 +29,16 @@ public final class GenericState<E> extends State {
return new GenericState<E>(parent, id, object);
}
- private void set(E object, boolean forced) {
+ public void set(E object) {
if (object == null) {
if (this.object != null) {
new GenericStateChange<E>(this, object);
}
- } else if (!object.equals(this.object) || forced) {
- new GenericStateChange<E>(this, object);
+ } else if (object != this.object) {
+ new GenericStateChange<E>(this, object);
}
}
- public void set(E object) {
- set(object, false);
- }
-
- public void setForced(E object) {
- set(object, true);
- }
-
public E get() {
return this.object;
}
diff --git a/src/rails/game/state/GenericStateChange.java b/src/rails/game/state/GenericStateChange.java
index 076f731..d53d925 100644
--- a/src/rails/game/state/GenericStateChange.java
+++ b/src/rails/game/state/GenericStateChange.java
@@ -29,7 +29,19 @@ final class GenericStateChange<E> extends Change {
@Override
public String toString() {
- return "Change State " + state.getId() + " from " + previous.toString() + " to" + next.toString();
+ String from, to;
+ if (previous == null) {
+ from = "<null>";
+ } else {
+ from = previous.toString();
+ }
+ if (next == null) {
+ to = "<null>";
+ } else {
+ to = next.toString();
+ }
+
+ return "Change State " + state + " from " + from + " to " + to ;
}
}
commit f828e621bdcf63659cc8b24516ba5a0e1430974e
Author: Stefan Frey <ste...@we...>
Date: Fri Jul 6 15:12:16 2012 +0200
added BooleanStateTest and StateTestUtils
diff --git a/junit/rails/game/state/BooleanStateTest.java b/junit/rails/game/state/BooleanStateTest.java
new file mode 100644
index 0000000..e5d9f77
--- /dev/null
+++ b/junit/rails/game/state/BooleanStateTest.java
@@ -0,0 +1,53 @@
+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 BooleanStateTest {
+
+ private final static String STATE_ID = "Boolean";
+
+ private Root root;
+ private ChangeStack stack;
+ private BooleanState state_default;
+ private BooleanState state_init;
+
+ @Before
+ public void setUp() {
+ root = StateTestUtils.setUpRoot();
+ state_default = BooleanState.create(root, STATE_ID);
+ state_init = BooleanState.create(root, null, true);
+ stack = root.getStateManager().getChangeStack();
+ }
+
+ @Test
+ public void testValue() {
+ assertFalse(state_default.value());
+ assertTrue(state_init.value());
+ }
+
+ @Test
+ public void testSet() {
+ state_default.set(true);
+ assertTrue(state_default.value());
+ state_init.set(false);
+ assertFalse(state_init.value());
+ }
+
+ @Test
+ public void testUndoRedo() {
+ assertFalse(state_default.value());
+ state_default.set(true);
+ assertTrue(state_default.value());
+ stack.closeCurrentChangeSet();
+ assertThat(stack.getLastClosedChangeSet().getStates()).contains(state_default);
+ stack.undo();
+ assertFalse(state_default.value());
+ stack.redo();
+ assertTrue(state_default.value());
+ }
+
+}
diff --git a/junit/rails/game/state/StateTestUtils.java b/junit/rails/game/state/StateTestUtils.java
new file mode 100644
index 0000000..1d1d50e
--- /dev/null
+++ b/junit/rails/game/state/StateTestUtils.java
@@ -0,0 +1,21 @@
+package rails.game.state;
+
+import org.mockito.Mock;
+
+import rails.game.Player;
+import rails.game.action.PossibleAction;
+
+/**
+ * Common Utilities for State Testing
+ */
+class StateTestUtils {
+ @Mock static Player player;
+ @Mock static PossibleAction action;
+
+ public static Root setUpRoot() {
+ Root root = Root.create();
+ // avoid initial changeSet as it is not undoable
+ root.getStateManager().getChangeStack().startActionChangeSet(player, action);
+ return root;
+ }
+}
diff --git a/src/rails/game/state/BooleanChange.java b/src/rails/game/state/BooleanChange.java
index 6246fd0..75aa2bc 100644
--- a/src/rails/game/state/BooleanChange.java
+++ b/src/rails/game/state/BooleanChange.java
@@ -2,7 +2,6 @@ package rails.game.state;
/**
* Change associated with BooleanState
- * @author freystef
*/
final class BooleanChange extends Change {
diff --git a/src/rails/game/state/BooleanState.java b/src/rails/game/state/BooleanState.java
index 2c35526..f2da4c2 100644
--- a/src/rails/game/state/BooleanState.java
+++ b/src/rails/game/state/BooleanState.java
@@ -2,8 +2,6 @@ package rails.game.state;
/**
* A stateful version of a boolean variable
- *
- * @author Erik Vos, Stefan Frey (V2.0)
*/
public final class BooleanState extends State {
@@ -22,16 +20,23 @@ public final class BooleanState extends State {
}
/**
+ * Creates a BooleanState with defined initial value
* @param value initial value
*/
public static BooleanState create(Item parent, String id, Boolean value){
return new BooleanState(parent, id, value);
}
+ /**
+ * @param value set state to this value
+ */
public void set(boolean value) {
new BooleanChange(this, value);
}
+ /**
+ * @return current value of state variable
+ */
public boolean value() {
return value;
}
commit a190b541b3264233275b92644cbfb99025c47827
Author: Stefan Frey <ste...@we...>
Date: Fri Jul 6 13:21:29 2012 +0200
added StateTest and required Impl test classes
diff --git a/junit/rails/game/state/FormatterTest.java b/junit/rails/game/state/FormatterTest.java
new file mode 100644
index 0000000..626f0be
--- /dev/null
+++ b/junit/rails/game/state/FormatterTest.java
@@ -0,0 +1,40 @@
+package rails.game.state;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class FormatterTest {
+
+ // This formatter doubles the text of the state
+ private class FormatterImpl implements Formatter<State> {
+ public String formatValue(State state) {
+ return state.toString() + state.toString();
+ }
+ }
+
+ private final static String STATE_ID = "State";
+ private final static String STATE_TEXT = "Test";
+
+ private Root root;
+ private State state;
+ private Formatter<State> formatter;
+
+ @Before
+ public void setUp() {
+ root = Root.create();
+ state = new StateImpl(root, STATE_ID, STATE_TEXT);
+ formatter = new FormatterImpl();
+ }
+
+ @Test
+ public void testFormatValue() {
+ assertEquals(STATE_TEXT, state.getText());
+ state.setFormatter(formatter);
+ assertEquals(STATE_TEXT + STATE_TEXT, state.getText());
+ state.setFormatter(null);
+ assertEquals(STATE_TEXT, state.getText());
+ }
+
+}
diff --git a/junit/rails/game/state/ModelImpl.java b/junit/rails/game/state/ModelImpl.java
new file mode 100644
index 0000000..e029de0
--- /dev/null
+++ b/junit/rails/game/state/ModelImpl.java
@@ -0,0 +1,17 @@
+package rails.game.state;
+
+//An implementation only for testing
+class ModelImpl extends Model {
+
+ private final String text;
+
+ ModelImpl(Item parent, String id, String text) {
+ super(parent, id);
+ this.text = text;
+ }
+
+ @Override
+ public String toString() {
+ return text;
+ }
+}
diff --git a/junit/rails/game/state/StateImpl.java b/junit/rails/game/state/StateImpl.java
new file mode 100644
index 0000000..4f4f160
--- /dev/null
+++ b/junit/rails/game/state/StateImpl.java
@@ -0,0 +1,18 @@
+package rails.game.state;
+
+// An implementation only for testing
+class StateImpl extends State {
+
+ private final String text;
+
+ StateImpl(Item parent, String id, String text) {
+ super(parent, id);
+ this.text = text;
+ }
+
+ @Override
+ public String toString() {
+ return text;
+ }
+
+}
diff --git a/junit/rails/game/state/StateTest.java b/junit/rails/game/state/StateTest.java
new file mode 100644
index 0000000..61bffab
--- /dev/null
+++ b/junit/rails/game/state/StateTest.java
@@ -0,0 +1,54 @@
+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 StateTest {
+
+ private final static String STATE_ID = "State";
+ private final static String MODEL_ID = "Model";
+ private final static String STATE_TEXT = "Test";
+
+ private Root root;
+ private State state;
+ private State state_model;
+ private State state_wo_id;
+ private Model model;
+
+ @Before
+ public void setUp() {
+ root = Root.create();
+ state = new StateImpl(root, STATE_ID, null);
+ model = new ModelImpl(root, MODEL_ID, null);
+ state_model = new StateImpl(model, STATE_ID, null);
+ state_wo_id = new StateImpl(model, null, STATE_TEXT);
+ }
+
+ @Test
+ public void testState() {
+ // check that model is linked by state_model
+ assertThat(state_model.getModels()).contains(model);
+ // but for the standard model only after explicit link
+ assertThat(state.getModels()).doesNotContain(model);
+ state.addModel(model);
+ assertThat(state.getModels()).contains(model);
+
+ // state_wo_id does not have any link
+ try {
+ state_wo_id.getModels();
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalStateException.class);
+ }
+
+ }
+
+ @Test
+ public void testGetText() {
+ assertNull(state.getText());
+ assertEquals(STATE_TEXT, state_wo_id.getText());
+ }
+
+}
diff --git a/src/rails/game/state/State.java b/src/rails/game/state/State.java
index fc2ef79..59a95c0 100644
--- a/src/rails/game/state/State.java
+++ b/src/rails/game/state/State.java
@@ -20,13 +20,14 @@ public abstract class State extends Observable {
protected State(Item parent, String id) {
super(parent, id);
- // check if parent is a model and add as dependent model
- if (parent instanceof Model) {
- addModel((Model)parent);
- }
+
// register if observable state
if (id != null) {
+ // check if parent is a model and add as dependent model
+ if (parent instanceof Model) {
+ addModel((Model)parent);
+ }
// check if there is a StateManager available
checkState(getContext().getRoot().getStateManager() != null, "Root of state has no StateManager attached");
// if so => register state there
commit 08ffe071434691403dc840e50859997bbd32c5ac
Author: Stefan Frey <ste...@we...>
Date: Fri Jul 6 10:57:07 2012 +0200
fixed wronger ordering of expected and actual arguments in existing tests
diff --git a/junit/rails/game/state/AbstractItemTest.java b/junit/rails/game/state/AbstractItemTest.java
index 19c994e..ec38434 100644
--- a/junit/rails/game/state/AbstractItemTest.java
+++ b/junit/rails/game/state/AbstractItemTest.java
@@ -26,38 +26,38 @@ public class AbstractItemTest {
@Test
public void testGetId() {
- assertEquals(item.getId(), ITEM_ID);
- assertEquals(anotherItem.getId(), ANOTHER_ID);
+ assertEquals(ITEM_ID, item.getId());
+ assertEquals(ANOTHER_ID, anotherItem.getId());
}
@Test
public void testGetParent() {
- assertSame(item.getParent(), manager);
- assertSame(anotherItem.getParent(), item);
+ assertSame(manager, item.getParent());
+ assertSame(item, anotherItem.getParent());
}
@Test
public void testGetContext() {
- assertSame(item.getContext(), manager);
- assertSame(anotherItem.getContext(), manager);
+ assertSame(manager, item.getContext());
+ assertSame(manager, anotherItem.getContext());
}
@Test
public void testGetRoot() {
- assertSame(item.getRoot(), root);
- assertSame(anotherItem.getRoot(), root);
+ assertSame(root, item.getRoot());
+ assertSame(root, anotherItem.getRoot());
}
@Test
public void testGetURI() {
- assertEquals(item.getURI(), ITEM_ID);
- assertEquals(anotherItem.getURI(), ITEM_ID + Item.SEP + ANOTHER_ID);
+ assertEquals(ITEM_ID, item.getURI());
+ assertEquals(ITEM_ID + Item.SEP + ANOTHER_ID, anotherItem.getURI());
}
@Test
public void testGetFullURI() {
- assertEquals(item.getFullURI(), Item.SEP + MANAGER_ID + Item.SEP + ITEM_ID);
- assertEquals(anotherItem.getFullURI(), Item.SEP + MANAGER_ID+ Item.SEP + ITEM_ID + Item.SEP + ANOTHER_ID);
+ assertEquals(Item.SEP + MANAGER_ID + Item.SEP + ITEM_ID, item.getFullURI());
+ assertEquals(Item.SEP + MANAGER_ID+ Item.SEP + ITEM_ID + Item.SEP + ANOTHER_ID, anotherItem.getFullURI());
}
}
diff --git a/junit/rails/game/state/ActionChangeSetTest.java b/junit/rails/game/state/ActionChangeSetTest.java
index 8062dba..dd388ec 100644
--- a/junit/rails/game/state/ActionChangeSetTest.java
+++ b/junit/rails/game/state/ActionChangeSetTest.java
@@ -42,12 +42,12 @@ public class ActionChangeSetTest {
@Test
public void testGetPlayer() {
- assertSame(changeSet.getPlayer(), player);
+ assertSame(player, changeSet.getPlayer());
}
@Test
public void testGetAction() {
- assertSame(changeSet.getAction(), action);
+ assertSame(action, changeSet.getAction());
}
@Test
@@ -79,5 +79,4 @@ public class ActionChangeSetTest {
assertTrue(state.value());
}
-
}
diff --git a/junit/rails/game/state/ChangeStackTest.java b/junit/rails/game/state/ChangeStackTest.java
index d1d04ef..3b24122 100644
--- a/junit/rails/game/state/ChangeStackTest.java
+++ b/junit/rails/game/state/ChangeStackTest.java
@@ -43,16 +43,16 @@ public class ChangeStackTest {
@Test
public void testGetCurrentChangeSet() {
- assertSame(changeStack.getCurrentChangeSet(), action_3);
+ assertSame(action_3, changeStack.getCurrentChangeSet());
// on the stack there are auto_1, action_1, auto_2, action_2
- assertEquals(changeStack.sizeUndoStack(), 4);
+ assertEquals(4, changeStack.sizeUndoStack());
}
@Test
public void testCloseCurrentChangeSet() {
changeStack.closeCurrentChangeSet();
assertTrue(action_3.isClosed());
- assertSame(changeStack.getLastClosedChangeSet(), action_3);
+ assertSame(action_3, changeStack.getLastClosedChangeSet());
// and now action_3 is added
assertEquals(changeStack.sizeUndoStack(), 5);
}
@@ -62,26 +62,26 @@ public class ChangeStackTest {
assertFalse(state.value());
// undo action 3
assertTrue(changeStack.undo());
- assertEquals(changeStack.sizeUndoStack(), 4);
- assertSame(changeStack.getLastClosedChangeSet(), action_2);
+ assertEquals(4, changeStack.sizeUndoStack());
+ assertSame(action_2, changeStack.getLastClosedChangeSet());
assertThat(changeStack.getCurrentChangeSet()).isInstanceOf(AutoChangeSet.class);
assertFalse(state.value());
// undo action 2
assertTrue(changeStack.undo());
- assertEquals(changeStack.sizeUndoStack(), 3);
- assertSame(changeStack.getLastClosedChangeSet(), auto_2);
+ assertEquals(3, changeStack.sizeUndoStack());
+ assertSame(auto_2, changeStack.getLastClosedChangeSet());
assertThat(changeStack.getCurrentChangeSet()).isInstanceOf(AutoChangeSet.class);
assertTrue(state.value());
// undo auto_2 and action 1
assertTrue(changeStack.undo());
- assertEquals(changeStack.sizeUndoStack(), 1);
- assertSame(changeStack.getLastClosedChangeSet(), auto_1);
+ assertEquals(1, changeStack.sizeUndoStack());
+ assertSame(auto_1, changeStack.getLastClosedChangeSet());
assertThat(changeStack.getCurrentChangeSet()).isInstanceOf(AutoChangeSet.class);
assertFalse(state.value());
// undo should not do anything now
assertFalse(changeStack.undo());
- assertEquals(changeStack.sizeUndoStack(), 1);
- assertSame(changeStack.getLastClosedChangeSet(), auto_1);
+ assertEquals(1, changeStack.sizeUndoStack());
+ assertSame(auto_1, changeStack.getLastClosedChangeSet());
assertThat(changeStack.getCurrentChangeSet()).isInstanceOf(AutoChangeSet.class);
assertFalse(state.value());
}
@@ -95,26 +95,26 @@ public class ChangeStackTest {
// the state unitl now was checked in testUndo
// now redo action_1 and auto_2
assertTrue(changeStack.redo());
- assertEquals(changeStack.sizeUndoStack(), 3);
- assertSame(changeStack.getLastClosedChangeSet(), auto_2);
+ assertEquals(3, changeStack.sizeUndoStack());
+ assertSame(auto_2, changeStack.getLastClosedChangeSet());
assertThat(changeStack.getCurrentChangeSet()).isInstanceOf(AutoChangeSet.class);
assertTrue(state.value());
// redo action_2
assertTrue(changeStack.redo());
- assertEquals(changeStack.sizeUndoStack(), 4);
- assertSame(changeStack.getLastClosedChangeSet(), action_2);
+ assertEquals(4, changeStack.sizeUndoStack());
+ assertSame(action_2, changeStack.getLastClosedChangeSet());
assertThat(changeStack.getCurrentChangeSet()).isInstanceOf(AutoChangeSet.class);
assertFalse(state.value());
// redo action_3
assertTrue(changeStack.redo());
- assertEquals(changeStack.sizeUndoStack(), 5);
- assertSame(changeStack.getLastClosedChangeSet(), action_3);
+ assertEquals(5, changeStack.sizeUndoStack());
+ assertSame(action_3, changeStack.getLastClosedChangeSet());
assertThat(changeStack.getCurrentChangeSet()).isInstanceOf(AutoChangeSet.class);
assertFalse(state.value());
// then it should do anything
assertFalse(changeStack.redo());
- assertEquals(changeStack.sizeUndoStack(), 5);
- assertSame(changeStack.getLastClosedChangeSet(), action_3);
+ assertEquals(5, changeStack.sizeUndoStack());
+ assertSame(action_3, changeStack.getLastClosedChangeSet());
assertThat(changeStack.getCurrentChangeSet()).isInstanceOf(AutoChangeSet.class);
assertFalse(state.value());
}
diff --git a/junit/rails/game/state/ManagerTest.java b/junit/rails/game/state/ManagerTest.java
index 0400718..95fd0c7 100644
--- a/junit/rails/game/state/ManagerTest.java
+++ b/junit/rails/game/state/ManagerTest.java
@@ -27,60 +27,59 @@ public class ManagerTest {
@Test
public void testGetId() {
- assertEquals(manager.getId(), MANAGER_ID);
- assertEquals(anotherManager.getId(), ANOTHER_MANAGER_ID);
+ assertEquals(MANAGER_ID, manager.getId());
+ assertEquals(ANOTHER_MANAGER_ID, anotherManager.getId());
}
@Test
public void testGetParent() {
- assertSame(manager.getParent(), item);
- assertSame(anotherManager.getParent(), manager);
+ assertSame(item, manager.getParent());
+ assertSame(manager, anotherManager.getParent());
}
@Test
public void testGetContext() {
- System.out.println();
- assertSame(manager.getContext(), root);
- assertSame(anotherManager.getContext(), manager);
+ assertSame(root, manager.getContext());
+ assertSame(manager, anotherManager.getContext());
}
@Test
public void testGetURI() {
- assertEquals(manager.getURI(), ITEM_ID + Item.SEP + MANAGER_ID);
- assertEquals(anotherManager.getURI(), ANOTHER_MANAGER_ID);
+ assertEquals(ITEM_ID + Item.SEP + MANAGER_ID, manager.getURI());
+ assertEquals(ANOTHER_MANAGER_ID, anotherManager.getURI());
}
@Test
public void testGetFullURI() {
- assertEquals(manager.getFullURI(), Item.SEP + ITEM_ID + Item.SEP + MANAGER_ID);
- assertEquals(anotherManager.getFullURI(), Item.SEP + ITEM_ID + Item.SEP + MANAGER_ID + Item.SEP + ANOTHER_MANAGER_ID);
+ assertEquals(Item.SEP + ITEM_ID + Item.SEP + MANAGER_ID, manager.getFullURI());
+ assertEquals(Item.SEP + ITEM_ID + Item.SEP + MANAGER_ID + Item.SEP + ANOTHER_MANAGER_ID, anotherManager.getFullURI());
}
@Test
public void testLocate() {
// anotherItem is local
- assertSame(manager.locate(anotherItem.getURI()), anotherItem);
- assertSame(manager.locate(anotherItem.getFullURI()), anotherItem);
+ assertSame(anotherItem, manager.locate(anotherItem.getURI()));
+ assertSame(anotherItem, manager.locate(anotherItem.getFullURI()));
// item is not local
assertNull(manager.locate(item.getURI()));
- assertSame(manager.locate(item.getFullURI()), item);
+ assertSame(item, manager.locate(item.getFullURI()));
// manager is not local in itself, but in root
assertNull(manager.locate(manager.getURI()));
- assertSame(root.locate(manager.getURI()), manager);
- assertSame(manager.locate(manager.getFullURI()), manager);
+ assertSame(manager, root.locate(manager.getURI()));
+ assertSame(manager, manager.locate(manager.getFullURI()));
// anotherManager is not local in itself, but in manager
assertNull(anotherManager.locate(anotherManager.getURI()));
- assertSame(manager.locate(anotherManager.getURI()), anotherManager);
- assertSame(anotherManager.locate(anotherManager.getFullURI()), anotherManager);
+ assertSame(anotherManager, manager.locate(anotherManager.getURI()));
+ assertSame(anotherManager, anotherManager.locate(anotherManager.getFullURI()));
}
@Test
public void testGetRoot() {
- assertSame(manager.getRoot(), root);
- assertSame(anotherManager.getRoot(), root);
+ assertSame(root, manager.getRoot());
+ assertSame(root, anotherManager.getRoot());
}
}
diff --git a/junit/rails/game/state/RootTest.java b/junit/rails/game/state/RootTest.java
index c98adfd..2f686c9 100644
--- a/junit/rails/game/state/RootTest.java
+++ b/junit/rails/game/state/RootTest.java
@@ -37,43 +37,43 @@ public class RootTest {
@Test
public void testGetId() {
- assertEquals(root.getId(), Root.ID);
+ assertEquals(Root.ID, root.getId());
}
@Test
public void testGetContext() {
- assertSame(root.getContext(), root);
+ assertSame(root, root.getContext());
}
@Test
public void testGetRoot() {
- assertSame(root.getRoot(), root);
+ assertSame(root, root.getRoot());
}
@Test
public void testGetURI() {
- assertSame(root.getURI(), Root.ID);
+ assertSame(Root.ID, root.getURI());
}
@Test
public void testGetFullURI() {
- assertSame(root.getFullURI(), Root.ID);
+ assertSame(Root.ID, root.getFullURI());
}
@Test
public void testLocate() {
// item is local
- assertSame(root.locate(item.getURI()), item);
- assertSame(root.locate(item.getFullURI()), item);
+ assertSame(item, root.locate(item.getURI()));
+ assertSame(item, root.locate(item.getFullURI()));
// manager is local
- assertSame(root.locate(manager.getURI()), manager);
- assertSame(root.locate(manager.getFullURI()), manager);
+ assertSame(manager, root.locate(manager.getURI()));
+ assertSame(manager, root.locate(manager.getFullURI()));
// anotherItem is not local
assertNull(root.locate(anotherItem.getURI()));
assertSame(root.locate(anotherItem.getFullURI()), anotherItem);
// root is local in root
- assertSame(root.locate(root.getURI()), root);
- assertSame(root.locate(root.getFullURI()), root);
+ assertSame(root, root.locate(root.getURI()));
+ assertSame(root, root.locate(root.getFullURI()));
// and if item is removed it is not found anymore
root.removeItem(item);
assertNull(root.locate(item.getURI()));
@@ -88,7 +88,7 @@ public class RootTest {
public void testAddItemSuccess() {
root.removeItem(item);
root.addItem(item);
- assertSame(root.locate(item.getFullURI()), item);
+ assertSame(item, root.locate(item.getFullURI()));
}
public void testRemoveItemSuccess() {
commit f324c698103cbc65d49fceecaf0b468d350e2d2e
Author: Stefan Frey <ste...@we...>
Date: Fri Jul 6 10:41:17 2012 +0200
added ObservableTest
diff --git a/junit/rails/game/state/AbstractItemImpl.java b/junit/rails/game/state/AbstractItemImpl.java
index 3aec737..5249e89 100644
--- a/junit/rails/game/state/AbstractItemImpl.java
+++ b/junit/rails/game/state/AbstractItemImpl.java
@@ -1,5 +1,6 @@
package rails.game.state;
+// Implementation for Testing only
class AbstractItemImpl extends AbstractItem {
AbstractItemImpl(Item parent, String id) {
super(parent, id);
diff --git a/junit/rails/game/state/ManagerImpl.java b/junit/rails/game/state/ManagerImpl.java
index a6fdf00..477fb3f 100644
--- a/junit/rails/game/state/ManagerImpl.java
+++ b/junit/rails/game/state/ManagerImpl.java
@@ -1,5 +1,6 @@
package rails.game.state;
+// Implementation for Testing only
class ManagerImpl extends Manager {
ManagerImpl(Item parent, String id) {
super(parent, id);
diff --git a/junit/rails/game/state/ObservableTest.java b/junit/rails/game/state/ObservableTest.java
new file mode 100644
index 0000000..2e2000b
--- /dev/null
+++ b/junit/rails/game/state/ObservableTest.java
@@ -0,0 +1,166 @@
+package rails.game.state;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+import static org.fest.assertions.api.Assertions.assertThat;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ObservableTest {
+
+ // Implementation for Testing only
+ private class ObservableImpl extends Observable {
+ ObservableImpl(Item parent, String id) {
+ super(parent, id);
+ }
+
+ @Override
+ public String getText() {
+ return null;
+ }
+ }
+
+ private final static String MANAGER_ID = "Manager";
+ private final static String ITEM_ID = "Item";
+ private final static String OBS_ID = "Observable";
+
+ private Root root;
+ private Manager manager;
+ private Item item;
+ private Observable observable, unobservable;
+ @Mock private Observer observer;
+ @Mock private Model model;
+
+ @Before
+ public void setUp() {
+ root = Root.create();
+ manager = new ManagerImpl(root, MANAGER_ID);
+ item = new AbstractItemImpl(manager, ITEM_ID);
+ observable = new ObservableImpl(item, OBS_ID);
+ unobservable = new ObservableImpl(root, null);
+ }
+
+
+ @Test
+ public void testObservers() {
+ // add observer and test if contained
+ observable.addObserver(observer);
+ assertThat(observable.getObservers()).contains(observer);
+
+ // remove observer and test if not contained
+ assertTrue(observable.removeObserver(observer));
+ assertThat(observable.getObservers()).doesNotContain(observer);
+
+ // remove observer not contained anymore
+ assertFalse(observable.removeObserver(observer));
+
+ // Check failing on unobservable
+ try {
+ unobservable.addObserver(observer);
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalStateException.class);
+ }
+ try {
+ unobservable.removeObserver(observer);
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalStateException.class);
+ }
+ try {
+ unobservable.getObservers();
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalStateException.class);
+ }
+ }
+
+ @Test
+ public void testModels() {
+ // add observer and test if contained
+ observable.addModel(model);
+ assertThat(observable.getModels()).contains(model);
+
+ // check update
+ observable.updateModels();
+ verify(model).update();
+
+ // remove Model and test if not contained
+ assertTrue(observable.removeModel(model));
+ assertThat(observable.getModels()).doesNotContain(model);
+ observable.updateModels();
+ // still only called once(!)
+ verify(model).update();
+
+ // remove Model not contained anymore
+ assertFalse(observable.removeModel(model));
+
+ // Check failing on unobservable
+ try {
+ unobservable.addModel(model);
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalStateException.class);
+ }
+ try {
+ unobservable.removeModel(model);
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalStateException.class);
+ }
+ try {
+ unobservable.getModels();
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalStateException.class);
+ }
+
+ }
+
+ @Test
+ public void testGetId() {
+ assertEquals(OBS_ID, observable.getId());
+ assertEquals(null, unobservable.getId());
+ }
+
+ @Test
+ public void testGetParent() {
+ assertSame(item, observable.getParent());
+ assertSame(root, unobservable.getParent());
+ }
+
+ @Test
+ public void testGetContext() {
+ assertSame(manager, observable.getContext());
+ assertSame(root, unobservable.getContext());
+ }
+
+ @Test
+ public void testGetRoot() {
+ assertSame(root, observable.getRoot());
+ assertSame(root, unobservable.getRoot());
+ }
+
+ @Test
+ public void testGetURI() {
+ assertEquals(ITEM_ID + Item.SEP + OBS_ID, observable.getURI());
+ assertSame(observable, observable.getContext().locate(observable.getURI()));
+ try {
+ unobservable.getURI();
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalStateException.class);
+ }
+ }
+
+ @Test
+ public void testGetFullURI() {
+ assertEquals(Item.SEP + MANAGER_ID + Item.SEP + ITEM_ID + Item.SEP + OBS_ID, observable.getFullURI());
+ assertSame(observable, observable.getContext().locate(observable.getURI()));
+ assertSame(observable, observable.getRoot().locate(observable.getFullURI()));
+ try {
+ unobservable.getFullURI();
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalStateException.class);
+ }
+ }
+
+}
diff --git a/src/rails/game/state/Observable.java b/src/rails/game/state/Observable.java
index 3272391..0ac1ffb 100644
--- a/src/rails/game/state/Observable.java
+++ b/src/rails/game/state/Observable.java
@@ -33,7 +33,13 @@ public abstract class Observable implements Item {
// defined standard fields
this.parent = parent;
this.id = id;
- context = parent.getContext();
+
+ if (parent instanceof Context) {
+ context = (Context)parent;
+ } else {
+ // recursive definition
+ context = parent.getContext();
+ }
// if id is null this is an "unobservable" observable
if (id == null) {
@@ -42,6 +48,8 @@ public abstract class Observable implements Item {
} else {
observers = HashSetState.create(this, null);
models = HashSetState.create(this, null);
+ // add item to context if it has an id
+ context.addItem(this);
}
}
@@ -108,7 +116,7 @@ public abstract class Observable implements Item {
public String getURI() {
checkState(id != null, "Cannot get URI of unobservable object");
- if (parent instanceof Manager) {
+ if (parent instanceof Context) {
return id;
} else {
// recursive definition
|
