More stack tests

2 files changed, 134 insertions, 34 deletions

diff --git a/src/test/java/bjc/TestUtils.java b/src/test/java/bjc/TestUtils.java
index a8cbf43..c325877 100644
--- a/src/test/java/bjc/TestUtils.java
+++ b/src/test/java/bjc/TestUtils.java
@@ -130,4 +130,19 @@ public class TestUtils {
 			assertEquals(exp, act);
 		}
 	}
+
+	/**
+	 * Assert a stack has the given contents.
+	 *
+	 * @param <T>
+	 * 	The type of items in the stack.
+	 *
+	 * @param src
+	 * 	The stack to inspect.
+	 * @param exps
+	 * 	The values that are expected.
+	 */
+	public static <T> void assertStackEquals(bjc.esodata.Stack<T> src, T... exps) {
+		assertArrayEquals(exps, src.toArray());
+	}
 }
diff --git a/src/test/java/bjc/esodata/StackTest.java b/src/test/java/bjc/esodata/StackTest.java
index 568e6ea..8603a8f 100644
--- a/src/test/java/bjc/esodata/StackTest.java
+++ b/src/test/java/bjc/esodata/StackTest.java
@@ -92,61 +92,146 @@ public class StackTest {
 
 		st.drop();
 
-		// stack should be [a, b, c]
-
-		assertEquals("c", st.top());
-		assertEquals(3, st.size());
+		// assertStackEquals goes from [top] -> [bottom]
+		assertStackEquals(st, "c", "b", "a");
 
 		st.drop(2);
 
-		// stack should be [a]
-
-		assertEquals("a", st.top());
-		assertEquals(1, st.size());
+		assertStackEquals(st, "a");
 
 		st.pushAll("b", "c", "d");
 
 		st.nip();
 		st.nip();
 
-		// stack should be [a, d]
-		assertEquals("d", st.top());
-		assertEquals(2, st.size());
-
-		st.pop();
+		assertStackEquals(st, "d", "a");
 
-		assertEquals("a", st.top());
-		assertEquals(1, st.size());
+		st.drop();
 
-		st.multidup(1, 1);
+		st.dup();
 
-		// stack should be [a, a]
-		assertEquals("a", st.top());
-		assertEquals(2, st.size());
+		assertStackEquals(st, "a", "a");
 
 		st.pushAll("b", "c");
 
 		st.multidup(3, 1);
 
-		// stack should be [a, a, b, c, a, b, c]
-		assertEquals("c", st.top());
-		assertEquals(7, st.size());
+		assertStackEquals(st, "c", "b", "a", "c", "b", "a", "a");
 
-		st.pop();
-		assertEquals("b", st.pop());
-		assertEquals("a", st.pop());
-		assertEquals("c", st.top());
+		st.drop(3);
 
-		// stack should be [a, a, b, c]
+		assertStackEquals(st, "c", "b", "a", "a");
 
-		st.dup();
-		assertEquals("c", st.top());
-		assertEquals(5, st.size());
+		st.over();
 
-		// stack should be [a, a, b, c, c]
-		assertEquals("c", st.pop());
-		assertEquals(4, st.size());
+		assertStackEquals(st, "b", "c", "b", "a", "a");
+
+		st.drop(2);
+
+		assertStackEquals(st, "b", "a", "a");
+
+		st.multiover(2, 2);
+
+		assertStackEquals(st, "a", "a", "a", "a", "b", "a", "a");
+
+		st.drop(6);
+		
+		assertStackEquals(st, "a");
+
+		st.push("b");
+		st.push("c");
+
+		assertStackEquals(st, "c", "b", "a");
+
+		st.pick();
+
+		assertStackEquals(st, "a", "c", "b", "a");
+
+		st.swap();
+
+		assertStackEquals(st, "c", "a", "b", "a");
+
+		st.deepdup();
+
+		assertStackEquals(st, "c", "a", "a", "b", "a");
+
+		st.swap();
+		st.deepswap();
+
+		assertStackEquals(st, "a", "a", "c", "b", "a");
+
+		st.rot();
+
+		assertStackEquals(st, "c", "a", "a", "b", "a");
+
+		st.invrot();
+
+		assertStackEquals(st, "a", "a", "c", "b", "a");
+	}
+
+	@Test
+	public void testDataComb() {
+		Stack<Integer> stk = new SimpleStack<>();
+
+		stk.pushAll(2, 3, 4);
+
+		assertStackEquals(stk, 4, 3, 2);
+
+		stk.dip((st) -> {
+			int x = stk.pop();
+			int y = stk.pop();
+
+			stk.push(x + y);
+		});
+
+		assertStackEquals(stk, 4, 5);
+
+		stk.dip(2, (st) -> {
+			stk.push(6);
+		});
+
+		assertStackEquals(stk, 4, 5, 6);
+
+		stk.keep((st) -> {
+			int v = st.pop();
+
+			st.push(v + 1);
+		});
+
+		assertStackEquals(stk, 4, 5, 5, 6);
+
+		stk.multicleave(2, (st) -> {
+			int x = st.pop();
+			int y = st.pop();
+
+			st.push(x + y);
+		}, (st) -> {
+			int x = st.pop();
+			int y = st.pop();
+
+			st.push(y - x);
+		});
+
+		assertStackEquals(stk, 1, 9, 5, 6);
+
+		stk.spread((st) -> {
+			int x = st.pop();
+			int y = st.pop();
+
+			st.push(x + y);
+		}, (st) -> {
+			int y = st.pop();
+
+			st.push(y + 1);
+		});
+
+		assertStackEquals(stk, 10, 6, 6);
+
+		stk.apply(2, (st) -> {
+			int lhs = st.pop();
+			st.push(lhs - st.pop());
+		});
 
-		// stack should be [a, a, b, c]
+		assertStackEquals(stk, 2);
 	}
 }