trackler 2.1.0.27 → 2.1.0.28

data/tracks/scala/exercises/difference-of-squares/src/main/scala/DifferenceOfSquares.scala

@@ -0,0 +1,8 @@
+object DifferenceOfSquares {
+
+  def sumOfSquares(n: Int): Int = ???
+
+  def squareOfSum(n: Int): Int = ???
+
+  def differenceOfSquares(n: Int): Int = ???
+}

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

@@ -0,0 +1,49 @@
+import org.scalatest.{Matchers, FunSuite}
+
+/** @version 1.1.0 */
+class DifferenceOfSquaresTest extends FunSuite with Matchers {
+
+  test("square of sum 1") {
+    DifferenceOfSquares.squareOfSum(1) should be (1)
+  }
+
+  test("square of sum 5") {
+    pending
+    DifferenceOfSquares.squareOfSum(5) should be (225)
+  }
+
+  test("square of sum 100") {
+    pending
+    DifferenceOfSquares.squareOfSum(100) should be (25502500)
+  }
+
+  test("sum of squares 1") {
+    pending
+    DifferenceOfSquares.sumOfSquares(1) should be (1)
+  }
+
+  test("sum of squares 5") {
+    pending
+    DifferenceOfSquares.sumOfSquares(5) should be (55)
+  }
+
+  test("sum of squares 100") {
+    pending
+    DifferenceOfSquares.sumOfSquares(100) should be (338350)
+  }
+
+  test("difference of squares 1") {
+    pending
+    DifferenceOfSquares.differenceOfSquares(1) should be (0)
+  }
+
+  test("difference of squares 5") {
+    pending
+    DifferenceOfSquares.differenceOfSquares(5) should be (170)
+  }
+
+  test("difference of squares 100") {
+    pending
+    DifferenceOfSquares.differenceOfSquares(100) should be (25164150)
+  }
+}

data/tracks/scala/exercises/leap/example.scala

@@ -1,5 +1,6 @@
-object Year {
-  def isLeap(year: Int): Boolean = {
+object Leap {
+  def leapYear(year: Int): Boolean = {
     def divisibleBy(i: Int) = year % i == 0
-    divisibleBy(4) && (divisibleBy(400) || !divisibleBy(100))}
+    divisibleBy(4) && (divisibleBy(400) || !divisibleBy(100))
+  }
 }

data/tracks/scala/exercises/leap/src/main/scala/Leap.scala

@@ -1,3 +1,3 @@
-object Year {
-  def isLeap(year: Int): Boolean = ???
+object Leap {
+  def leapYear(year: Int): Boolean = ???
 }

data/tracks/scala/exercises/leap/src/test/scala/LeapTest.scala

@@ -1,32 +1,24 @@
-import org.scalatest._
+import org.scalatest.{Matchers, FunSuite}
 
-class LeapTest extends FunSuite {
-  test ("vanilla leap year") {
-    assert(Year.isLeap(1996))
-  }
+/** @version 1.0.0 */
+class LeapTest extends FunSuite with Matchers {
 
-  test ("any old year") {
-    pending
-    assert(!Year.isLeap(1997))
-  }
-
-  test("an even year") {
-    pending
-    assert(!Year.isLeap(1986))
+  test("year not divisible by 4: common year") {
+    Leap.leapYear(2015) should be (false)
   }
 
-  test ("century") {
+  test("year divisible by 4, not divisible by 100: leap year") {
     pending
-    assert(!Year.isLeap(1900))
+    Leap.leapYear(2016) should be (true)
   }
 
-  test ("exceptional century") {
+  test("year divisible by 100, not divisible by 400: common year") {
     pending
-    assert(Year.isLeap(2000))
+    Leap.leapYear(2100) should be (false)
   }
 
-  test("exceptional century that is no millenium") {
+  test("year divisible by 400: leap year") {
     pending
-    assert(Year.isLeap(1600))
+    Leap.leapYear(2000) should be (true)
   }
-}
+}

data/tracks/scala/exercises/raindrops/src/test/scala/RaindropsTest.scala

@@ -1,83 +1,94 @@
-import org.scalatest.{Matchers, FlatSpec}
+import org.scalatest.{Matchers, FunSuite}
 
-class RaindropsTest extends FlatSpec with Matchers {
-  it should "convert 1" in {
-    Raindrops.convert(1) should equal("1")
+/** @version 1.0.0 */
+class RaindropsTest extends FunSuite with Matchers {
+
+  test("the sound for 1 is 1") {
+    Raindrops.convert(1) should be ("1")
   }
 
-  it should "convert 3" in {
+  test("the sound for 3 is Pling") {
     pending
-    Raindrops.convert(3) should equal("Pling")
+    Raindrops.convert(3) should be ("Pling")
   }
 
-  it should "convert 5" in {
+  test("the sound for 5 is Plang") {
     pending
-    Raindrops.convert(5) should equal("Plang")
+    Raindrops.convert(5) should be ("Plang")
   }
 
-  it should "convert 7" in {
+  test("the sound for 7 is Plong") {
     pending
-    Raindrops.convert(7) should equal("Plong")
+    Raindrops.convert(7) should be ("Plong")
   }
 
-  it should "convert 6" in {
+  test("the sound for 6 is Pling as it has a factor 3") {
     pending
-    Raindrops.convert(6) should equal("Pling")
+    Raindrops.convert(6) should be ("Pling")
   }
 
-  it should "convert 9" in {
+  test("2 to the power 3 does not make a raindrop sound as 3 is the exponent not the base") {
     pending
-    Raindrops.convert(9) should equal("Pling")
+    Raindrops.convert(8) should be ("8")
   }
 
-  it should "convert 10" in {
+  test("the sound for 9 is Pling as it has a factor 3") {
     pending
-    Raindrops.convert(10) should equal("Plang")
+    Raindrops.convert(9) should be ("Pling")
   }
 
-  it should "convert 14" in {
+  test("the sound for 10 is Plang as it has a factor 5") {
     pending
-    Raindrops.convert(14) should equal("Plong")
+    Raindrops.convert(10) should be ("Plang")
   }
 
-  it should "convert 15" in {
+  test("the sound for 14 is Plong as it has a factor of 7") {
     pending
-    Raindrops.convert(15) should equal("PlingPlang")
+    Raindrops.convert(14) should be ("Plong")
   }
 
-  it should "convert 21" in {
+  test("the sound for 15 is PlingPlang as it has factors 3 and 5") {
     pending
-    Raindrops.convert(21) should equal("PlingPlong")
+    Raindrops.convert(15) should be ("PlingPlang")
   }
 
-  it should "convert 25" in {
+  test("the sound for 21 is PlingPlong as it has factors 3 and 7") {
     pending
-    Raindrops.convert(25) should equal("Plang")
+    Raindrops.convert(21) should be ("PlingPlong")
   }
 
-  it should "convert 35" in {
+  test("the sound for 25 is Plang as it has a factor 5") {
     pending
-    Raindrops.convert(35) should equal("PlangPlong")
+    Raindrops.convert(25) should be ("Plang")
   }
 
-  it should "convert 49" in {
+  test("the sound for 27 is Pling as it has a factor 3") {
     pending
-    Raindrops.convert(49) should equal("Plong")
+    Raindrops.convert(27) should be ("Pling")
   }
 
-  it should "convert 52" in {
+  test("the sound for 35 is PlangPlong as it has factors 5 and 7") {
     pending
-    Raindrops.convert(52) should equal("52")
+    Raindrops.convert(35) should be ("PlangPlong")
   }
 
-  it should "convert 105" in {
+  test("the sound for 49 is Plong as it has a factor 7") {
     pending
-    Raindrops.convert(105) should equal("PlingPlangPlong")
+    Raindrops.convert(49) should be ("Plong")
   }
 
-  it should "convert 12121" in {
+  test("the sound for 52 is 52") {
     pending
-    Raindrops.convert(12121) should equal("12121")
+    Raindrops.convert(52) should be ("52")
+  }
+
+  test("the sound for 105 is PlingPlangPlong as it has factors 3, 5 and 7") {
+    pending
+    Raindrops.convert(105) should be ("PlingPlangPlong")
   }
-}
 
+  test("the sound for 3125 is Plang as it has a factor 5") {
+    pending
+    Raindrops.convert(3125) should be ("Plang")
+  }
+}

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

@@ -0,0 +1,15 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder
+import testgen.TestSuiteBuilder.fromLabeledTest
+
+object BobTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("bob.json")
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTest("input"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

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

@@ -0,0 +1,15 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder
+import testgen.TestSuiteBuilder.fromLabeledTest
+
+object BookStoreTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("book-store.json")
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTest("basket"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

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

@@ -0,0 +1,17 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder._
+import testgen._
+
+object DifferenceOfSquaresTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/difference-of-squares.json")
+
+    val code = TestSuiteBuilder.build(file,
+        fromLabeledTestAlt("squareOfSum" -> Seq("number"), "sumOfSquares" -> Seq("number"),
+          "differenceOfSquares" -> Seq("number")))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

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

@@ -0,0 +1,15 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder
+import testgen.TestSuiteBuilder.fromLabeledTest
+
+object LeapTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("leap.json")
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTest("input"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

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

@@ -0,0 +1,15 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder
+import testgen.TestSuiteBuilder.fromLabeledTest
+
+object RaindropsTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/raindrops.json")
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTest("number"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/vimscript/config.json

@@ -80,6 +80,11 @@
       "slug": "scrabble-score",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "triangle",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [],

data/tracks/vimscript/exercises/triangle/example.vim

@@ -0,0 +1,28 @@
+"
+" TravisCI's Trusty uses Vim 7.4.52. No uniq() for us.
+"
+
+function! Equilateral(triangle) abort
+  let [a, b, c] = a:triangle
+  return s:invalid(a:triangle) ? 0 : a == b && a == c
+endfunction
+
+function! Isosceles(triangle) abort
+  let [a, b, c] = a:triangle
+  return s:invalid(a:triangle) ? 0 : a == b || a == c || b == c
+endfunction
+
+function! Scalene(triangle) abort
+  let [a, b, c] = a:triangle
+  return s:invalid(a:triangle) ? 0 : a != b && a != c && b != c
+endfunction
+
+function! s:invalid(triangle) abort
+  let [a, b, c] = a:triangle
+
+  if a == 0 || b == 0 || c == 0 || a + b < c || a + c < b || b + c < a
+    return 1
+  endif
+
+  return 0
+endfunction

data/tracks/vimscript/exercises/triangle/triangle.vader

@@ -0,0 +1,92 @@
+"
+" Version: 1.0.0
+"
+
+Before:
+  unlet! input expected
+
+Execute (true if all sides are equal):
+  let input = [2, 2, 2]
+  let expected = 1
+  AssertEqual expected, Equilateral(input)
+
+Execute (false if any side is unequal):
+  let input = [2, 3, 2]
+  let expected = 0
+  AssertEqual expected, Equilateral(input)
+
+Execute (false if no sides are equal):
+  let input = [5, 4, 6]
+  let expected = 0
+  AssertEqual expected, Equilateral(input)
+
+Execute (All zero sides are illegal, so the triangle is not equilateral):
+  let input = [0, 0, 0]
+  let expected = 0
+  AssertEqual expected, Equilateral(input)
+
+Execute (sides may be floats):
+  let input = [0.5, 0.5, 0.5]
+  let expected = 1
+  AssertEqual expected, Equilateral(input)
+
+Execute (true if last two sides are equal):
+  let input = [3, 4, 4]
+  let expected = 1
+  AssertEqual expected, Isosceles(input)
+
+Execute (true if first two sides are equal):
+  let input = [4, 4, 3]
+  let expected = 1
+  AssertEqual expected, Isosceles(input)
+
+Execute (true if first and last sides are equal):
+  let input = [4, 3, 4]
+  let expected = 1
+  AssertEqual expected, Isosceles(input)
+
+Execute (equilateral triangles are also isosceles):
+  let input = [4, 4, 4]
+  let expected = 1
+  AssertEqual expected, Isosceles(input)
+
+Execute (false if no sides are equal):
+  let input = [2, 3, 4]
+  let expected = 0
+  AssertEqual expected, Isosceles(input)
+
+Execute (Sides that violate triangle inequality are not isosceles, even if two are equal):
+  let input = [1, 1, 3]
+  let expected = 0
+  AssertEqual expected, Isosceles(input)
+
+Execute (sides may be floats):
+  let input = [0.5, 0.4, 0.5]
+  let expected = 1
+  AssertEqual expected, Isosceles(input)
+
+Execute (true if no sides are equal):
+  let input = [5, 4, 6]
+  let expected = 1
+  AssertEqual expected, Scalene(input)
+
+Execute (false if all sides are equal):
+  let input = [4, 4, 4]
+  let expected = 0
+  AssertEqual expected, Scalene(input)
+
+Execute (false if two sides are equal):
+  let input = [4, 4, 3]
+  let expected = 0
+  AssertEqual expected, Scalene(input)
+
+Execute (Sides that violate triangle inequality are not scalene, even if they are all different):
+  let input = [7, 3, 2]
+  let expected = 0
+  AssertEqual expected, Scalene(input)
+
+Execute (sides may be floats):
+  let input = [0.5, 0.4, 0.6]
+  let expected = 1
+  AssertEqual expected, Scalene(input)
+