ManualTicTacToe: Added initial GameUITest (runGame only; no internal mocking/spying.

Author: Daniel Barclay

src/main/scala/com/us/dsb/explore/algs/ttt/manual/GameState.scala

@@ -18,7 +18,7 @@ object GameState {
 
   def initial(startingPlayer: Player): GameState =
     GameState(Board.initial, None, startingPlayer)
-  def initial: GameState = initial(Player.O)
+  def initial: GameState = initial(Player.X)
 }
 
 /**

src/test/scala/com/us/dsb/explore/algs/ttt/manual/GameUITest.scala

@@ -0,0 +1,95 @@
+package com.us.dsb.explore.algs.ttt.manual
+
+import com.us.dsb.explore.algs.ttt.manual.GameUI.{GameUIResult, UserTextIO}
+import org.scalatest.funspec.AnyFunSpec
+import org.scalatest.matchers.should.Matchers._
+
+
+class GameUITest extends AnyFunSpec {
+
+  class CrudeManualStubIO(inputs: String*) extends UserTextIO {
+
+    private var remainingInputs = inputs.toList
+
+    override def readLine(): String = {
+      val thisInput :: laterInputs = remainingInputs
+      remainingInputs = laterInputs
+      Predef.println(s"readLine(): returning; '''${thisInput}'''")
+      thisInput
+    }
+
+    override def print(lineOrPart: String): Unit = {
+      Predef.println(s"print(String):   not checking; '''${lineOrPart}'''")
+    }
+
+    override def println(fullLine: String): Unit = {
+      Predef.println(s"println(String): not checking; '''${fullLine}'''")
+    }
+
+  }
+
+  private def runStrings(inputs: String*): String =
+    GameUI.runGame(new CrudeManualStubIO(inputs: _*)).text
+  private def runChars(inputChars: String): String =
+    runStrings(inputChars.map("" + _): _*)
+
+
+  describe("runGame:") {
+    describe("'q' should quit (result in message mentioning \"quit\"):") {
+
+      it("'q' as first command") {
+        runStrings("q") should include regex ("(?i)quit")
+      }
+
+    }
+    describe("""X win should report X won; text should:""") {
+      lazy val result = runChars("mdmrmdmrm")  // X--/OX-/-OX
+      it("""mention "win""") {
+        result should include regex "(?i)W[o]n"
+      }
+      it("""mention X""") {
+        result should include ("X")
+      }
+      it("""not mention O (probably)""" ) { // not if "X beat O"
+        result should not include ("O")
+      }
+      it("""be "Player X won" (currently) """) {
+        result should be ("Player X won")
+      }
+    }
+    describe("""O win should report O won; text should:""") {
+      lazy val result = runChars("m rm dlm rm rm dlm")  // XO-/XOX/--O
+      it("""mention win, O, and not X (probably)""") {
+        result should (
+            include regex ("(?i)W[o]n")
+            and include ("O")
+            and not include ("X")
+            )
+      }
+      it("""be "Player O won" (currently) """) {
+        result should be ("Player O won")
+      }
+    }
+    describe("draw should report draw; text should:") {
+      /*
+        (1, 1) - m
+        (2, 1) - dm
+        (1, 2) - urm
+        (2, 2) - dm
+        (3, 1) - dlm
+        (1, 3) - uurrm
+        (2, 3) - dm
+        (3, 3) - dm
+        (3, 2) - lm
+       */
+      lazy val actual = runChars("m" + "dm" + "urm" + "dm" + "dlm" + "uurrm" + "dm" + "dm" + "lm")
+
+      it("""mention "draw""") {
+        actual should include regex "(?i)Draw"
+      }
+      it("""be "Game ended in draw" (currently)""") {
+        actual should be ("Game ended in draw")
+      }
+    }
+  }
+}