Add selection display and visibility toggle logic

src/test/java/seedu/address/commons/util/CopyableInt.java

@@ -0,0 +1,37 @@
+package seedu.address.commons.util;
+
+/**
+ * A utility class that implements the Copyable interface.
+ */
+public class CopyableInt implements Copyable<CopyableInt> {
+    public static final CopyableInt COPYABLE_ZERO = new CopyableInt(0);
+    public static final CopyableInt COPYABLE_ONE = new CopyableInt(1);
+    public static final CopyableInt COPYABLE_TWO = new CopyableInt(2);
+    public static final CopyableInt COPYABLE_THREE = new CopyableInt(3);
+    public static final CopyableInt COPYABLE_FOUR = new CopyableInt(4);
+
+    private final int number;
+
+    public CopyableInt(int number) {
+        this.number = number;
+    }
+
+    /**
+     * Gets the integer that is saved within the instance of CopyableInt.
+     *
+     * @return The saved integer.
+     */
+    public int getNumber() {
+        return number;
+    }
+
+    /**
+     * Creates a duplicate instance of the CopyableInt.
+     *
+     * @return The duplicate instance.
+     */
+    @Override
+    public CopyableInt copy() {
+        return new CopyableInt(number);
+    }
+}

src/test/java/seedu/address/logic/history/HistoryTest.java

@@ -0,0 +1,66 @@
+package seedu.address.logic.history;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static seedu.address.commons.util.CopyableInt.COPYABLE_ONE;
+import static seedu.address.commons.util.CopyableInt.COPYABLE_THREE;
+import static seedu.address.commons.util.CopyableInt.COPYABLE_TWO;
+import static seedu.address.commons.util.CopyableInt.COPYABLE_ZERO;
+
+import org.junit.jupiter.api.Test;
+
+import seedu.address.commons.util.CopyableInt;
+
+public class HistoryTest {
+    private Historyable<CopyableInt> history = new History<>();
+
+    protected HistoryTest() {
+        history.push(COPYABLE_ZERO);
+        history.push(COPYABLE_ONE);
+        history.push(COPYABLE_TWO);
+    }
+
+    @Test
+    void size_success() {
+        assertEquals(3, history.size());
+    }
+
+    @Test
+    void go_validInput_success() {
+        CopyableInt copyableOne = history.go(-1);
+        assertEquals(COPYABLE_ONE.getNumber(), copyableOne.getNumber());
+    }
+
+    @Test
+    void go_tooLargeInput_success() {
+        CopyableInt copyableTwo = history.go(100); // Should return the last pushed item.
+        assertEquals(COPYABLE_TWO.getNumber(), copyableTwo.getNumber());
+    }
+
+    @Test
+    void go_tooSmallInput_success() {
+        CopyableInt copyableZero = history.go(-100); // Should return the first pushed item.
+        assertEquals(COPYABLE_ZERO.getNumber(), copyableZero.getNumber());
+    }
+
+    @Test
+    void push_expected_success() {
+        history.push(COPYABLE_THREE);
+        CopyableInt currentCopyableInt = history.getCurrentState();
+        assertNotEquals(COPYABLE_THREE, currentCopyableInt);
+        assertEquals(COPYABLE_THREE.getNumber(), currentCopyableInt.getNumber());
+    }
+
+    @Test
+    void push_null_throwsNullPointerException() {
+        assertThrows(NullPointerException.class, () -> history.push(null));
+    }
+
+    @Test
+    void pop_success() {
+        CopyableInt poppedCopyableInt = history.pop();
+        assertNotEquals(COPYABLE_TWO, poppedCopyableInt);
+        assertEquals(COPYABLE_TWO.getNumber(), poppedCopyableInt.getNumber());
+    }
+}

src/test/java/seedu/address/logic/history/SnapshotTest.java

@@ -0,0 +1,74 @@
+package seedu.address.logic.history;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+import seedu.address.commons.util.CopyableInt;
+
+public class SnapshotTest {
+    @Test
+    public void constructor_expected_success() {
+        CopyableInt copyableInt = new CopyableInt(0);
+        Snapshot<CopyableInt> snapshot = new Snapshot<>(copyableInt);
+        assertNotEquals(copyableInt, snapshot.getState());
+        assertEquals(copyableInt.getNumber(), snapshot.getState().getNumber());
+    }
+
+    @Test
+    public void getState_expected_success() {
+        int expectedState = 0;
+        CopyableInt copyableInt = new CopyableInt(expectedState);
+        Snapshot<CopyableInt> snapshot = new Snapshot<>(copyableInt);
+        assertEquals(expectedState, snapshot.getState().getNumber());
+    }
+
+    @Test
+    public void getState_null_throwsNullPointerException() {
+        assertThrows(NullPointerException.class, () -> new Snapshot<>(null));
+    }
+
+    @Test
+    public void restore_originalSnapshot_success() {
+        int expectedState = 0;
+        CopyableInt copyableInt = new CopyableInt(expectedState);
+        Snapshot<CopyableInt> snapshot = new Snapshot<>(copyableInt);
+        Snapshot<CopyableInt> restoredSnapshot = snapshot.restore();
+        assertNotEquals(snapshot, restoredSnapshot);
+        assertEquals(expectedState, restoredSnapshot.getState().getNumber());
+    }
+
+    @Test
+    public void restore_editedSnapshot_success() {
+        int originalState = 0;
+        int editedState = 1;
+        CopyableInt originalCopyableInt = new CopyableInt(originalState);
+        CopyableInt editedCopyableInt = new CopyableInt(editedState);
+        Snapshot<CopyableInt> snapshot = new Snapshot<>(originalCopyableInt);
+        Snapshot<CopyableInt> editedSnapshot = snapshot.edit(editedCopyableInt);
+        Snapshot<CopyableInt> restoredSnapshot = editedSnapshot.restore();
+        assertNotEquals(snapshot, restoredSnapshot);
+        assertEquals(originalState, restoredSnapshot.getState().getNumber());
+    }
+
+    @Test
+    public void edit_expected_success() {
+        int originalState = 0;
+        int editedState = 1;
+        CopyableInt originalCopyableInt = new CopyableInt(originalState);
+        CopyableInt editedCopyableInt = new CopyableInt(editedState);
+        Snapshot<CopyableInt> snapshot = new Snapshot<>(originalCopyableInt);
+        Snapshot<CopyableInt> editedSnapshot = snapshot.edit(editedCopyableInt);
+        assertNotEquals(snapshot, editedSnapshot);
+        assertNotEquals(snapshot.getState(), editedSnapshot.getState());
+        assertNotEquals(snapshot.getState().getNumber(), editedSnapshot.getState().getNumber());
+    }
+
+    @Test
+    public void edit_null_throwsNullPointerException() {
+        Snapshot<CopyableInt> snapshot = new Snapshot<>(new CopyableInt(0));
+        assertThrows(NullPointerException.class, () -> snapshot.edit(null));
+    }
+}