trackler 2.0.6.36 → 2.0.6.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b98826af252625c0ee25312e8d6e7d0559d62ce
-  data.tar.gz: 1033d0f0d124ed5a5b5be7be0f905294a10fafe9
+  metadata.gz: 0851a1075b06ef0bcf3a59ba9ffa6072f1df8b44
+  data.tar.gz: f890063e05af38c4a48d0d0fd1d9c8e2632418d3
 SHA512:
-  metadata.gz: 1cc546d150c52d181ebd3a13e20fcbe0ed2b01c9477d21f43fbd0686af787feead08794076a42f63cb3fb4dcffc8cc0075f83a71a577d64234c3667f7324629d
-  data.tar.gz: 97481fdacba33c88b1910c287ee081abe040e546aa1bf3dee676b8449f9d1e5345ad057c89eba5428ccfd04c923d8a2e9ea35e41cde95cba7b7ce82bf14f7f9b
+  metadata.gz: e6462d9ecac9f0af0664b798ee4dc9b65f0da97eeac0d8cf4a64e854a381909931cd150dd7605d1b80091ef249656e05598e32eed9f45bfdad7ac80d8bf90717
+  data.tar.gz: bf00c473405dfb45099e1d259a1687cd93f0f9d01eb473e62d292ef8bb2c3068a3a744a92bedb759d42ae21db2822632ad4b5053bccdf6de72828f8aa3b842a2

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.36"
+  VERSION = "2.0.6.37"
 end

data/tracks/fsharp/exercises/isogram/IsogramTest.fs

@@ -4,15 +4,73 @@ open NUnit.Framework
 
 open Isogram
 
-[<TestCase("duplicates", ExpectedResult = true)>]
-[<TestCase("eleven", ExpectedResult = false, Ignore = "Remove to run test case")>]
-[<TestCase("subdermatoglyphic", ExpectedResult = true, Ignore = "Remove to run test case")>]
-[<TestCase("Alphabet", ExpectedResult = false, Ignore = "Remove to run test case")>]
-[<TestCase("thumbscrew-japingly", ExpectedResult = true, Ignore = "Remove to run test case")>]
-[<TestCase("Hjelmqvist-Gryb-Zock-Pfund-Wax", ExpectedResult = true, Ignore = "Remove to run test case")>]
-[<TestCase("Heizölrückstoßabdämpfung", ExpectedResult = true, Ignore = "Remove to run test case")>]
-[<TestCase("the quick brown fox", ExpectedResult = false, Ignore = "Remove to run test case")>]
-[<TestCase("Emily Jung Schwartzkopf", ExpectedResult = true, Ignore = "Remove to run test case")>]
-[<TestCase("éléphant", ExpectedResult = false, Ignore = "Remove to run test case")>]
-let ``Isogram correctly detects isograms`` (actual: string) =
-    isogram actual
+[<Test>]
+let ``Empty string`` () =
+    let input = ""
+    let expected = true
+    let actual = isogram input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Isogram with only lower case characters`` () =
+    let input = "isogram"
+    let expected = true
+    let actual = isogram input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Word with one duplicated character`` () =
+    let input = "eleven"
+    let expected = false
+    let actual = isogram input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Longest reported english isogram`` () =
+    let input = "subdermatoglyphic"
+    let expected = true
+    let actual = isogram input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Word with duplicated character in mixed case`` () =
+    let input = "Alphabet"
+    let expected = false
+    let actual = isogram input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Hypothetical isogrammic word with hyphen`` () =
+    let input = "thumbscrew-japingly"
+    let expected = true
+    let actual = isogram input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Isogram with duplicated non letter character`` () =
+    let input = "Hjelmqvist-Gryb-Zock-Pfund-Wax"
+    let expected = true
+    let actual = isogram input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Made-up name that is an isogram`` () =
+    let input = "Emily Jung Schwartzkopf"
+    let expected = true
+    let actual = isogram input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Word with duplicated accented character`` () =
+    let input = "éléphant"
+    let expected = false
+    let actual = isogram input
+    Assert.That(actual, Is.EqualTo(expected))

data/tracks/fsharp/exercises/luhn/LuhnTest.fs

@@ -2,12 +2,106 @@ module LuhnTest
 
 open NUnit.Framework
 open Luhn
-  
-[<TestCase("1", ExpectedResult = false)>] // single digit strings can not be valid
-[<TestCase("0", ExpectedResult = false, Ignore = "Remove to run test case")>] // a single zero is invalid
-[<TestCase("046 454 286", ExpectedResult = true, Ignore = "Remove to run test case")>] // valid Canadian SIN
-[<TestCase("046 454 287", ExpectedResult = false, Ignore = "Remove to run test case")>] // invalid Canadian SIN
-[<TestCase("8273 1232 7352 0569", ExpectedResult = false, Ignore = "Remove to run test case")>] // invalid credit card
-[<TestCase("827a 1232 7352 0569", ExpectedResult = false, Ignore = "Remove to run test case")>] // strings that contain non-digits are not valid
-let ``Validate checksum`` number =
-    valid number
+
+[<Test>]
+let ``Single digit strings cannot be valid`` () =
+    let input = "1"
+    let expected = false
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``A single zero is invalid`` () =
+    let input = "0"
+    let expected = false
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Single zero with space is invalid`` () =
+    let input = "0 "
+    let expected = false
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Lots of zeros are valid`` () =
+    let input = "00000"
+    let expected = true
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Nine doubled is nine`` () =
+    let input = "091"
+    let expected = true
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Simple valid number`` () =
+    let input = " 5 9 "
+    let expected = true
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Valid Canadian SIN`` () =
+    let input = "046 454 286"
+    let expected = true
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Another valid SIN`` () =
+    let input = "055 444 285"
+    let expected = true
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Invalid Canadian SIN`` () =
+    let input = "046 454 287"
+    let expected = false
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Invalid credit card`` () =
+    let input = "8273 1232 7352 0569"
+    let expected = false
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Strings that contain non-digits are not valid`` () =
+    let input = "827a 1232 7352 0569"
+    let expected = false
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Punctuation is not allowed`` () =
+    let input = "055-444-285"
+    let expected = false
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Symbols are not allowed`` () =
+    let input = "055£ 444$ 285"
+    let expected = false
+    let actual = valid input
+    Assert.That(actual, Is.EqualTo(expected))

data/tracks/fsharp/exercises/nth-prime/NthPrimeTest.fs

@@ -1,19 +1,58 @@
 module NthPrimeTest
 
 open NUnit.Framework
-
 open NthPrime
 
-[<TestCase(1, ExpectedResult = 2)>]
-[<TestCase(2, ExpectedResult = 3, Ignore = "Remove to run test case")>]
-[<TestCase(3, ExpectedResult = 5, Ignore = "Remove to run test case")>]
-[<TestCase(4, ExpectedResult = 7, Ignore = "Remove to run test case")>]
-[<TestCase(5, ExpectedResult = 11, Ignore = "Remove to run test case")>]
-[<TestCase(6, ExpectedResult = 13, Ignore = "Remove to run test case")>]
-[<TestCase(7, ExpectedResult = 17, Ignore = "Remove to run test case")>]
-[<TestCase(8, ExpectedResult = 19, Ignore = "Remove to run test case")>]
-[<TestCase(1000, ExpectedResult = 7919, Ignore = "Remove to run test case")>]
-[<TestCase(10000, ExpectedResult = 104729, Ignore = "Remove to run test case")>]
-[<TestCase(10001, ExpectedResult = 104743, Ignore = "Remove to run test case")>]
-let ``Nth prime calculated`` (nth: int ) = 
-    nthPrime nth
+[<Test>]
+let ``First prime`` () =
+    Assert.That(nthPrime 1, Is.EqualTo(2))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Second prime`` () =
+    Assert.That(nthPrime 2, Is.EqualTo(3))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Third prime`` () =
+    Assert.That(nthPrime 3, Is.EqualTo(5))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``4th prime`` () =
+    Assert.That(nthPrime 4, Is.EqualTo(7))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``5th prime`` () =
+    Assert.That(nthPrime 5, Is.EqualTo(11))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``6th prime`` () =
+    Assert.That(nthPrime 6, Is.EqualTo(13))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``7th prime`` () =
+    Assert.That(nthPrime 7, Is.EqualTo(17))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``8th prime`` () =
+    Assert.That(nthPrime 8, Is.EqualTo(19))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``1000th prime`` () =
+    Assert.That(nthPrime 1000, Is.EqualTo(7919))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``10000th prime`` () =
+    Assert.That(nthPrime 10000, Is.EqualTo(104729))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``10001th prime`` () =
+    Assert.That(nthPrime 10001, Is.EqualTo(104743))

data/tracks/go/config.json

@@ -474,6 +474,11 @@
       "difficulty": 1,
       "slug": "variable-length-quantity",
       "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "forth",
+      "topics": []
     }
   ]
 }

data/tracks/go/exercises/forth/cases_test.go

@@ -0,0 +1,246 @@
+package forth
+
+// Source: exercism/x-common
+// Commit: 8804a76 Remove non-ASCII characters tests from forth exercise
+
+var parsingGroup = []testCase{
+	{
+		"empty input results in empty stack",
+		[]string{},
+		[]int{},
+	},
+	{
+		"numbers just get pushed onto the stack",
+		[]string{"1 2 3 4 5"},
+		[]int{1, 2, 3, 4, 5},
+	},
+	{
+		"all non-word characters are separators",
+		[]string{"1\x002\x133\n4\r5 6\t7"},
+		[]int{1, 2, 3, 4, 5, 6, 7},
+	},
+}
+
+var additionGroup = []testCase{
+	{
+		"can add two numbers",
+		[]string{"1 2 +"},
+		[]int{3},
+	},
+	{
+		"errors if there is nothing on the stack",
+		[]string{"+"},
+		[]int(nil),
+	},
+	{
+		"errors if there is only one value on the stack",
+		[]string{"1 +"},
+		[]int(nil),
+	},
+}
+
+var subtractionGroup = []testCase{
+	{
+		"can subtract two numbers",
+		[]string{"3 4 -"},
+		[]int{-1},
+	},
+	{
+		"errors if there is nothing on the stack",
+		[]string{"-"},
+		[]int(nil),
+	},
+	{
+		"errors if there is only one value on the stack",
+		[]string{"1 -"},
+		[]int(nil),
+	},
+}
+
+var multiplicationGroup = []testCase{
+	{
+		"can multiply two numbers",
+		[]string{"2 4 *"},
+		[]int{8},
+	},
+	{
+		"errors if there is nothing on the stack",
+		[]string{"*"},
+		[]int(nil),
+	},
+	{
+		"errors if there is only one value on the stack",
+		[]string{"1 *"},
+		[]int(nil),
+	},
+}
+
+var divisionGroup = []testCase{
+	{
+		"can divide two numbers",
+		[]string{"12 3 /"},
+		[]int{4},
+	},
+	{
+		"performs integer division",
+		[]string{"8 3 /"},
+		[]int{2},
+	},
+	{
+		"errors if dividing by zero",
+		[]string{"4 0 /"},
+		[]int(nil),
+	},
+	{
+		"errors if there is nothing on the stack",
+		[]string{"/"},
+		[]int(nil),
+	},
+	{
+		"errors if there is only one value on the stack",
+		[]string{"1 /"},
+		[]int(nil),
+	},
+}
+
+var arithmeticGroup = []testCase{
+	{
+		"addition and subtraction",
+		[]string{"1 2 + 4 -"},
+		[]int{-1},
+	},
+	{
+		"multiplication and division",
+		[]string{"2 4 * 3 /"},
+		[]int{2},
+	},
+}
+
+var dupGroup = []testCase{
+	{
+		"copies the top value on the stack",
+		[]string{"1 DUP"},
+		[]int{1, 1},
+	},
+	{
+		"is case-insensitive",
+		[]string{"1 2 Dup"},
+		[]int{1, 2, 2},
+	},
+	{
+		"errors if there is nothing on the stack",
+		[]string{"dup"},
+		[]int(nil),
+	},
+}
+
+var dropGroup = []testCase{
+	{
+		"removes the top value on the stack if it is the only one",
+		[]string{"1 drop"},
+		[]int{},
+	},
+	{
+		"removes the top value on the stack if it is not the only one",
+		[]string{"1 2 drop"},
+		[]int{1},
+	},
+	{
+		"errors if there is nothing on the stack",
+		[]string{"drop"},
+		[]int(nil),
+	},
+}
+
+var swapGroup = []testCase{
+	{
+		"swaps the top two values on the stack if they are the only ones",
+		[]string{"1 2 swap"},
+		[]int{2, 1},
+	},
+	{
+		"swaps the top two values on the stack if they are not the only ones",
+		[]string{"1 2 3 swap"},
+		[]int{1, 3, 2},
+	},
+	{
+		"errors if there is nothing on the stack",
+		[]string{"swap"},
+		[]int(nil),
+	},
+	{
+		"errors if there is only one value on the stack",
+		[]string{"1 swap"},
+		[]int(nil),
+	},
+}
+
+var overGroup = []testCase{
+	{
+		"copies the second element if there are only two",
+		[]string{"1 2 over"},
+		[]int{1, 2, 1},
+	},
+	{
+		"copies the second element if there are more than two",
+		[]string{"1 2 3 over"},
+		[]int{1, 2, 3, 2},
+	},
+	{
+		"errors if there is nothing on the stack",
+		[]string{"over"},
+		[]int(nil),
+	},
+	{
+		"errors if there is only one value on the stack",
+		[]string{"1 over"},
+		[]int(nil),
+	},
+}
+
+var userdefinedGroup = []testCase{
+	{
+		"can consist of built-in words",
+		[]string{": dup-twice dup dup ;", "1 dup-twice"},
+		[]int{1, 1, 1},
+	},
+	{
+		"execute in the right order",
+		[]string{": countup 1 2 3 ;", "countup"},
+		[]int{1, 2, 3},
+	},
+	{
+		"can override other user-defined words",
+		[]string{": foo dup ;", ": foo dup dup ;", "1 foo"},
+		[]int{1, 1, 1},
+	},
+	{
+		"can override built-in words",
+		[]string{": swap dup ;", "1 swap"},
+		[]int{1, 1},
+	},
+	{
+		"cannot redefine numbers",
+		[]string{": 1 2 ;"},
+		[]int(nil),
+	},
+	{
+		"errors if executing a non-existent word",
+		[]string{"foo"},
+		[]int(nil),
+	},
+}
+
+var testSections = []testcaseSection{
+	{"parsing", parsingGroup},
+	{"addition(+)", additionGroup},
+	{"subtraction(-)", subtractionGroup},
+	{"multiplication(*)", multiplicationGroup},
+	{"division(/)", divisionGroup},
+	{"arithmetic", arithmeticGroup},
+	{"dup", dupGroup},
+	{"drop", dropGroup},
+	{"swap", swapGroup},
+	{"over", overGroup},
+	{"user-defined", userdefinedGroup},
+}