trackler 2.0.0.1 → 2.0.0.2

data/tracks/scala/exercises/bowling/src/test/scala/BowlingSuite.scala

@@ -0,0 +1,237 @@
+import org.scalatest.{FunSuite, Matchers}
+
+class BowlingSuite extends FunSuite with Matchers {
+  // returns the final score of a bowling game
+  test("should be able to score a game with all zeros") {
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 0)
+      case Left(_) => fail("should be able to score a game with all zeros")
+    }
+  }
+
+  test("should be able to score a game with no strikes or spares") {
+    pending
+    val score = List(3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 90)
+      case Left(_) => fail("should be able to score a game with no strikes or spares")
+    }
+  }
+
+  test("a spare followed by zeros is worth ten points") {
+    pending
+    val score = List(6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 10)
+      case Left(_) => fail("a spare followed by zeros is worth ten points")
+    }
+  }
+
+  test("points scored in the roll after a spare are counted twice") {
+    pending
+    val score = List(6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 16)
+      case Left(_) => fail("points scored in the roll after a spare are counted twice")
+    }
+  }
+
+  test("consecutive spares each get a one roll bonus") {
+    pending
+    val score = List(5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 31)
+      case Left(_) => fail("consecutive spares each get a one roll bonus")
+    }
+  }
+
+  test("a spare in the last frame gets a one roll bonus that is counted once") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 17)
+      case Left(_) => fail("a spare in the last frame gets a one roll bonus that is counted once")
+    }
+  }
+
+  test("a strike earns ten points in a frame with a single roll") {
+    pending
+    val score = List(10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 10)
+      case Left(_) => fail("a strike earns ten points in a frame with a single roll")
+    }
+  }
+
+  test("points scored in the two rolls after a strike are counted twice as a bonus") {
+    pending
+    val score = List(10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 26)
+      case Left(_) => fail("points scored in the two rolls after a strike are counted twice as a bonus")
+    }
+  }
+
+  test("consecutive strikes each get the two roll bonus") {
+    pending
+    val score = List(10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 81)
+      case Left(_) => fail("consecutive strikes each get the two roll bonus")
+    }
+  }
+
+  test("a strike in the last frame gets a two roll bonus that is counted once") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 18)
+      case Left(_) => fail("a strike in the last frame gets a two roll bonus that is counted once")
+    }
+  }
+
+  test("rolling a spare with the two roll bonus does not get a bonus roll") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 20)
+      case Left(_) => fail("rolling a spare with the two roll bonus does not get a bonus roll")
+    }
+  }
+
+  test("strikes with the two roll bonus do not get bonus rolls") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 30)
+      case Left(_) => fail("strikes with the two roll bonus do not get bonus rolls")
+    }
+  }
+
+  test("a strike with the one roll bonus after a spare in the last frame does not get a bonus") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 20)
+      case Left(_) => fail("a strike with the one roll bonus after a spare in the last frame does not get a bonus")
+    }
+  }
+
+  test("all strikes is a perfect game") {
+    pending
+    val score = List(10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 300)
+      case Left(_) => fail("all strikes is a perfect game")
+    }
+  }
+
+  test("rolls can not score negative points") {
+    pending
+    val score = List(-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+
+  test("a roll can not score more than 10 points") {
+    pending
+    val score = List(11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+
+  test("two rolls in a frame can not score more than 10 points") {
+    pending
+    val score = List(5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+
+  test("two bonus rolls after a strike in the last frame can not score more than 10 points") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+
+  test("two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(n) => assert(n == 26)
+      case Left(_) => fail("two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike")
+    }
+  }
+
+  test("the second bonus rolls after a strike in the last frame can not be a strike if the first one is not a strike") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6, 10).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+
+  test("an unstarted game can not be scored") {
+    pending
+    val score = List().foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+
+  test("an incomplete game can not be scored") {
+    pending
+    val score = List(0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+
+  test("a game with more than ten frames can not be scored") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+
+  test("bonus rolls for a strike in the last frame must be rolled before score can be calculated") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+
+  test("both bonus rolls for a strike in the last frame must be rolled before score can be calculated") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+
+  test("bonus roll for a spare in the last frame must be rolled before score can be calculated") {
+    pending
+    val score = List(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3).foldLeft(Bowling())((acc, roll) => acc.roll(roll)).score()
+    score match {
+      case Right(_) => fail("Unexpected score returned. Failure expected")
+      case Left(_) =>
+    }
+  }
+}

data/tracks/scala/exercises/clock/src/test/scala/ClockTest.scala

@@ -7,204 +7,254 @@ class ClockTest extends FlatSpec with Matchers {
   }
 
   it should "construct from minutes" in {
+    pending
     Clock(3).toString should be ("00:03")
   }
 
   it should "implement equals" in {
+    pending
     Clock(15, 37) should be (Clock(15, 37))
     Clock(15, 37) should not be Clock(15, 36)
   }
 
   it should "support wraparound" in {
+    pending
     Clock(24, 0) should be (Clock(0, 0))
     Clock(25, 0) should be (Clock(1, 0))
   }
 
   it should "handle hour rolls over continuously" in {
+    pending
     Clock(100, 0) should be (Clock(4, 0))
   }
 
   it should "implement 60 min as the next hour" in {
+    pending
     Clock(1, 60) should be (Clock(2, 0))
   }
 
   it should "construct consistently between constructors" in {
+    pending
     Clock(60) should be (Clock(1, 0))
   }
 
   it should "support rolling over minutes" in {
+    pending
     Clock(0, 160) should be (Clock(2, 40))
   }
 
   it should "handle minutes rolling over consistently" in {
+    pending
     Clock(0, 1723) should be (Clock(4, 43))
   }
 
   it should "support rolling over both hours and minutes" in {
+    pending
     Clock(25, 160) should be (Clock(3, 40))
   }
 
   it should "handle hours and minutes rolling over consistently" in {
+    pending
     Clock(201, 3001) should be (Clock(11, 1))
   }
 
   it should "handle hours and minutes rolling over to midnight" in {
+    pending
     Clock(72, 8640) should be (Clock(0, 0))
   }
 
   it should "handle negative hour" in {
+    pending
     Clock(-1, 15) should be (Clock(23, 15))
   }
 
   it should "handle rolling over negative hour" in {
+    pending
     Clock(-25, 0) should be (Clock(23, 0))
   }
 
   it should "handle negative hours rolling over consistently" in {
+    pending
     Clock(-91, 0) should be (Clock(5, 0))
   }
 
   it should "handle negative minute" in {
+    pending
     Clock(1, -40) should be (Clock(0, 20))
   }
 
   it should "handle rolling over negative minute" in {
+    pending
     Clock(1, -160) should be (Clock(22, 20))
   }
 
   it should "handle negative minutes rolling over consistently" in {
+    pending
     Clock(1, -4820) should be (Clock(16, 40))
   }
 
   it should "handle negative hour and minutes roll over" in {
+    pending
     Clock(-25, -160) should be (Clock(20, 20))
   }
 
   it should "handle negative hour and minutes rolling over consistently" in {
+    pending
     Clock(-121, -5810) should be (Clock(22, 10))
   }
 
   it should "add minutes" in {
+    pending
     Clock(10, 0) + Clock(3) should be (Clock(10, 3))
   }
 
   it should "add no minutes" in {
+    pending
     Clock(6, 41) + Clock(0) should be (Clock(6, 41))
   }
 
   it should "add to next hour" in {
+    pending
     Clock(0, 45) + Clock(40) should be (Clock(1, 25))
   }
 
   it should "add more than one hour" in {
+    pending
     Clock(10, 0) + Clock(61) should be (Clock(11, 1))
   }
 
   it should "add more than two hours with carry" in {
+    pending
     Clock(0, 45) + Clock(160) should be (Clock(3, 25))
   }
 
   it should "add across midnight" in {
+    pending
     Clock(23, 59) + Clock(2) should be (Clock(0, 1))
   }
 
   it should "add more than one day (1500 min == 25 hours)" in {
+    pending
     Clock(5, 32) + Clock(1500) should be (Clock(6, 32))
   }
 
   it should "add more than 2 days" in {
+    pending
     Clock(1, 1) + Clock(3500) should be (Clock(11, 21))
   }
 
   it should "subtract minutes" in {
+    pending
     Clock(10, 3) - Clock(3) should be (Clock(10, 0))
   }
 
   it should "subtract to previous hour" in {
+    pending
     Clock(10, 3) - Clock(30) should be (Clock(9, 33))
   }
 
   it should "subtract more than an hour" in {
+    pending
     Clock(10, 3) - Clock(70) should be (Clock(8, 53))
   }
 
   it should "subtract across midnight" in {
+    pending
     Clock(0, 3) - Clock(4) should be (Clock(23, 59))
   }
 
   it should "subtract more than two hours" in {
+    pending
     Clock(0, 0) - Clock(160) should be (Clock(21, 20))
   }
 
   it should "subtract more than two hours with borrow" in {
+    pending
     Clock(6, 15) - Clock(160) should be (Clock(3, 35))
   }
 
   it should "subtract more than one day (1500 min = 25 hrs)" in {
+    pending
     Clock(5, 32) - Clock(1500) should be (Clock(4, 32))
   }
 
   it should "subtract more than two days" in {
+    pending
     Clock(2, 20) - Clock(3000) should be (Clock(0, 20))
   }
 
   it should "handle equality of clocks with same time" in {
+    pending
     Clock(15, 37) should be (Clock(15, 37))
   }
 
   it should "handle equality of clocks that are one minute apart" in {
+    pending
     Clock(15, 36) should not be (Clock(15, 37))
   }
 
   it should "handle equality of clocks that are one hour apart" in {
+    pending
     Clock(14, 37) should not be (Clock(15, 37))
   }
 
   it should "handle equality of clocks with hour overflow" in {
+    pending
     Clock(10, 37) should be (Clock(34, 37))
   }
 
   it should "handle equality of clocks with hour overflow by several days" in {
+    pending
     Clock(3, 11) should be (Clock(99, 11))
   }
 
   it should "handle equality of clocks with negative hour" in {
+    pending
     Clock(22, 40) should be (Clock(-2, 40))
   }
 
   it should "handle equality of clocks with negative hour that wraps" in {
+    pending
     Clock(17, 3) should be (Clock(-31, 3))
   }
 
   it should "handle equality of clocks with negative hour that wraps multiple times" in {
+    pending
     Clock(13, 49) should be (Clock(-83, 49))
   }
 
   it should "handle equality of clocks with minute overflow" in {
+    pending
     Clock(0, 1) should be (Clock(0, 1441))
   }
 
   it should "handle equality of clocks with minute overflow by several days" in {
+    pending
     Clock(2, 2) should be (Clock(2, 4322))
   }
 
   it should "handle equality of clocks with negative minute" in {
+    pending
     Clock(2, 40) should be (Clock(3, -20))
   }
 
   it should "handle equality of clocks with negative minute that wraps" in {
+    pending
     Clock(4, 10) should be (Clock(5, -1490))
   }
 
   it should "handle equality of clocks with negative minute that wraps mutiple times" in {
+    pending
     Clock(6, 15) should be (Clock(6, -4305))
   }
 
   it should "handle equality of clocks with negative hours and minute" in {
+    pending
     Clock(7, 32) should be (Clock(-12, -268))
   }
 
   it should "handle equality of clocks with negative hours and minute that wrap" in {
+    pending
     Clock(18, 7) should be (Clock(-54, -11513))
   }
 }

data/tracks/scala/exercises/connect/README.md

@@ -0,0 +1,17 @@
+# Connect
+
+Determine a winner.
+
+The Scala exercises assume an SBT project scheme. The exercise solution source should be placed within the exercise directory/src/main/scala. The exercise unit tests can be found within the exercise directory/src/test/scala.
+
+To run the tests simply run the command `sbt test` in the exercise directory.
+
+For more detailed info about the Scala track see the [help page](http://help.exercism.io/getting-started-with-scala.html).
+
+### Note
+
+You may notice that some test cases seem unfair. However, they may be legitimately so. For example, it is common to give young or beginner players an extra n pieces at fixed positions on the board, so mismatched piece counts can occur in an otherwise fully legal game.
+
+In any case, this exercise cares only about determining a winner for a game that can have a variety of parameters, like board length and extra pieces. It is not interested in any other state of the game, such as who moved where, when, or whose turn it is.
+
+So don't be puzzled by those seemingly unfair games.

data/tracks/scala/exercises/connect/src/test/scala/ConnectTest.scala

@@ -15,16 +15,19 @@ class ConnectTest extends FunSuite with Matchers {
   }
 
   test("black single item board") {
+    pending
     val lines = List("X")
     Connect(mkBoard(lines)).result should be (Some(Color.Black))
   }
 
   test("white single item board") {
+    pending
     val lines = List("O")
     Connect(mkBoard(lines)).result should be (Some(Color.White))
   }
 
   test("convoluted path") {
+    pending
     val lines = List(". X X . ."
                     ," X . X . X"
                     ,"  . X . X ."
@@ -34,6 +37,7 @@ class ConnectTest extends FunSuite with Matchers {
   }
 
   test("rectangle - black wins") {
+    pending
     val lines = List(". O . ."
                     ," O X X X"
                     ,"  O X O ."
@@ -43,6 +47,7 @@ class ConnectTest extends FunSuite with Matchers {
   }
 
   test("rectangle - white wins") {
+    pending
     val lines = List(". O . ."
                     ," O X X X"
                     ,"  O O O ."
@@ -52,6 +57,7 @@ class ConnectTest extends FunSuite with Matchers {
   }
 
   test("spiral - black wins") {
+    pending
     val lines = List("OXXXXXXXX"
                     ,"OXOOOOOOO"
                     ,"OXOXXXXXO"
@@ -65,6 +71,7 @@ class ConnectTest extends FunSuite with Matchers {
   }
 
   test("spiral - none") {
+    pending
     val lines = List("OXXXXXXXX"
                     ,"OXOOOOOOO"
                     ,"OXOXXXXXO"

data/tracks/scala/exercises/crypto-square/src/test/scala/{CrytpoSquareTest.scala → CryptoSquareTest.scala}

@@ -6,36 +6,43 @@ class CrytpoSquareTest extends FlatSpec with Matchers {
   }
 
   it should "normalize uppercase to lowercase" in {
+    pending
     CryptoSquare().normalizePlaintext("1, 2, 3 GO!") should equal("123go")
   }
 
 
   it should "calc a square size for a perfect square" in {
+    pending
     CryptoSquare().squareSize("1234") should equal(2)
     CryptoSquare().squareSize("123456789") should equal(3)
   }
 
   it should "calc a square size when not a perfect square" in {
+    pending
     CryptoSquare().squareSize("123456789abc") should equal(4)
     CryptoSquare().squareSize("123456789abcd") should equal(4)
   }
 
   it should "not generate calc error when empty string" in {
+    pending
     CryptoSquare().squareSize("") should equal(0)
   }
 
 
   it should "build plaintext segments - all equal segment lengths" in {
+    pending
     CryptoSquare().plaintextSegments("Never vex thine heart with idle woes.") should
       equal(List("neverv", "exthin", "eheart", "withid", "lewoes"))
   }
 
   it should "build plaintext segments - last segment short" in {
+    pending
     CryptoSquare().plaintextSegments("ZOMG! ZOMBIES!!!") should
       equal(List("zomg", "zomb", "ies"))
   }
 
   it should "build cipher text" in {
+    pending
     CryptoSquare().ciphertext("Time is an illusion. Lunchtime doubly so.") should
       equal("tasneyinicdsmiohooelntuillibsuuml")
     CryptoSquare().ciphertext("We all know interspecies romance is weird.") should
@@ -43,6 +50,7 @@ class CrytpoSquareTest extends FlatSpec with Matchers {
   }
 
   it should "build normalized cipher text" in {
+    pending
     CryptoSquare().normalizedCiphertext("Madness, and then illumination.") should
       equal("msemo aanin dnin ndla etlt shui")
     CryptoSquare().normalizedCiphertext("If man was meant to stay on the ground " +
@@ -51,6 +59,7 @@ class CrytpoSquareTest extends FlatSpec with Matchers {
   }
 
   it should "not error on blank strings" in {
+    pending
     CryptoSquare().ciphertext("") should
       equal("")
     CryptoSquare().ciphertext("    ") should