trackler 2.2.1.36 → 2.2.1.37

data/tracks/scala/exercises/nucleotide-count/src/test/scala/NucleotideCountTest.scala

@@ -1,74 +1,34 @@
-import org.scalatest._
+import org.scalatest.{Matchers, FunSuite}
 
-class NucleotideCountSpecs extends FlatSpec with Matchers {
-  behavior of "count"
+/** @version 1.0.0 */
+class NucleotideCountTest extends FunSuite with Matchers {
 
-  it should "have no adenine for an empty dna string" in {
-    new DNA("").count('A') should be (Right(0))
-  }
-
-  it should "count cytosine for a repetitive sequence" in {
-    pending
-    new DNA("CCCCC").count('C') should be (Right(5))
-  }
-
-  it should "count only thymine for a mixed dna string" in {
-    pending
-    new DNA("GGGGGTAACCCGG").count('T') should be (Right(1))
-  }
-
-  it should "validate nucleotides" in {
-    pending
-    new DNA("GACT").count('X') should be (Left("invalid nucleotide 'X'"))
-  }
-
-  it should "validate dna" in {
-    pending
-    new DNA("GACYT").count('G') should be (Left("invalid nucleotide 'Y'"))
-  }
-
-  behavior of "nucleotideCounts"
 
-  it should "have no nucleotides" in {
-    pending
-    val expected = Right(Map('A' -> 0, 'T' -> 0, 'C' -> 0, 'G' -> 0))
-    new DNA("").nucleotideCounts should be (expected)
+  test("empty strand") {
+    new DNA("").nucleotideCounts should be (Right(Map('A' -> 0,
+      'C' -> 0,
+      'G' -> 0,
+      'T' -> 0)))
   }
 
-  it should "have only guanine" in {
+  test("strand with repeated nucleotide") {
     pending
-    val expected = Right(Map('A' -> 0, 'T' -> 0, 'C' -> 0, 'G' -> 8))
-    new DNA("GGGGGGGG").nucleotideCounts should be (expected)
+    new DNA("GGGGGGG").nucleotideCounts should be (Right(Map('A' -> 0,
+      'C' -> 0,
+      'G' -> 7,
+      'T' -> 0)))
   }
 
-  it should "count a nucleotide only once" in {
+  test("strand with multiple nucleotides") {
     pending
-    val dna = new DNA("CGATTGGG")
-    val counts = dna.nucleotideCounts.right.get
-    counts('T')
-    counts('T') should be (2)
+    new DNA("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC").nucleotideCounts should be (Right(Map('A' -> 20,
+      'C' -> 12,
+      'G' -> 17,
+      'T' -> 21)))
   }
 
-  it should "not change counts after counting adenine" in {
+  test("strand with invalid nucleotides") {
     pending
-    val dna = new DNA("GATTACA")
-    val counts = dna.nucleotideCounts.right.get
-    counts('A')
-    val expected = Right(Map('A' -> 3, 'T' -> 2, 'C' -> 1, 'G' -> 1))
-    dna.nucleotideCounts should be (expected)
+    new DNA("AGXXACT").nucleotideCounts.isLeft should be (true)
   }
-
-  it should "count all nucleotides" in {
-    pending
-    val s = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC"
-    val dna = new DNA(s)
-    val expected = Right(Map('A' -> 20, 'T' -> 21, 'G' -> 17, 'C' -> 12))
-    dna.nucleotideCounts should be (expected)
-  }
-
-  it should "validate dna" in {
-    pending
-    new DNA("GACYT").nucleotideCounts should be (Left("invalid nucleotide 'Y'"))
-  }
-}
-
+}

data/tracks/scala/exercises/palindrome-products/example.scala

@@ -1,12 +1,15 @@
 
 case class PalindromeProducts(minFactor: Int, maxFactor: Int) {
 
-  lazy val (smallest: (Int, Set[(Int, Int)]),
-            largest: (Int, Set[(Int, Int)])) = {
+  lazy val (smallest: Option[(Int, Set[(Int, Int)])],
+            largest: Option[(Int, Set[(Int, Int)])]) = {
     val palindromes = for (a <- Range(minFactor, maxFactor + 1);
-         b <- Range(a, maxFactor + 1) if isPalindrome(a * b)) yield (a * b, (a, b))
+                           b <- Range(a, maxFactor + 1) if isPalindrome(a * b)) yield (a * b, (a, b))
     val mapped = palindromes.groupBy(_._1).map{case(k, v) => (k, v.map(_._2).toSet)}
-    (mapped.minBy(_._1), mapped.maxBy(_._1))
+    if (mapped.isEmpty)
+      (None, None)
+    else
+      (Some(mapped.minBy(_._1)), Some(mapped.maxBy(_._1)))
   }
 
   private def isPalindrome(i: Int) = i.toString == i.toString.reverse

data/tracks/scala/exercises/palindrome-products/src/test/scala/PalindromeProductsTest.scala

@@ -1,59 +1,79 @@
-import org.scalatest.{Matchers, FlatSpec}
+import org.scalatest.{Matchers, FunSuite}
 
-class PalindromeProductsTest extends FlatSpec with Matchers {
+/** @version 1.0.0 */
+class PalindromeProductsTest extends FunSuite with Matchers {
 
-  it should "find smallest palindrome from a single digit factors" in {
-    val (value, factors) = PalindromeProducts(1, 9).smallest
-    value should be (1)
-    factors should be (Set((1, 1)))
+  // PalindromeProducts largest call is expecting a return type of
+  // Option[(Int, Set[(Int, Int)])] - None is expected for error cases.
+  // Some is expected for valid cases. The first element of the tuple
+  // is the largest palindrome product value. The second element of the
+  // tuple is the list of factors.
+  // PalindromeProducts smallest call is expecting a return type of
+  // Option[(Int, Set[(Int, Int)])] - None is expected for error cases.
+  // Some is expected for valid cases. The first element of the tuple
+  // is the smallest palindrome product value. The second element of the
+  // tuple is the list of factors.
+
+  test("finds the smallest palindrome from single digit factors") {
+    PalindromeProducts(1, 9).smallest should be(Some((1, Set((1, 1)))))
+  }
+
+  test("finds the largest palindrome from single digit factors") {
+    pending
+    PalindromeProducts(1, 9).largest should be(Some((9, Set((1, 9), (3, 3)))))
+  }
+
+  test("find the smallest palindrome from double digit factors") {
+    pending
+    PalindromeProducts(10, 99).smallest should be(Some((121, Set((11, 11)))))
+  }
+
+  test("find the largest palindrome from double digit factors") {
+    pending
+    PalindromeProducts(10, 99).largest should be(Some((9009, Set((91, 99)))))
+  }
+
+  test("find smallest palindrome from triple digit factors") {
+    pending
+    PalindromeProducts(100, 999).smallest should be(
+      Some((10201, Set((101, 101)))))
   }
 
-  it should "find largest palindrome from a single digit factors" in {
+  test("find the largest palindrome from triple digit factors") {
     pending
-    val (value, factors) = PalindromeProducts(0, 9).largest
-    value should be (9)
-    factors should be (Set((1, 9), (3, 3)))
+    PalindromeProducts(100, 999).largest should be(
+      Some((906609, Set((913, 993)))))
   }
 
-  it should "find smallest palindrome from a double digit factors" in {
+  test("find smallest palindrome from four digit factors") {
     pending
-    val (value, factors) = PalindromeProducts(10, 99).smallest
-    value should be (121)
-    factors should be (Set((11, 11)))
+    PalindromeProducts(1000, 9999).smallest should be(
+      Some((1002001, Set((1001, 1001)))))
   }
 
-  it should "find largest palindrome from a double digit factors" in {
+  test("find the largest palindrome from four digit factors") {
     pending
-    val (value, factors) = PalindromeProducts(10, 99).largest
-    value should be (9009)
-    factors should be (Set((91, 99)))
+    PalindromeProducts(1000, 9999).largest should be(
+      Some((99000099, Set((9901, 9999)))))
   }
 
-  it should "find smallest palindrome from a triple digit factors" in {
+  test("empty result for smallest if no palindrome in the range") {
     pending
-    val (value, factors) = PalindromeProducts(100, 999).smallest
-    value should be (10201)
-    factors should be (Set((101, 101)))
+    PalindromeProducts(1002, 1003).smallest should be(None)
   }
 
-  it should "find largest palindrome from a triple digit factors" in {
+  test("empty result for largest if no palindrome in the range") {
     pending
-    val (value, factors) = PalindromeProducts(100, 999).largest
-    value should be (906609)
-    factors should be (Set((913, 993)))
+    PalindromeProducts(15, 15).largest should be(None)
   }
 
-  it should "find smallest palindrome from a four digit factors" in {
+  test("error result for smallest if min is more than max") {
     pending
-    val (value, factors) = PalindromeProducts(1000, 9999).smallest
-    value should be (1002001)
-    factors should be (Set((1001, 1001)))
+    PalindromeProducts(10000, 1).smallest should be(None)
   }
 
-  it should "find largest palindrome from a four digit factors" in {
+  test("error result for largest if min is more than max") {
     pending
-    val (value, factors) = PalindromeProducts(1000, 9999).largest
-    value should be (99000099)
-    factors should be (Set((9901, 9999)))
+    PalindromeProducts(2, 1).largest should be(None)
   }
 }

data/tracks/scala/testgen/src/main/scala/ClockTestGenerator.scala

@@ -0,0 +1,66 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder.{toString, _}
+import testgen._
+
+object ClockTestGenerator {
+  private def toString(expected: CanonicalDataParser.Expected): String =
+    expected.fold(_ => "", TestSuiteBuilder.toString)
+
+  private def expectedToClockStr(expected: CanonicalDataParser.Expected): String =
+    expected.fold(_ => "", any => any match {
+      case str: String => str.split(':').map(_.toInt).mkString(", ")
+      case _ => throw new IllegalArgumentException
+    })
+
+  private def toOperation(addArg: String): String =
+    if (addArg.startsWith("-")) "-" else "+"
+
+  def mapArgToStringForEqual(arg: Any): String = {
+    arg match {
+      case vals: Map[String, String] => s"${vals("hour")}, ${vals("minute")}"
+      case _ => throw new IllegalArgumentException
+    }
+  }
+
+  def sutArgsForEqual(parseResult: CanonicalDataParser.ParseResult, argNames: String*): String =
+    argNames map (name => mapArgToStringForEqual(parseResult(name))) mkString
+
+  def fromLabeledTestAlt(propArgs: (String, Seq[String])*): ToTestCaseData =
+    withLabeledTest { sut => labeledTest =>
+      val sutFunction = labeledTest.property
+      val args = sutArgsAlt(labeledTest.result, propArgs:_*)
+
+      val sutCall =
+        if (sutFunction.toString == "create")
+          s"$sut($args)"
+        else if (sutFunction.toString == "add") {
+          val addArgs = sutArgs(labeledTest.result, "add")
+          s"$sut($args) ${toOperation(addArgs)} $sut(${addArgs.stripPrefix("-")})"
+        } else {
+          val argsForEqual1 = sutArgsForEqual(labeledTest.result, "clock1")
+          val argsForEqual2 = sutArgsForEqual(labeledTest.result, "clock2")
+          s"$sut($argsForEqual1) == $sut($argsForEqual2)"
+        }
+
+      val expected =
+        if (sutFunction.toString == "create" || sutFunction.toString == "add")
+          s"$sut(${expectedToClockStr(labeledTest.expected)})"
+        else
+          toString(labeledTest.expected)
+
+      TestCaseData(s"${labeledTest.description}", sutCall, expected)
+    }
+
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/clock.json")
+
+    val code = TestSuiteBuilder.build(file,
+      fromLabeledTestAlt("create" -> Seq("hour", "minute"),
+        "add" -> Seq("hour", "minute"),
+        "equal" -> Seq("clock1")))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/scala/testgen/src/main/scala/ForthTestGenerator.scala

@@ -0,0 +1,66 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder.{toString, _}
+import testgen._
+
+object ForthTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/forth.json")
+
+    def toString(expected: CanonicalDataParser.Expected): String = {
+      expected match {
+        case Right(n: Int) => s""""${n.toString}""""
+        case Right(vals: List[Int]) => s""""${vals.map(_.toString).mkString(" ")}""""
+        case _ => throw new IllegalArgumentException
+      }
+    }
+
+    def isError(expected: CanonicalDataParser.Expected): Boolean = {
+      expected match {
+        case Left(_) => true
+        case Right(null) => true
+        case Right(n) => false
+      }
+    }
+
+    def argsToString(any: Any): String = {
+      any match {
+        case list: List[_] =>
+          val vals = list.map(s => argsToString(s)).mkString(" ")
+          s""""$vals""""
+        case str: String =>
+          s"$str"
+        case _ => any.toString
+      }
+    }
+
+    def sutArgs(parseResult: CanonicalDataParser.ParseResult, argNames: String*): String =
+      argNames map (name => argsToString(parseResult(name))) mkString ", "
+
+    def fromLabeledTest(argNames: String*): ToTestCaseData =
+      withLabeledTest { sut =>
+        labeledTest =>
+          val args = sutArgs(labeledTest.result, argNames: _*)
+          val property = labeledTest.property
+          val isErr = isError(labeledTest.expected)
+          val sutCall = if (isErr)
+              s"""forth.eval($args).isLeft"""
+            else
+              s"""forth.eval($args).fold(_ => "", _.toString)"""
+
+          val expected = if (isErr)
+              "true"
+            else
+              toString(labeledTest.expected)
+
+          TestCaseData(s"${labeledTest.parentDescriptions.mkString(" - " )} - ${labeledTest.description}", sutCall, expected)
+      }
+
+    val code =
+      TestSuiteBuilder.build(file, fromLabeledTest("input"), Seq(), Seq("private val forth = new Forth"))
+
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/scala/testgen/src/main/scala/KindergartenGardenTestGenerator.scala

@@ -0,0 +1,48 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder._
+import testgen._
+
+object KindergartenGardenTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/kindergarten-garden.json")
+
+    def toString(expected: CanonicalDataParser.Expected): String = {
+      expected match {
+        case Right(xs: List[String]) => s"List(${xs.map(x => "Plant." + x.capitalize).mkString(", ")})"
+        case _ => throw new IllegalArgumentException
+      }
+    }
+
+    def fromLabeledTest(argNames: String*): ToTestCaseData =
+      withLabeledTest { sut =>
+        labeledTest =>
+          val diagram = labeledTest.result("diagram")
+          val student = labeledTest.result("student")
+          val students: List[String] = (labeledTest.result getOrElse("students", List())).asInstanceOf[List[String]]
+          val property = labeledTest.property
+          val sutCall =
+            if (students.isEmpty)
+              s"""Garden.defaultGarden(${escape(diagram.toString)}).$property("$student")"""
+            else
+              s"""Garden(List(${students.map(s => escape(s)).mkString(", ")}), ${escape(diagram.toString)}).$property(${escape(student.toString)})"""
+
+          val expected = toString(labeledTest.expected)
+          TestCaseData(labeledTest.parentDescriptions.mkString(", ") + " - " + labeledTest.description,
+            sutCall, expected)
+      }
+
+    // TODO: Move this escape up to TestSuiteBuilder
+    def escape(raw: String): String = {
+      import scala.reflect.runtime.universe._
+      Literal(Constant(raw)).toString
+    }
+
+    val code =
+      TestSuiteBuilder.build(file, fromLabeledTest("diagram", "student"))
+
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/scala/testgen/src/main/scala/NucleotideCountTestGenerator.scala

@@ -7,6 +7,40 @@ object NucleotideCountTestGenerator {
   def main(args: Array[String]): Unit = {
     val file = new File("src/main/resources/nucleotide-count.json")
 
+    def mapExpectedToString(arg: Map[String, Int]): String = {
+      s"Right(Map(${arg.toSeq
+        .sortBy(_._1)
+        .map{case (key, value) => "\'" + key.toString + "\' -> " + value.toString}
+        .mkString(",\n")}))"
+    }
+
+    def toString(expected: CanonicalDataParser.Expected): String = {
+      expected match {
+        case Left(s: String) => "true"
+        case Right(m: Map[String, Int]) => mapExpectedToString(m)
+        case _ => throw new IllegalArgumentException
+      }
+    }
+
+    def toSutCall(labeledTest: LabeledTest, argNames: String*): String = {
+      val args = sutArgs(labeledTest.result, argNames: _*)
+      val property = labeledTest.property
+      labeledTest.expected match {
+        case Left(_) => s"""new DNA($args).$property.isLeft"""
+        case Right(_) => s"""new DNA($args).$property"""
+        case _ => throw new IllegalArgumentException
+      }
+    }
+
+    def fromLabeledTest(argNames: String*): ToTestCaseData =
+      withLabeledTest { sut =>
+        labeledTest =>
+          val sutCall = toSutCall(labeledTest, argNames: _*)
+          val expected = toString(labeledTest.expected)
+          TestCaseData(labeledTest.description, sutCall, expected)
+      }
+
+
     val code = TestSuiteBuilder.build(file, fromLabeledTest("strand"))
     println(s"-------------")
     println(code)