trackler 1.0.0 → 1.0.0.1

data/tracks/elixir/exercises/zipper/zipper_test.exs

@@ -3,7 +3,7 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule ZipperTest do
   alias BinTree, as: BT
@@ -21,62 +21,62 @@ defmodule ZipperTest do
                      bt(6, leaf(7), leaf(8)))
   defp t6, do: bt(1, bt(2, nil,     leaf(5)), leaf(4))
 
-  # @tag :skip
+  # @tag :pending
   test "data is retained" do
     assert (t1 |> from_tree |> to_tree) == t1
   end
 
-  @tag :skip
+  @tag :pending
   test "left, right and value" do
     assert (t1 |> from_tree |> left |> right |> value) == 3
   end
 
-  @tag :skip
+  @tag :pending
   test "dead end" do
     assert (t1 |> from_tree |> left |> left) == nil
   end
 
-  @tag :skip
+  @tag :pending
   test "tree from deep focus" do
     assert (t1 |> from_tree |> left |> right |> to_tree) == t1
   end
 
-  @tag :skip
+  @tag :pending
   test "traversing up from top" do
     assert (t1 |> from_tree |> up) == nil
   end
 
-  @tag :skip
+  @tag :pending
   test "left, right, and up" do
     assert (t1 |> from_tree |> left |> up |> right |> up |> left |> right |> value) == 3
   end
 
-  @tag :skip
+  @tag :pending
   test "set_value" do
     assert (t1 |> from_tree |> left |> set_value(5) |> to_tree) == t2
   end
 
-  @tag :skip
+  @tag :pending
   test "set_value after traversing up" do
     assert (t1 |> from_tree |> left |> right |> up |> set_value(5) |> to_tree) == t2
   end
 
-  @tag :skip
+  @tag :pending
   test "set_left with leaf" do
     assert (t1 |> from_tree |> left |> set_left(leaf(5)) |> to_tree) == t3
   end
 
-  @tag :skip
+  @tag :pending
   test "set_right with nil" do
     assert (t1 |> from_tree |> left |> set_right(nil) |> to_tree) == t4
   end
 
-  @tag :skip
+  @tag :pending
   test "set_right with subtree" do
     assert (t1 |> from_tree |> set_right(bt(6, leaf(7), leaf(8))) |> to_tree) == t5
   end
 
-  @tag :skip
+  @tag :pending
   test "set_value on deep focus" do
     assert (t1 |> from_tree |> left |> right |> set_value(5) |> to_tree) == t6
   end

data/tracks/fsharp/build.fsx

@@ -48,10 +48,6 @@ Target "Test" (fun _ ->
         |> NUnit3 (fun p -> { p with ShadowCopy = false })
 )
 
-Target "CleanTest" (fun _ ->
-    DeleteFiles ["iliad.txt"; "midsummer-night.txt"; "paradise-lost.txt"]
-)
-
 // Build order
 "Clean" 
   ==> "Copy"
@@ -59,7 +55,6 @@ Target "CleanTest" (fun _ ->
   ==> "PrepareTests"
   ==> "BuildWithAllTests"    
   ==> "Test"
-  ==> "CleanTest"
 
-// start build
-RunTargetOrDefault "CleanTest"
+// Start build
+RunTargetOrDefault "Test"

data/tracks/fsharp/config.json

@@ -3,110 +3,6 @@
   "language": "F#",
   "repository": "https://github.com/exercism/xfsharp",
   "active": true,
-  "problems": [
-    "hello-world",
-    "bob",
-    "leap",
-    "gigasecond",
-    "difference-of-squares",
-    "rna-transcription",
-    "sum-of-multiples",
-    "space-age",
-    "bank-account",
-    "grains",
-    "hamming",
-    "nucleotide-count",
-    "accumulate",
-    "raindrops",
-    "grade-school",
-    "pangram",
-    "etl",
-    "clock",
-    "beer-song",
-    "triangle",
-    "robot-name",
-    "error-handling",
-    "scrabble-score",
-    "proverb",
-    "protein-translation",
-    "kindergarten-garden",
-    "queen-attack",
-    "strain",
-    "isogram",
-    "sieve",
-    "phone-number",
-    "perfect-numbers",
-    "robot-simulator",
-    "binary-search",
-    "secret-handshake",
-    "word-count",
-    "allergies",
-    "twelve-days",
-    "meetup",
-    "anagram",
-    "series",
-    "simple-linked-list",
-    "acronym",
-    "matrix",
-    "all-your-base",
-    "largest-series-product",
-    "house",
-    "pythagorean-triplet",
-    "saddle-points",
-    "pascals-triangle",
-    "list-ops",
-    "prime-factors",
-    "roman-numerals",
-    "binary-search-tree",
-    "ocr-numbers",
-    "dot-dsl",
-    "parallel-letter-frequency",
-    "linked-list",
-    "simple-cipher",
-    "tree-building",
-    "scale-generator",
-    "atbash-cipher",
-    "food-chain",
-    "grep",
-    "custom-set",
-    "crypto-square",
-    "ledger",
-    "circular-buffer",
-    "luhn",
-    "markdown",
-    "run-length-encoding",
-    "tournament",
-    "word-search",
-    "bowling",
-    "transpose",
-    "nth-prime",
-    "palindrome-products",
-    "pig-latin",
-    "rail-fence-cipher",
-    "bracket-push",
-    "sublist",
-    "change",
-    "minesweeper",
-    "diffie-hellman",
-    "dominoes",
-    "rectangles",
-    "wordy",
-    "hangman",
-    "zebra-puzzle",
-    "poker",
-    "diamond",
-    "two-bucket",
-    "connect",
-    "say",
-    "react",
-    "variable-length-quantity",
-    "go-counting",
-    "sgf-parsing",
-    "zipper",
-    "forth",
-    "pov",
-    "alphametics"
-  ],
   "exercises": [
     {
       "slug": "hello-world",

data/tracks/fsharp/exercises/grep/GrepTest.fs

@@ -43,11 +43,17 @@ That Shepherd, who first taught the chosen Seed
 """
 
 [<OneTimeSetUp>]
-let init () =
+let setUp () =
     File.WriteAllText(iliadFileName, iliadContents)
     File.WriteAllText(midsummerNightFileName, midsummerNightContents)
     File.WriteAllText(paradiseLostFileName, paradiseLostContents)
 
+[<OneTimeTearDown>]
+let tearDown () =
+    File.Delete(iliadFileName)
+    File.Delete(midsummerNightFileName)
+    File.Delete(paradiseLostFileName)
+
 [<Test>]
 let ``One file, one match, no flags`` () =
     let pattern = "Agamemnon"

data/tracks/go/config.json

@@ -10,6 +10,7 @@
     "gigasecond",
     "hamming",
     "raindrops",
+    "acronym",
     "bob",
     "triangle",
     "difference-of-squares",

data/tracks/go/exercises/acronym/acronym_test.go

@@ -0,0 +1,36 @@
+package acronym
+
+import (
+	"testing"
+)
+
+const targetTestVersion = 1
+
+type testCase struct {
+	input    string
+	expected string
+}
+
+var stringTestCases = []testCase{
+	{"Portable Network Graphics", "PNG"},
+	{"HyperText Markup Language", "HTML"},
+	{"Ruby on Rails", "ROR"},
+	{"PHP: Hypertext Preprocessor", "PHP"},
+	{"First In, First Out", "FIFO"},
+	{"Complementary metal-oxide semiconductor", "CMOS"},
+}
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}
+
+func TestAcronym(t *testing.T) {
+	for _, test := range stringTestCases {
+		actual := abbreviate(test.input)
+		if actual != test.expected {
+			t.Errorf("Acronym test [%s], expected [%s], actual [%s]", test.input, test.expected, actual)
+		}
+	}
+}

data/tracks/go/exercises/acronym/example.go

@@ -0,0 +1,21 @@
+package acronym
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+const testVersion = 1
+
+func abbreviate(s string) string {
+	regex := regexp.MustCompile("[A-Z]+[a-z]*|[a-z]+")
+	words := regex.FindAllString(s, -1)
+	abbr := []string{}
+
+	for _, word := range words {
+		abbr = append(abbr, string(word[0]))
+	}
+
+	return fmt.Sprintf("%s", strings.ToUpper(strings.Join(abbr, "")))
+}

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

@@ -5,6 +5,8 @@ import (
 	"strconv"
 )
 
+const testVersion = 1
+
 func isPal(x int) bool {
 	s := strconv.Itoa(x)
 	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {

data/tracks/go/exercises/palindrome-products/palindrome_products_test.go

@@ -7,6 +7,14 @@ import (
 	"testing"
 )
 
+const targetTestVersion = 1
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}
+
 // API to impliment:
 // type Product struct {
 // 	Product int // palindromic, of course
@@ -66,6 +74,8 @@ func TestPalindromeProducts(t *testing.T) {
 			test.fmin, test.fmax)
 		// test
 		pmin, pmax, err := Products(test.fmin, test.fmax)
+		// we check if err is of error type
+		var _ error = err
 		switch {
 		case err == nil:
 			if test.errPrefix > "" {

data/tracks/go/exercises/phone-number/example.go

@@ -6,6 +6,8 @@ import (
 	"unicode"
 )
 
+const testVersion = 1
+
 // Number takes in a potential phone number string and returns the number
 // without any formatting if it's valid.
 //

data/tracks/go/exercises/phone-number/phone_number_test.go

@@ -4,6 +4,8 @@ import (
 	"testing"
 )
 
+const targetTestVersion = 1
+
 type testCase struct {
 	input     string
 	expected  string
@@ -20,19 +22,24 @@ var numberTests = []testCase{
 }
 
 func TestNumber(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
 	for _, test := range numberTests {
 		actual, actualErr := Number(test.input)
-		if actual != test.expected {
-			t.Errorf("Number(%s): expected [%s], actual: [%s]", test.input, test.expected, actual)
-		}
-		// if we expect an error and there isn't one
-		if test.expectErr && actualErr == nil {
+		if !test.expectErr {
+			if actualErr != nil {
+				// if we don't expect an error and there is one
+				var _ error = actualErr
+				t.Errorf("Number(%s): expected no error, but error is: %s", test.input, actualErr)
+			}
+			if actual != test.expected {
+				t.Errorf("Number(%s): expected [%s], actual: [%s]", test.input, test.expected, actual)
+			}
+		} else if actualErr == nil {
+			// if we expect an error and there isn't one
 			t.Errorf("Number(%s): expected an error, but error is nil", test.input)
 		}
-		// if we don't expect an error and there is one
-		if !test.expectErr && actualErr != nil {
-			t.Errorf("Number(%s): expected no error, but error is: %s", test.input, actualErr)
-		}
 	}
 }
 
@@ -55,19 +62,24 @@ var areaCodeTests = []testCase{
 }
 
 func TestAreaCode(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
 	for _, test := range areaCodeTests {
 		actual, actualErr := AreaCode(test.input)
-		if actual != test.expected {
-			t.Errorf("AreaCode(%s): expected [%s], actual: [%s]", test.input, test.expected, actual)
-		}
-		// if we expect an error and there isn't one
-		if test.expectErr && actualErr == nil {
+		if !test.expectErr {
+			if actual != test.expected {
+				t.Errorf("AreaCode(%s): expected [%s], actual: [%s]", test.input, test.expected, actual)
+			}
+			if actualErr != nil {
+				// if we don't expect an error and there is one
+				var _ error = actualErr
+				t.Errorf("AreaCode(%s): expected no error, but error is: %s", test.input, actualErr)
+			}
+		} else if actualErr == nil {
+			// if we expect an error and there isn't one
 			t.Errorf("AreaCode(%s): expected an error, but error is nil", test.input)
 		}
-		// if we don't expect an error and there is one
-		if !test.expectErr && actualErr != nil {
-			t.Errorf("AreaCode(%s): expected no error, but error is: %s", test.input, actualErr)
-		}
 	}
 }
 
@@ -90,19 +102,24 @@ var formatTests = []testCase{
 }
 
 func TestFormat(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
 	for _, test := range formatTests {
 		actual, actualErr := Format(test.input)
-		if actual != test.expected {
-			t.Errorf("Format(%s): expected [%s], actual: [%s]", test.input, test.expected, actual)
-		}
-		// if we expect an error and there isn't one
-		if test.expectErr && actualErr == nil {
+		if !test.expectErr {
+			if actualErr != nil {
+				// if we don't expect an error and there is one
+				var _ error = actualErr
+				t.Errorf("Format(%s): expected no error, but error is: %s", test.input, actualErr)
+			}
+			if actual != test.expected {
+				t.Errorf("Format(%s): expected [%s], actual: [%s]", test.input, test.expected, actual)
+			}
+		} else if actualErr == nil {
+			// if we expect an error and there isn't one
 			t.Errorf("Format(%s): expected an error, but error is nil", test.input)
 		}
-		// if we don't expect an error and there is one
-		if !test.expectErr && actualErr != nil {
-			t.Errorf("Format(%s): expected no error, but error is: %s", test.input, actualErr)
-		}
 	}
 }