trackler 2.2.1.30 → 2.2.1.31

data/tracks/go/exercises/robot-name/.meta/hints.md

@@ -0,0 +1,13 @@
+### Bonus exercise
+
+Once you get `go test` passing, try `go test -tags bonus`.  This uses a *build
+tag* to enable a test that wasn't previously enabled. Build tags control which
+files should be included in the package. You can read more about those at [the
+Go documentation](https://golang.org/pkg/go/build/#hdr-Build_Constraints).
+
+For this exercise it limits `go test` to only build the tests in the
+`robot_name_test.go` file. We can then include the bonus test in the
+`bonus_test.go` file with the tags flag as described above.
+
+To get the bonus test to pass you'll have to ensure a robot's name has not been
+used before.

data/tracks/go/exercises/robot-name/bonus_example.go

@@ -7,6 +7,8 @@ import (
 	"math/rand"
 )
 
+const testVersion = 1
+
 type Robot struct {
 	name string
 }

data/tracks/java/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Sat Sep 09 18:32:27 EDT 2017
+#Fri Jul 07 18:07:45 EDT 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.0.1-bin.zip

data/tracks/java/gradlew

@@ -33,11 +33,11 @@ DEFAULT_JVM_OPTS=""
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
-warn () {
+warn ( ) {
     echo "$*"
 }
 
-die () {
+die ( ) {
     echo
     echo "$*"
     echo
@@ -155,7 +155,7 @@ if $cygwin ; then
 fi
 
 # Escape application args
-save () {
+save ( ) {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }

data/tracks/php/config.json

@@ -566,6 +566,14 @@
       "topics": [
 
       ]
+    },
+    {
+      "uuid": "9dede68f-6b48-4142-88fd-0cf2c9de7207",
+      "slug": "flatten-array",
+      "difficulty": 2,
+      "topics": [
+        "Arrays"
+      ]
     }
   ]
 }

data/tracks/php/exercises/flatten-array/example.php

@@ -0,0 +1,10 @@
+<?php
+
+function flatten($array = [])
+{
+    $return = array();
+    array_walk_recursive($array, function ($x) use (&$return) {
+        return !is_null($x) ? $return[] = $x : [];
+    });
+    return $return;
+}

data/tracks/php/exercises/flatten-array/flatten-array_test.php

@@ -0,0 +1,51 @@
+<?php
+
+require 'flatten-array.php';
+
+class FlattenArrayTest extends PHPUnit\Framework\TestCase
+{
+    public function testWithOutNesting()
+    {
+        $input = [0, 1, 2];
+        $expected = [0, 1, 2];
+        $this->assertEquals($expected, flatten($input));
+    }
+    public function testArrayWithJustIntegersPresent()
+    {
+        $this->markTestSkipped();
+        $input = [1, [2, 3, 4, 5, 6, 7], 8];
+        $expected = [1, 2, 3, 4, 5, 6, 7, 8];
+        $this->assertEquals($expected, flatten($input));
+    }
+
+    public function testFiveLevelNesting()
+    {
+        $this->markTestSkipped();
+        $input = [0, 2, [[2, 3], 8, 100, 4, [[[50]]]], -2];
+        $expected = [0, 2, 2, 3, 8, 100, 4, 50, -2];
+        $this->assertEquals($expected, flatten($input));
+    }
+
+    public function testSixLevelNesting()
+    {
+        $this->markTestSkipped();
+        $input = [1, [2, [[3]], [4, [[5]]], 6, 7], 8];
+        $expected = [1, 2, 3, 4, 5, 6, 7, 8];
+        $this->assertEquals($expected, flatten($input));
+    }
+    public function testSixLevelNestListWithNullValues()
+    {
+        $this->markTestSkipped();
+        $input = [0, 2, [[2, 3], 8, [[100]], null, [[null]]], -2];
+        $expected = [0, 2, 2, 3, 8, 100, -2];
+        $this->assertEquals($expected, flatten($input));
+    }
+
+    public function testAllValuesInNestedListAreNull()
+    {
+        $this->markTestSkipped();
+        $input = [null, [[[null]]], null, null, [[null, null], null], null];
+        $expected = [];
+        $this->assertEquals($expected, flatten($input));
+    }
+}

data/tracks/ruby/exercises/hello-world/GETTING_STARTED.md

@@ -95,8 +95,8 @@ Run the test again.
 
     1) Failure:
     HelloWorldTest#test_no_name [hello_world_test.rb:11]:
-    When given no name, we should greet the world!.
-    Expected: "Hello, world!"
+    When given no name, we should greet the world.
+    Expected: "Hello, World!"
       Actual: nil
 
 Up until now we've been getting errors, this time we get a failure.

data/tracks/scala/exercises/accumulate/src/test/scala/AccumulateTest.scala

@@ -1,5 +1,6 @@
 import org.scalatest.{Matchers, FlatSpec}
 
+/** @version created manually **/
 class AccumulateTest extends FlatSpec with Matchers {
 
   it should "allow empty accumulation" in {

data/tracks/scala/exercises/allergies/example.scala

@@ -3,11 +3,11 @@ import Allergen.Allergen
 object Allergies {
   private lazy val allergenList = Allergen.values
 
-  def isAllergicTo(allergen: Allergen, score: Int): Boolean =
+  def allergicTo(allergen: Allergen, score: Int): Boolean =
     (allergen.id & score) != 0
 
-  def allergies(score: Int): List[Allergen] =
-    allergenList.filter(a => isAllergicTo(a, score)).toList
+  def list(score: Int): List[Allergen] =
+    allergenList.filter(a => allergicTo(a, score)).toList
 }
 
 object Allergen extends Enumeration {

data/tracks/scala/exercises/allergies/src/test/scala/AllergiesTest.scala

@@ -1,69 +1,104 @@
-import org.scalatest.{Matchers, FlatSpec}
+import org.scalatest.{Matchers, FunSuite}
 
-class AllergiesTest extends FlatSpec with Matchers {
-  it should "handle no allergies means not allergic" in {
-    Allergies.isAllergicTo(Allergen.Peanuts, 0) should equal (false)
-    Allergies.isAllergicTo(Allergen.Cats, 0) should equal (false)
-    Allergies.isAllergicTo(Allergen.Strawberries, 0) should equal (false)
+/** @version 1.0.0 */
+class AllergiesTest extends FunSuite with Matchers {
+
+  test("Allergen.Peanuts - no allergies means not allergic") {
+    Allergies.allergicTo(Allergen.Peanuts, 0) should be(false)
+  }
+
+  test("Allergen.Cats - no allergies means not allergic") {
+    pending
+    Allergies.allergicTo(Allergen.Cats, 0) should be(false)
+  }
+
+  test("Allergen.Strawberries - no allergies means not allergic") {
+    pending
+    Allergies.allergicTo(Allergen.Strawberries, 0) should be(false)
+  }
+
+  test("Allergen.Eggs - is allergic to eggs") {
+    pending
+    Allergies.allergicTo(Allergen.Eggs, 1) should be(true)
+  }
+
+  test("Allergen.Eggs - allergic to eggs in addition to other stuff") {
+    pending
+    Allergies.allergicTo(Allergen.Eggs, 5) should be(true)
   }
 
-  it should "handle is allergic to eggs" in {
+  test("Allergen.Shellfish - allergic to eggs in addition to other stuff") {
     pending
-    Allergies.isAllergicTo(Allergen.Eggs, 1) should equal (true)
+    Allergies.allergicTo(Allergen.Shellfish, 5) should be(true)
   }
 
-  it should "handle is allergic to eggs in addition to other stuff" in {
+  test("Allergen.Strawberries - allergic to eggs in addition to other stuff") {
     pending
-    Allergies.isAllergicTo(Allergen.Eggs, 5) should equal (true)
+    Allergies.allergicTo(Allergen.Strawberries, 5) should be(false)
   }
 
-  it should "handle no allergies" in {
+  test("no allergies at all") {
     pending
-    Allergies.allergies(0) should equal (List())
+    Allergies.list(0) should be(List())
   }
 
-  it should "handle allergic to just eggs" in {
+  test("allergic to just eggs") {
     pending
-    Allergies.allergies(1) should equal (List(Allergen.Eggs))
+    Allergies.list(1) should be(List(Allergen.Eggs))
   }
 
-  it should "handle allergic to just peanuts" in {
+  test("allergic to just peanuts") {
     pending
-    Allergies.allergies(2) should equal (List(Allergen.Peanuts))
+    Allergies.list(2) should be(List(Allergen.Peanuts))
   }
 
-  it should "handle allergic to just strawberries" in {
+  test("allergic to just strawberries") {
     pending
-    Allergies.allergies(8) should equal (List(Allergen.Strawberries))
+    Allergies.list(8) should be(List(Allergen.Strawberries))
   }
 
-  it should "handle allergic to eggs and peanuts" in {
+  test("allergic to eggs and peanuts") {
     pending
-    Allergies.allergies(3) should equal (List(Allergen.Eggs, Allergen.Peanuts))
+    Allergies.list(3) should be(List(Allergen.Eggs, Allergen.Peanuts))
   }
 
-  it should "handle allergic to more than eggs but not peanuts" in {
+  test("allergic to more than eggs but not peanuts") {
     pending
-    Allergies.allergies(5) should equal (List(Allergen.Eggs, Allergen.Shellfish))
+    Allergies.list(5) should be(List(Allergen.Eggs, Allergen.Shellfish))
   }
 
-  it should "handle allergic to lots of stuff" in {
+  test("allergic to lots of stuff") {
     pending
-    Allergies.allergies(248) should equal (List(Allergen.Strawberries, Allergen.Tomatoes,
-      Allergen.Chocolate, Allergen.Pollen, Allergen.Cats))
+    Allergies.list(248) should be(
+      List(Allergen.Strawberries,
+           Allergen.Tomatoes,
+           Allergen.Chocolate,
+           Allergen.Pollen,
+           Allergen.Cats))
   }
 
-  it should "handle allergic to everything" in {
+  test("allergic to everything") {
     pending
-    Allergies.allergies(255) should equal (List(Allergen.Eggs, Allergen.Peanuts,
-      Allergen.Shellfish, Allergen.Strawberries, Allergen.Tomatoes,
-      Allergen.Chocolate, Allergen.Pollen, Allergen.Cats))
+    Allergies.list(255) should be(
+      List(Allergen.Eggs,
+           Allergen.Peanuts,
+           Allergen.Shellfish,
+           Allergen.Strawberries,
+           Allergen.Tomatoes,
+           Allergen.Chocolate,
+           Allergen.Pollen,
+           Allergen.Cats))
   }
 
-  it should "ignore non allergen score parts" in {
+  test("ignore non allergen score parts") {
     pending
-    Allergies.allergies(509) should equal (List(Allergen.Eggs,
-      Allergen.Shellfish, Allergen.Strawberries, Allergen.Tomatoes,
-      Allergen.Chocolate, Allergen.Pollen, Allergen.Cats))
+    Allergies.list(509) should be(
+      List(Allergen.Eggs,
+           Allergen.Shellfish,
+           Allergen.Strawberries,
+           Allergen.Tomatoes,
+           Allergen.Chocolate,
+           Allergen.Pollen,
+           Allergen.Cats))
   }
 }

data/tracks/scala/exercises/bank-account/src/test/scala/BankAccountTest.scala

@@ -1,6 +1,7 @@
 import org.scalatest.concurrent.{IntegrationPatience, Conductors}
 import org.scalatest.{Matchers, FunSuite}
 
+/** @version created manually **/
 class BankAccountTest extends FunSuite with Matchers with Conductors with IntegrationPatience {
   test("open account") {
     Bank.openAccount().getBalance should be (Some(0))

data/tracks/scala/exercises/binary-search-tree/src/test/scala/BstTest.scala

@@ -1,5 +1,6 @@
 import org.scalatest.{Matchers, FlatSpec}
 
+/** @version created manually **/
 class BstTest extends FlatSpec with Matchers {
   val bst4 = Bst(4)
 

data/tracks/scala/exercises/connect/example.scala

@@ -55,7 +55,7 @@ case class Connect(lines: List[String]) {
     }
   }
 
-  def result: Option[Color] = {
+  def winner: Option[Color] = {
     if (blackStartCoords.exists(tryConnect(Color.Black, seenCoords, _))) Some(Color.Black)
     else if (whiteStartCoords.exists(tryConnect(Color.White, seenCoords, _))) Some(Color.White)
     else None

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

@@ -1,86 +1,102 @@
 import org.scalatest.{Matchers, FunSuite}
 
+/** @version 1.0.0 */
 class ConnectTest extends FunSuite with Matchers {
+
   // Filter readable board into valid input
   private def mkBoard(lines: List[String]): List[String] =
     lines.map(l => l.filter(!_.isSpaceChar))
 
-  test("empty board") {
-    val lines = List(". . . . ."
-                    ," . . . . ."
-                    ,"  . . . . ."
-                    ,"   . . . . ."
-                    ,"    . . . . .")
-    Connect(mkBoard(lines)).result should be (None)
+  test("an empty board has no winner") {
+    Connect(
+      mkBoard(
+        List(". . . . .",
+             " . . . . .",
+             "  . . . . .",
+             "   . . . . .",
+             "    . . . . ."))).winner should be(None)
+  }
+
+  test("X can win on a 1x1 board") {
+    pending
+    Connect(mkBoard(List("X"))).winner should be(Some(Color.Black))
+  }
+
+  test("O can win on a 1x1 board") {
+    pending
+    Connect(mkBoard(List("O"))).winner should be(Some(Color.White))
   }
 
-  test("black single item board") {
+  test("only edges does not make a winner") {
     pending
-    val lines = List("X")
-    Connect(mkBoard(lines)).result should be (Some(Color.Black))
+    Connect(mkBoard(List("O O O X", " X . . X", "  X . . X", "   X O O O"))).winner should be(
+      None)
   }
 
-  test("white single item board") {
+  test("illegal diagonal does not make a winner") {
     pending
-    val lines = List("O")
-    Connect(mkBoard(lines)).result should be (Some(Color.White))
+    Connect(
+      mkBoard(List("X O . .",
+                   " O X X X",
+                   "  O X O .",
+                   "   . O X .",
+                   "    X X O O"))).winner should be(None)
   }
 
-  test("convoluted path") {
+  test("nobody wins crossing adjacent angles") {
     pending
-    val lines = List(". X X . ."
-                    ," X . X . X"
-                    ,"  . X . X ."
-                    ,"   . X X . ."
-                    ,"    O O O O O")
-    Connect(mkBoard(lines)).result should be (Some(Color.Black))
+    Connect(
+      mkBoard(List("X . . .",
+                   " . X O .",
+                   "  O . X O",
+                   "   . O . X",
+                   "    . . O ."))).winner should be(None)
   }
 
-  test("rectangle - black wins") {
+  test("X wins crossing from left to right") {
     pending
-    val lines = List(". O . ."
-                    ," O X X X"
-                    ,"  O X O ."
-                    ,"   X X O X"
-                    ,"    . O X .")
-    Connect(mkBoard(lines)).result should be (Some(Color.Black))
+    Connect(
+      mkBoard(List(". O . .",
+                   " O X X X",
+                   "  O X O .",
+                   "   X X O X",
+                   "    . O X ."))).winner should be(Some(Color.Black))
   }
 
-  test("rectangle - white wins") {
+  test("O wins crossing from top to bottom") {
     pending
-    val lines = List(". O . ."
-                    ," O X X X"
-                    ,"  O O O ."
-                    ,"   X X O X"
-                    ,"    . O X .")
-    Connect(mkBoard(lines)).result should be (Some(Color.White))
+    Connect(
+      mkBoard(List(". O . .",
+                   " O X X X",
+                   "  O O O .",
+                   "   X X O X",
+                   "    . O X ."))).winner should be(Some(Color.White))
   }
 
-  test("spiral - black wins") {
+  test("X wins using a convoluted path") {
     pending
-    val lines = List("OXXXXXXXX"
-                    ,"OXOOOOOOO"
-                    ,"OXOXXXXXO"
-                    ,"OXOXOOOXO"
-                    ,"OXOXXXOXO"
-                    ,"OXOOOXOXO"
-                    ,"OXXXXXOXO"
-                    ,"OOOOOOOXO"
-                    ,"XXXXXXXXO")
-    Connect(mkBoard(lines)).result should be (Some(Color.Black))
+    Connect(
+      mkBoard(
+        List(". X X . .",
+             " X . X . X",
+             "  . X . X .",
+             "   . X X . .",
+             "    O O O O O"))).winner should be(Some(Color.Black))
   }
 
-  test("spiral - none") {
+  test("X wins using a spiral path") {
     pending
-    val lines = List("OXXXXXXXX"
-                    ,"OXOOOOOOO"
-                    ,"OXOXXXXXO"
-                    ,"OXOXOOOXO"
-                    ,"OXOX.XOXO"
-                    ,"OXOOOXOXO"
-                    ,"OXXXXXOXO"
-                    ,"OOOOOOOXO"
-                    ,"XXXXXXXXO")
-    Connect(mkBoard(lines)).result should be (None)
+    Connect(
+      mkBoard(List(
+        "O X X X X X X X X",
+        " O X O O O O O O O",
+        "  O X O X X X X X O",
+        "   O X O X O O O X O",
+        "    O X O X X X O X O",
+        "     O X O O O X O X O",
+        "      O X X X X X O X O",
+        "       O O O O O O O X O",
+        "        X X X X X X X X O"
+      ))).winner should be(Some(Color.Black))
   }
 }

data/tracks/scala/exercises/dominoes/src/test/scala/DominoesTest.scala

@@ -1,7 +1,36 @@
-import org.scalatest.{FunSuite, Matchers}
+import org.scalatest.{Matchers, FunSuite}
 
+/** @version 2.0.0 */
 class DominoesTest extends FunSuite with Matchers {
 
+  private def check(input: List[(Int, Int)], hasResult: Boolean): Unit = {
+    val result = Dominoes.chain(input)
+    if (hasResult) {
+      checkChain(result getOrElse fail("should have had a chain, but didn't"), input)
+    }
+    else assert(result == None)
+  }
+
+  private def checkChain(result: List[(Int, Int)], input: List[(Int, Int)]): Unit = {
+    def sortDomino(ab: (Int, Int)): (Int, Int) =
+      if (ab._1 > ab._2) ab.swap else ab
+    def consecutivesShouldMatch(dominoes: List[((Int, Int), Int)]): Unit =
+      dominoes.tails foreach {
+        case (a@(_,x), i1)::(b@(y,_), i2)::_ =>
+          assert(x == y, s"dominoes $i1 and $i2 don't match: $a $b")
+        case _ =>
+      }
+    def endsShouldMatch: Unit =
+      if (!result.isEmpty)
+        consecutivesShouldMatch(List((result.last, result.length - 1),
+          (result.head, 0)))
+
+    assert(result.map(sortDomino).sorted == input.map(sortDomino).sorted,
+      "doesn't consist of input dominoes")
+    consecutivesShouldMatch(result.zipWithIndex)
+    endsShouldMatch
+  }
+
   test("empty input = empty output") {
     check(List(), true)
   }
@@ -56,36 +85,8 @@ class DominoesTest extends FunSuite with Matchers {
     check(List((1, 2), (2, 3), (3, 1), (1, 1), (2, 2), (3, 3)), true)
   }
 
-  test("ten elements") {
+  test("nine elements") {
     pending
     check(List((1, 2), (5, 3), (3, 1), (1, 2), (2, 4), (1, 6), (2, 3), (3, 4), (5, 6)), true)
   }
-
-  private def check(input: List[(Int, Int)], hasResult: Boolean): Unit = {
-    val result = Dominoes.chain(input)
-    if (hasResult) {
-      checkChain(result getOrElse fail("should have had a chain, but didn't"), input)
-    }
-    else assert(result == None)
-  }
-
-  private def checkChain(result: List[(Int, Int)], input: List[(Int, Int)]): Unit = {
-    def sortDomino(ab: (Int, Int)): (Int, Int) =
-      if (ab._1 > ab._2) ab.swap else ab
-    def consecutivesShouldMatch(dominoes: List[((Int, Int), Int)]): Unit =
-      dominoes.tails foreach {
-        case (a@(_,x), i1)::(b@(y,_), i2)::_ =>
-          assert(x == y, s"dominoes $i1 and $i2 don't match: $a $b")
-        case _ =>
-      }
-    def endsShouldMatch: Unit =
-      if (!result.isEmpty)
-        consecutivesShouldMatch(List((result.last, result.length - 1),
-                                     (result.head, 0)))
-
-    assert(result.map(sortDomino).sorted == input.map(sortDomino).sorted,
-        "doesn't consist of input dominoes")
-    consecutivesShouldMatch(result.zipWithIndex)
-    endsShouldMatch
-  }
-}
+}

data/tracks/scala/exercises/grade-school/src/test/scala/GradeSchoolTest.scala

@@ -1,5 +1,6 @@
 import org.scalatest._
 
+/** @version created manually **/
 class GradeSchoolTest extends FunSuite with Matchers with OneInstancePerTest {
   val school = new School
 

data/tracks/scala/exercises/lens-person/src/test/scala/LensPersonTest.scala

@@ -2,6 +2,7 @@ import org.scalatest.{FunSuite, Matchers}
 import java.time.LocalDate
 import LensPerson._
 
+/** @version created manually **/
 class LensPersonTest extends FunSuite with Matchers {
   val testPerson =
     Person(

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

@@ -1,5 +1,6 @@
 import org.scalatest.{Matchers, FlatSpec}
 
+/** @version created manually **/
 class DequeTest extends FlatSpec with Matchers {
 
   it should "handle push then pop" in {

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

@@ -1,5 +1,6 @@
 import org.scalatest.{Matchers, FlatSpec}
 
+/** @version created manually **/
 class MatrixTest extends FlatSpec with Matchers {
   it should "extract a row" in {
     Matrix("1 2\n10 20").rows(0) should be (Vector(1, 2))

data/tracks/scala/exercises/parallel-letter-frequency/src/test/scala/FrequencyTest.scala

@@ -1,5 +1,6 @@
 import org.scalatest.{Matchers, FunSuite}
 
+/** @version created manually **/
 class FrequencyTest extends FunSuite with Matchers {
 
   // Poem by Friedrich Schiller. The corresponding music is the European

data/tracks/scala/exercises/protein-translation/src/test/scala/ProteinTranslationTest.scala

@@ -1,5 +1,6 @@
 import org.scalatest.{FunSuite, Matchers}
 
+/** @version created manually **/
 class ProteinTranslationTest extends FunSuite with Matchers {
   test("Identifies methionine codon") {
     ProteinTranslation.translate("AUG") should be(Seq("Methionine"))
@@ -56,4 +57,4 @@ class ProteinTranslationTest extends FunSuite with Matchers {
     pending
     ProteinTranslation.translate("UGGUGUUAUUAAUGGUUU") should be(Seq("Tryptophan", "Cysteine", "Tyrosine"))
   }
-}
+}

data/tracks/scala/exercises/pythagorean-triplet/src/test/scala/PythagoreanTripletTest.scala

@@ -1,5 +1,6 @@
 import org.scalatest.{FunSuite, Matchers}
 
+/** @version created manually **/
 class PythagoreanTripletTest extends FunSuite with Matchers {
   test("isPythagorean") {
     PythagoreanTriplet.isPythagorean((3, 4, 5)) should be (true)

data/tracks/scala/exercises/robot-name/src/test/scala/RobotNameTest.scala

@@ -2,6 +2,7 @@ import org.scalatest._
 
 import collection.mutable
 
+/** @version created manually **/
 class RobotNameSpecs extends FunSpec with Matchers {
   val nameRegex = """[A-Z]{2}\d{3}"""