trackler 2.0.0.1 → 2.0.0.2

data/tracks/scala/exercises/custom-set/src/test/scala/CustomSetTest.scala

@@ -8,58 +8,68 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("sets with elements are not empty") {
+    pending
     val set = CustomSet.fromList(List(1))
     CustomSet.empty(set) should be (false)
   }
 
   // Contains test cases - Sets can report if they contain an element
   test("nothing is contained in an empty set") {
+    pending
     val set = CustomSet.fromList(List())
     CustomSet.member(set, 1) should be (false)
   }
 
   test("when the element is in the set") {
+    pending
     val set = CustomSet.fromList(List(1, 2, 3))
     CustomSet.member(set, 1) should be (true)
   }
 
   test("when the element is not in the set") {
+    pending
     val set = CustomSet.fromList(List(1, 2, 3))
     CustomSet.member(set, 4) should be (false)
   }
 
   // Subset test cases - A set is a subset if all of its elements are contained in the other set
   test("empty set is a subset of another empty set") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
     CustomSet.isSubsetOf(set1, set2) should be (true)
   }
 
   test("empty set is a subset of non-empty set") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(1))
     CustomSet.isSubsetOf(set1, set2) should be (true)
   }
 
   test("non-empty set is not a subset of empty set") {
+    pending
     val set1 = CustomSet.fromList(List(1))
     val set2 = CustomSet.fromList(List())
     CustomSet.isSubsetOf(set1, set2) should be (false)
   }
 
   test("set is a subset of set with exact same elements") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List(1, 2, 3))
     CustomSet.isSubsetOf(set1, set2) should be (true)
   }
 
   test("set is a subset of larger set with same elements") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List(4, 1, 2, 3))
     CustomSet.isSubsetOf(set1, set2) should be (true)
   }
 
   test("set is not a subset of set that does not contain its elements") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List(4, 1, 3))
     CustomSet.isSubsetOf(set1, set2) should be (false)
@@ -67,30 +77,35 @@ class CustomSetTest extends FunSuite with Matchers {
 
   // Disjoint test cases - Sets are disjoint if they share no elements
   test("the empty set is disjoint with itself") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
     CustomSet.isDisjointFrom(set1, set2) should be (true)
   }
 
   test("empty set is disjoint with non-empty set") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(1))
     CustomSet.isDisjointFrom(set1, set2) should be (true)
   }
 
   test("non-empty set is disjoint with empty set") {
+    pending
     val set1 = CustomSet.fromList(List(1))
     val set2 = CustomSet.fromList(List())
     CustomSet.isDisjointFrom(set1, set2) should be (true)
   }
 
   test("sets are not disjoint if they share an element") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2))
     val set2 = CustomSet.fromList(List(2, 3))
     CustomSet.isDisjointFrom(set1, set2) should be (false)
   }
 
   test("sets are disjoint if they share no elements") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2))
     val set2 = CustomSet.fromList(List(3, 4))
     CustomSet.isDisjointFrom(set1, set2) should be (true)
@@ -98,30 +113,35 @@ class CustomSetTest extends FunSuite with Matchers {
 
   // Equal test cases - Sets with the same elements are equal
   test("empty sets are equal") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
     CustomSet.isEqual(set1, set2) should be (true)
   }
 
   test("empty set is not equal to non-empty set") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(1, 2, 3))
     CustomSet.isEqual(set1, set2) should be (false)
   }
 
   test("non-empty set is not equal to empty set") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List())
     CustomSet.isEqual(set1, set2) should be (false)
   }
 
   test("sets with the same elements are equal") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2))
     val set2 = CustomSet.fromList(List(2, 1))
     CustomSet.isEqual(set1, set2) should be (true)
   }
 
   test("sets with different elements are not equal") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List(1, 2, 4))
     CustomSet.isEqual(set1, set2) should be (false)
@@ -129,18 +149,21 @@ class CustomSetTest extends FunSuite with Matchers {
 
   // Add test cases - Unique elements can be added to a set
   test("add to empty set") {
+    pending
     val set = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List(3))
     CustomSet.isEqual(CustomSet.insert(set, 3 ), expected) should be (true)
   }
 
   test("add to non-empty set") {
+    pending
     val set = CustomSet.fromList(List(1, 2, 4))
     val expected = CustomSet.fromList(List(1, 2, 3, 4))
     CustomSet.isEqual(CustomSet.insert(set, 3 ), expected) should be (true)
   }
 
   test("adding an existing element does not change the set") {
+    pending
     val set = CustomSet.fromList(List(1, 2, 3))
     val expected = CustomSet.fromList(List(1, 2, 3))
     CustomSet.isEqual(CustomSet.insert(set, 3 ), expected) should be (true)
@@ -148,6 +171,7 @@ class CustomSetTest extends FunSuite with Matchers {
 
   // Intersection test cases - Intersect returns a set of all shared elements
   test("intersection of two empty sets is an empty set") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List())
@@ -155,6 +179,7 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("intersection of an empty set and non-empty set is an empty set") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(3, 2, 5))
     val expected = CustomSet.fromList(List())
@@ -162,6 +187,7 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("intersection of a non-empty set and an empty set is an empty set") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2, 3, 4))
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List())
@@ -169,6 +195,7 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("intersection of two sets with no shared elements is an empty set") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2, 3))
     val set2 = CustomSet.fromList(List(4, 5, 6))
     val expected = CustomSet.fromList(List())
@@ -176,6 +203,7 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("intersection of two sets with shared elements is a set of the shared elements") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2, 3, 4))
     val set2 = CustomSet.fromList(List(3, 2, 5))
     val expected = CustomSet.fromList(List(2, 3))
@@ -184,6 +212,7 @@ class CustomSetTest extends FunSuite with Matchers {
 
   // Difference test cases - Difference (or Complement) of a set is a set of all elements that are only in the first set
   test("difference of two empty sets is an empty set") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List())
@@ -191,6 +220,7 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("difference of empty set and non-empty set is an empty set") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(3, 2, 5))
     val expected = CustomSet.fromList(List())
@@ -198,6 +228,7 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("difference of a non-empty set and an empty set is the non-empty set") {
+    pending
     val set1 = CustomSet.fromList(List(1, 2, 3, 4))
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List(1, 2, 3, 4))
@@ -205,6 +236,7 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("difference of two non-empty sets is a set of elements that are only in the first set") {
+    pending
     val set1 = CustomSet.fromList(List(3, 2, 1))
     val set2 = CustomSet.fromList(List(2, 4))
     val expected = CustomSet.fromList(List(1, 3))
@@ -213,6 +245,7 @@ class CustomSetTest extends FunSuite with Matchers {
 
   // Union test cases - Union returns a set of all elements in either set
   test("union of empty sets is an empty set") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List())
@@ -220,6 +253,7 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("union of an empty set and non-empty set is the non-empty set") {
+    pending
     val set1 = CustomSet.fromList(List())
     val set2 = CustomSet.fromList(List(2))
     val expected = CustomSet.fromList(List(2))
@@ -227,6 +261,7 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("union of a non-empty set and empty set is the non-empty set") {
+    pending
     val set1 = CustomSet.fromList(List(1, 3))
     val set2 = CustomSet.fromList(List())
     val expected = CustomSet.fromList(List(1, 3))
@@ -234,6 +269,7 @@ class CustomSetTest extends FunSuite with Matchers {
   }
 
   test("union of non-empty sets contains all unique elements") {
+    pending
     val set1 = CustomSet.fromList(List(1, 3))
     val set2 = CustomSet.fromList(List(2, 3))
     val expected = CustomSet.fromList(List(3, 2, 1))

data/tracks/scala/exercises/difference-of-squares/src/test/scala/squares_test.scala

@@ -7,41 +7,49 @@ class SquaresTest extends FlatSpec with Matchers {
   }
 
   it should "calc sum of squares to 5" in {
+    pending
     val result = Squares().sumOfSquares(5)
     result should equal (55)
   }
 
   it should "calc difference of sums to 5" in {
+    pending
     val result = Squares().difference(5)
     result should equal (170)
   }
 
   it should "calc square of sums to 10" in {
+    pending
     val result = Squares().squareOfSums(10)
     result should equal (3025)
   }
 
   it should "calc sum of squares to 10" in {
+    pending
     val result = Squares().sumOfSquares(10)
     result should equal (385)
   }
 
   it should "calc difference of sums to 10" in {
+    pending
     val result = Squares().difference(10)
     result should equal (2640)
   }
 
   it should "calc square of sums to 100" in {
+    pending
     val result = Squares().squareOfSums(100)
     result should equal (25502500)
   }
 
   it should "calc sum of squares to 100" in {
+    pending
     val result = Squares().sumOfSquares(100)
     result should equal (338350)
   }
 
   it should "calc difference of sums to 100" in {
+    pending
     val result = Squares().difference(100)
     result should equal (25164150)
   }

data/tracks/scala/exercises/forth/src/test/scala/ForthTest.scala

@@ -11,6 +11,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "numbers" should "just get pushed onto the stack" in {
+    pending
     forth.eval("1 2 3 4 5") match {
       case Right(state) => state.toString should equal("1 2 3 4 5")
       case Left(error) => fail("error pushing numbers on stack - " + error)
@@ -18,6 +19,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "non-word characters" should "be handled as separators" in {
+    pending
     // Note the Ogham Space Mark ( ), this is a spacing character.
     // Also note that if Regex is used for your solution then handling
     // Unicode requires and additional flag in the Regex string "(?U)".
@@ -28,6 +30,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "basic arithmetic" should "evaluate" in {
+    pending
     forth.eval("1 2 + 4 -") match {
       case Right(state) => state.toString should equal("-1")
       case Left(error) => fail("error handling basic arithmetic - " + error)
@@ -35,6 +38,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "basic mul/div" should "evaluate" in {
+    pending
     forth.eval("2 4 * 3 /") match {
       case Right(state) => state.toString should equal("2")
       case Left(error) => fail("error handling basic mul/div - " + error)
@@ -42,6 +46,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "division by zero" should "return error" in {
+    pending
     forth.eval("4 2 2 - /") match {
       case Right(state) => fail("division by zero should return error")
       case Left(error) => error should equal(ForthError.DivisionByZero)
@@ -49,6 +54,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "dup" should "dupe the top of the stack" in {
+    pending
     forth.eval("1 DUP") match {
       case Right(state) => state.toString should equal("1 1")
       case Left(error) => fail("error handling dup - " + error)
@@ -61,6 +67,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "dup on empty stack" should "result in error" in {
+    pending
     forth.eval("dup") match {
       case Right(state) => fail("dup on empty stack should return error")
       case Left(error) => error should equal(ForthError.StackUnderflow)
@@ -68,6 +75,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "drop" should "remove an item from the stack" in {
+    pending
     forth.eval("1 2 drop") match {
       case Right(state) => state.toString should equal("1")
       case Left(error) => fail("error handling drop - " + error)
@@ -75,6 +83,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "drop on 1 item stack" should "result in empty" in {
+    pending
     forth.eval("1 drop") match {
       case Right(state) => state.toString should equal("")
       case Left(error) => fail("error handling drop on 1 item stack - " + error)
@@ -82,6 +91,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "drop on empty stack" should "result in error" in {
+    pending
     forth.eval("drop") match {
       case Right(state) => fail("drop on empty stack should return error")
       case Left(error) => error should equal(ForthError.StackUnderflow)
@@ -89,6 +99,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "swap" should "swap the top of the stack" in {
+    pending
     forth.eval("1 2 swap") match {
       case Right(state) => state.toString should equal("2 1")
       case Left(error) => fail("error handling swap - " + error)
@@ -101,6 +112,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "swap on empty" should "result in error" in {
+    pending
     forth.eval("swap") match {
       case Right(state) => fail("swap on empty stack should return error")
       case Left(error) => error should equal(ForthError.StackUnderflow)
@@ -108,6 +120,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "swap on single item stack" should "result in error" in {
+    pending
     forth.eval("1 swap") match {
       case Right(state) => fail("swap on single item stack should return error")
       case Left(error) => error should equal(ForthError.StackUnderflow)
@@ -115,6 +128,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "over" should "dupe second item in stack" in {
+    pending
     forth.eval("1 2 over") match {
       case Right(state) => state.toString should equal("1 2 1")
       case Left(error) => fail("error handling over - " + error)
@@ -127,6 +141,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "over on empty" should "result in error" in {
+    pending
     forth.eval("over") match {
       case Right(state) => fail("over on empty stack should return error")
       case Left(error) => error should equal(ForthError.StackUnderflow)
@@ -134,6 +149,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "over on single item stack" should "result in error" in {
+    pending
     forth.eval("1 over") match {
       case Right(state) => fail("over on single item  stack should return error")
       case Left(error) => error should equal(ForthError.StackUnderflow)
@@ -141,6 +157,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "define a new word and usage" should "result in stack update" in {
+    pending
     forth.eval(": dupe-twice dup dup ;\r 1 dupe-twice") match {
       case Right(state) => state.toString should equal("1 1 1")
       case Left(error) => fail("error handling define new word and use - " + error)
@@ -148,6 +165,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "redefine an existing word and usage" should "result in stack update" in {
+    pending
     forth.eval(": foo dup ;\r: foo dup dup ;\n1 foo") match {
       case Right(state) => state.toString should equal("1 1 1")
       case Left(error) => fail("error handling redefine word and use - " + error)
@@ -155,6 +173,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "define a built in word" should "result in stack update using redefinition" in {
+    pending
     forth.eval(": swap dup ;\r 1 swap") match {
       case Right(state) => state.toString should equal("1 1")
       case Left(error) => fail("error handling redefining built in word and use - " + error)
@@ -162,6 +181,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "defining a word with odd chars" should "update the stack" in {
+    pending
     forth.eval(": €A 220371 ; €A") match {
       case Right(state) => state.toString should equal("220371")
       case Left(error) => fail("error handling word definition with odd chars - " + error)
@@ -169,6 +189,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "defining a number" should "result in an error" in {
+    pending
     forth.eval(": 1 2 ;") match {
       case Right(state) => fail("defining a new word using a number should result in an error")
       case Left(error) => error should equal(ForthError.InvalidWord)
@@ -176,6 +197,7 @@ class ForthTest extends FlatSpec with Matchers with EitherValues {
   }
 
   "calling a non-existent word" should "result in an error" in {
+    pending
     forth.eval("1 foo") match {
       case Right(state) => fail("calling a non-existent word should result in an error")
       case Left(error) => error should equal(ForthError.InvalidWord)

data/tracks/scala/exercises/hexadecimal/src/test/scala/HexadecimalTest.scala

@@ -6,36 +6,44 @@ class HexadecimalTest extends FlatSpec with Matchers {
   }
 
   it should "handle zeros" in {
+    pending
     Hexadecimal.hexToInt("00000000") should equal(0)
   }
 
   it should "handle single digit" in {
+    pending
     Hexadecimal.hexToInt("1") should equal(1)
   }
 
   it should "handle single hex digit" in {
+    pending
     Hexadecimal.hexToInt("c") should equal(12)
   }
 
   it should "handle upper case" in {
+    pending
     Hexadecimal.hexToInt("C") should equal(12)
   }
 
   it should "handle multiple digits" in {
+    pending
     Hexadecimal.hexToInt("10") should equal(16)
   }
 
   it should "handle multiple hex digits" in {
+    pending
     Hexadecimal.hexToInt("AF") should equal(175)
   }
 
   it should "handle complex strings" in {
+    pending
     Hexadecimal.hexToInt("19ace") should equal(105166)
     Hexadecimal.hexToInt("ffffff") should equal(16777215)
     Hexadecimal.hexToInt("ffff00") should equal(16776960)
   }
 
   it should "handle invalid strings" in {
+    pending
     Hexadecimal.hexToInt("carrot") should equal(0)
     Hexadecimal.hexToInt("abczcba") should equal(0)
   }

data/tracks/scala/exercises/kindergarten-garden/src/test/scala/GardenTest.scala

@@ -7,6 +7,7 @@ class GardenTest extends FunSuite with Matchers {
   }
 
   test("alice tests") {
+    pending
     Garden.defaultGarden("RC\nGG").getPlants("Alice") should
       equal(List(Plant.Radishes, Plant.Clover, Plant.Grass, Plant.Grass))
     Garden.defaultGarden("VC\nRC").getPlants("Alice") should
@@ -14,11 +15,13 @@ class GardenTest extends FunSuite with Matchers {
   }
 
   test("small garden") {
+    pending
     Garden.defaultGarden("VVCG\nVVRC").getPlants("Bob") should
       equal(List(Plant.Clover, Plant.Grass, Plant.Radishes, Plant.Clover))
   }
 
   test("medium garden") {
+    pending
     val garden = Garden.defaultGarden("VVCCGG\nVVCCGG")
     garden.getPlants("Bob") should
       equal(List(Plant.Clover, Plant.Clover, Plant.Clover, Plant.Clover))
@@ -27,6 +30,7 @@ class GardenTest extends FunSuite with Matchers {
   }
 
   test("full garden") {
+    pending
     val garden = Garden.defaultGarden("VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV")
     garden.getPlants("Alice") should
       equal(List(Plant.Violets, Plant.Radishes, Plant.Violets, Plant.Radishes))
@@ -53,6 +57,7 @@ class GardenTest extends FunSuite with Matchers {
   }
 
   test("surprise garden") {
+    pending
     val garden = Garden(List("Samantha", "Patricia", "Xander", "Roger"), "VCRRGVRG\nRVGCCGCV")
     garden.getPlants("Patricia") should
       equal(List(Plant.Violets, Plant.Clover, Plant.Radishes, Plant.Violets))

data/tracks/scala/exercises/largest-series-product/src/test/scala/SeriesTest.scala

@@ -10,6 +10,7 @@ class SeriesTest extends FlatSpec with Matchers {
   }
 
   it should "find largestProduct in long strings" in {
+    pending
     Series.largestProduct(6,
       "73167176531330624919225119674426574742355349194934") should equal(Some(23520))
     Series.largestProduct(6,
@@ -17,6 +18,7 @@ class SeriesTest extends FlatSpec with Matchers {
   }
 
   it should "find largestProduct boundary conditions" in {
+    pending
     Series.largestProduct(0, "") should equal(Some(1))
     Series.largestProduct(0, "123") should equal(Some(1))
     Series.largestProduct(1, "") should equal(None)

data/tracks/scala/exercises/linked-list/src/test/scala/DequeTest.scala

@@ -12,6 +12,7 @@ class DequeTest extends FlatSpec with Matchers {
   }
 
   it should "handle push then shift" in {
+    pending
     val deque = Deque[Char]()
     deque.push('a')
     deque.push('b')
@@ -21,6 +22,7 @@ class DequeTest extends FlatSpec with Matchers {
   }
 
   it should "handle unshift then shift" in {
+    pending
     val deque = Deque[Char]()
     deque.unshift('a')
     deque.unshift('b')
@@ -29,6 +31,7 @@ class DequeTest extends FlatSpec with Matchers {
   }
 
   it should "handle unshift then pop" in {
+    pending
     val deque = Deque[Char]()
     deque.unshift('a')
     deque.unshift('b')
@@ -37,6 +40,7 @@ class DequeTest extends FlatSpec with Matchers {
   }
 
   it should "handle complex interaction" in {
+    pending
     val deque = Deque[Int]()
     deque.push(1)
     deque.push(2)

data/tracks/scala/exercises/luhn/src/test/scala/LuhnTest.scala

@@ -8,11 +8,13 @@ class LuhnTest extends FlatSpec with Matchers {
   }
 
   it should "create addends" in {
+    pending
     Luhn(12121).addends should equal(List(1, 4, 1, 4, 1))
     Luhn(8631).addends should equal(List(7, 6, 6, 1))
   }
 
   it should "create checksum" in {
+    pending
     //  NOTE: this differs from the ruby and js, the checksum really should
     //        be mod 10 like we are testing here.
     Luhn(4913).checksum should equal(2)
@@ -20,11 +22,13 @@ class LuhnTest extends FlatSpec with Matchers {
   }
 
   it should "check validity" in {
+    pending
     Luhn(738).isValid should be (false)
     Luhn(8739567).isValid should be (true)
   }
 
   it should "create luhn values" in {
+    pending
     Luhn(123).create should be (1230)
     Luhn(873956).create should be (8739567)
     Luhn(837263756).create should be (8372637564L)

data/tracks/scala/exercises/matrix/src/test/scala/MatrixTest.scala

@@ -7,11 +7,13 @@ class MatrixTest extends FlatSpec with Matchers {
   }
 
   it should "extract a col" in {
+    pending
     Matrix("1 2\n10 20").cols(0) should be (Vector(1, 10))
     Matrix("1 2\n10 20\n100 200").cols(1) should be (Vector(2, 20, 200))
   }
 
   it should "support equality" in {
+    pending
     Matrix("1 2\n10 20") should be (Matrix("1 2\n10 20"))
     Matrix("1 2\n10 20") should not be Matrix("20 10\n100 200")
   }