trackler 1.0.0 → 1.0.0.1

data/tracks/elixir/exercises/sublist/sublist_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 SublistTest do
   use ExUnit.Case
@@ -12,100 +12,100 @@ defmodule SublistTest do
     assert Sublist.compare([], []) == :equal
   end
 
-  @tag :skip
+  @tag :pending
   test "empty is a sublist of anything" do
     assert Sublist.compare([], [nil]) == :sublist
   end
 
-  @tag :skip
+  @tag :pending
   test "anything is a superlist of empty" do
     assert Sublist.compare([nil], []) == :superlist
   end
 
-  @tag :skip
+  @tag :pending
   test "1 is not 2" do
     assert Sublist.compare([1], [2]) == :unequal
   end
 
-  @tag :skip
+  @tag :pending
   test "comparing massive equal lists" do
     l = Enum.to_list(1..1_000_000)
     assert Sublist.compare(l, l) == :equal
   end
 
-  @tag :skip
+  @tag :pending
   test "sublist at start" do
     assert Sublist.compare([1,2,3],[1,2,3,4,5]) == :sublist
   end
 
-  @tag :skip
+  @tag :pending
   test "sublist in middle" do
     assert Sublist.compare([4,3,2],[5,4,3,2,1]) == :sublist
   end
 
-  @tag :skip
+  @tag :pending
   test "sublist at end" do
     assert Sublist.compare([3,4,5],[1,2,3,4,5]) == :sublist
   end
 
-  @tag :skip
+  @tag :pending
   test "partially matching sublist at start" do
     assert Sublist.compare([1,1,2], [1,1,1,2]) == :sublist
   end
 
-  @tag :skip
+  @tag :pending
   test "sublist early in huge list" do
     assert Sublist.compare([3,4,5], Enum.to_list(1..1_000_000)) == :sublist
   end
 
-  @tag :skip
+  @tag :pending
   test "huge sublist not in huge list" do
     assert Sublist.compare(Enum.to_list(10..1_000_001),
                            Enum.to_list(1..1_000_000))
            == :unequal
   end
 
-  @tag :skip
+  @tag :pending
   test "superlist at start" do
     assert Sublist.compare([1,2,3,4,5],[1,2,3]) == :superlist
   end
 
-  @tag :skip
+  @tag :pending
   test "superlist in middle" do
     assert Sublist.compare([5,4,3,2,1],[4,3,2]) == :superlist
   end
 
-  @tag :skip
+  @tag :pending
   test "superlist at end" do
     assert Sublist.compare([1,2,3,4,5],[3,4,5]) == :superlist
   end
 
-  @tag :skip
+  @tag :pending
   test "1 and 2 does not contain 3" do
     assert Sublist.compare([1,2], [3]) == :unequal
   end
 
-  @tag :skip
+  @tag :pending
   test "partially matching superlist at start" do
     assert Sublist.compare([1,1,1,2], [1,1,2]) == :superlist
   end
 
-  @tag :skip
+  @tag :pending
   test "superlist early in huge list" do
     assert Sublist.compare(Enum.to_list(1..1_000_000), [3,4,5]) == :superlist
   end
 
-  @tag :skip
+  @tag :pending
   test "strict equality needed" do
     assert Sublist.compare([1], [1.0, 2]) == :unequal
   end
 
-  @tag :skip
+  @tag :pending
   test "recurring values sublist" do
     assert Sublist.compare([1,2,1,2,3], [1,2,3,1,2,1,2,3,2,1]) == :sublist
   end
 
-  @tag :skip
+  @tag :pending
   test "recurring values unequal" do
     assert Sublist.compare([1,2,1,2,3], [1,2,3,1,2,3,2,3,2,1]) == :unequal
   end

data/tracks/elixir/exercises/sum-of-multiples/sum_of_multiples_test.exs

@@ -3,60 +3,60 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule SumOfMultiplesTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "sum to 1" do
     assert SumOfMultiples.to(1, [3, 5]) == 0
   end
 
-  @tag :skip
+  @tag :pending
   test "sum to 3" do
     assert SumOfMultiples.to(4, [3, 5]) == 3
   end
 
-  @tag :skip
+  @tag :pending
   test "sum to 10" do
     assert SumOfMultiples.to(10, [3, 5]) == 23
   end
 
-  @tag :skip
+  @tag :pending
   test "sum to 20" do
     assert SumOfMultiples.to(20, [3, 5]) == 78
   end
 
-  @tag :skip
+  @tag :pending
   test "sum to 100" do
     assert SumOfMultiples.to(100, [3, 5]) == 2318
   end
 
-  @tag :skip
+  @tag :pending
   test "sum to 1000" do
     assert SumOfMultiples.to(1000, [3, 5]) == 233168
   end
 
-  @tag :skip
+  @tag :pending
   test "configurable 7, 13, 17 to 20" do
     multiples = [7, 13, 17]
     assert SumOfMultiples.to(20, multiples) == 51
   end
 
-  @tag :skip
+  @tag :pending
   test "configurable 4, 6 to 15" do
     multiples = [4, 6]
     assert SumOfMultiples.to(15, multiples) == 30
   end
 
-  @tag :skip
+  @tag :pending
   test "configurable 5, 6, 8 to 150" do
     multiples = [5, 6, 8]
     assert SumOfMultiples.to(150, multiples) == 4419
   end
 
-  @tag :skip
+  @tag :pending
   test "configurable 43, 47 to 10000" do
     multiples = [43, 47]
     assert SumOfMultiples.to(10000, multiples) == 2203160

data/tracks/elixir/exercises/test_helper.exs

@@ -3,5 +3,5 @@
 |> Kernel.ParallelRequire.files
 
 System.put_env("EXERCISM_TEST_EXAMPLES", "true")
-ExUnit.configure include: :skip
+ExUnit.configure include: :pending
 ExUnit.start

data/tracks/elixir/exercises/triangle/triangle_test.exs

@@ -3,82 +3,82 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule TriangleTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "equilateral triangles have equal sides" do
     assert Triangle.kind(2, 2, 2) == { :ok, :equilateral }
   end
 
-  @tag :skip
+  @tag :pending
   test "larger equilateral triangles also have equal sides" do
     assert Triangle.kind(10, 10, 10) == { :ok, :equilateral }
   end
 
-  @tag :skip
+  @tag :pending
   test "isosceles triangles have last two sides equal" do
     assert Triangle.kind(3, 4, 4) == { :ok, :isosceles }
   end
 
-  @tag :skip
+  @tag :pending
   test "isosceles triangles have first and last sides equal" do
     assert Triangle.kind(4, 3, 4) == { :ok, :isosceles }
   end
 
-  @tag :skip
+  @tag :pending
   test "isosceles triangles have two first sides equal" do
     assert Triangle.kind(4, 4, 3) == { :ok, :isosceles }
   end
 
-  @tag :skip
+  @tag :pending
   test "isosceles triangles have in fact exactly two sides equal" do
     assert Triangle.kind(10, 10, 2) == { :ok, :isosceles }
   end
 
-  @tag :skip
+  @tag :pending
   test "scalene triangles have no equal sides" do
     assert Triangle.kind(3, 4, 5) == { :ok, :scalene }
   end
 
-  @tag :skip
+  @tag :pending
   test "scalene triangles have no equal sides at a larger scale too" do
     assert Triangle.kind(10, 11, 12) == { :ok, :scalene }
   end
 
-  @tag :skip
+  @tag :pending
   test "scalene triangles have no equal sides in descending order either" do
     assert Triangle.kind(5, 4, 2) == { :ok, :scalene }
   end
 
-  @tag :skip
+  @tag :pending
   test "very small triangles are legal" do
     assert Triangle.kind(0.4, 0.6, 0.3) == { :ok, :scalene }
   end
 
-  @tag :skip
+  @tag :pending
   test "triangles with no size are illegal" do
     assert Triangle.kind(0, 0, 0) == { :error, "all side lengths must be positive" }
   end
 
-  @tag :skip
+  @tag :pending
   test "triangles with negative sides are illegal" do
     assert Triangle.kind(3, 4, -5) == { :error, "all side lengths must be positive" }
   end
 
-  @tag :skip
+  @tag :pending
   test "triangles violating triangle inequality are illegal" do
     assert Triangle.kind(1, 1, 3) == { :error, "side lengths violate triangle inequality" }
   end
 
-  @tag :skip
+  @tag :pending
   test "triangles violating triangle inequality are illegal 2" do
     assert Triangle.kind(2, 4, 2) == { :error, "side lengths violate triangle inequality" }
   end
 
-  @tag :skip
+  @tag :pending
   test "triangles violating triangle inequality are illegal 3" do
     assert Triangle.kind(7, 3, 2) == { :error, "side lengths violate triangle inequality" }
   end

data/tracks/elixir/exercises/word-count/word_count_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 WordsTest do
   use ExUnit.Case
@@ -12,49 +12,49 @@ defmodule WordsTest do
     assert Words.count("word") == %{ "word" => 1 }
   end
 
-  @tag :skip
+  @tag :pending
   test "count one of each" do
     expected = %{ "one" => 1 ,  "of" => 1 ,  "each" => 1 }
     assert Words.count("one of each") == expected
   end
 
-  @tag :skip
+  @tag :pending
   test "count multiple occurrences" do
     expected = %{ "one" => 1 ,  "fish" => 4 ,  "two" => 1 ,  "red" => 1 ,  "blue" => 1 }
     assert Words.count("one fish two fish red fish blue fish") == expected
   end
 
-  @tag :skip
+  @tag :pending
   test "ignore punctuation" do
     expected = %{"car" => 1, "carpet" => 1, "as" => 1, "java" => 1, "javascript" => 1}
     assert Words.count("car : carpet as java : javascript!!&@$%^&") == expected
   end
 
-  @tag :skip
+  @tag :pending
   test "include numbers" do
     expected = %{"testing" => 2, "1" => 1, "2" => 1}
     assert Words.count("testing, 1, 2 testing") == expected
   end
 
-  @tag :skip
+  @tag :pending
   test "hyphens" do
     expected = %{"co-operative" => 1}
     assert Words.count("co-operative") == expected
   end
 
-  @tag :skip
+  @tag :pending
   test "ignore underscores" do
     expected = %{"two" => 1, "words" => 1}
     assert Words.count("two_words") == expected
   end
 
-  @tag :skip
+  @tag :pending
   test "normalize case" do
     expected = %{"go" => 3}
     assert Words.count("go Go GO") == expected
   end
 
-  @tag :skip
+  @tag :pending
   test "German" do
     expected = %{"götterfunken" => 1, "schöner" => 1, "freude" => 1}
     assert Words.count("Freude schöner Götterfunken") == expected

data/tracks/elixir/exercises/wordy/wordy_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 WordyTest do
   use ExUnit.Case
@@ -12,79 +12,79 @@ defmodule WordyTest do
     assert Wordy.answer("What is 1 plus 1?") == 2
   end
 
-  @tag :skip
+  @tag :pending
   test "more addition" do
     assert Wordy.answer("What is 53 plus 2?") == 55
   end
 
-  @tag :skip
+  @tag :pending
   test "addition with negative numbers" do
     assert Wordy.answer("What is -1 plus -10?") == -11
   end
 
-  @tag :skip
+  @tag :pending
   test "large addition" do
     assert Wordy.answer("What is 123 plus 45678?") == 45801
   end
 
-  @tag :skip
+  @tag :pending
   test "subtraction" do
     assert Wordy.answer("What is 4 minus -12?") == 16
   end
 
-  @tag :skip
+  @tag :pending
   test "multiplication" do
     assert Wordy.answer("What is -3 multiplied by 25?") == -75
   end
 
-  @tag :skip
+  @tag :pending
   test "division" do
     assert Wordy.answer("What is 33 divided by -3?") == -11
   end
 
-  @tag :skip
+  @tag :pending
   test "multiple additions" do
     assert Wordy.answer("What is 1 plus 1 plus 1?") == 3
   end
 
-  @tag :skip
+  @tag :pending
   test "addition and subtraction" do
     assert Wordy.answer("What is 1 plus 5 minus -2?") == 8
   end
 
-  @tag :skip
+  @tag :pending
   test "multiple subtraction" do
     assert Wordy.answer("What is 20 minus 4 minus 13?") == 3
   end
 
-  @tag :skip
+  @tag :pending
   test "subtraction then addition" do
     assert Wordy.answer("What is 17 minus 6 plus 3?") == 14
   end
 
-  @tag :skip
+  @tag :pending
   test "multiple multiplication" do
     assert Wordy.answer("What is 2 multiplied by -2 multiplied by 3?") == -12
   end
 
-  @tag :skip
+  @tag :pending
   test "addition and multiplication" do
     assert Wordy.answer("What is -3 plus 7 multiplied by -2?") == -8
   end
 
-  @tag :skip
+  @tag :pending
   test "multiple division" do
     assert Wordy.answer("What is -12 divided by 2 divided by -3?") == 2
   end
 
-  @tag :skip
+  @tag :pending
   test "unknown operation" do
     assert_raise ArgumentError, fn ->
       Wordy.answer("What is 52 cubed?")
     end
   end
 
-  @tag :skip
+  @tag :pending
   test "Non math question" do
     assert_raise ArgumentError, fn ->
       Wordy.answer("Who is the President of the United States?")