trackler 1.0.0 → 1.0.0.1

data/tracks/elixir/exercises/prime-factors/prime_factors_test.exs

@@ -3,67 +3,67 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule PrimeFactorsTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "1" do
     assert PrimeFactors.factors_for(1) == []
   end
 
-  @tag :skip
+  @tag :pending
   test "2" do
     assert PrimeFactors.factors_for(2) == [2]
   end
 
-  @tag :skip
+  @tag :pending
   test "3" do
     assert PrimeFactors.factors_for(3) == [3]
   end
 
-  @tag :skip
+  @tag :pending
   test "4" do
     assert PrimeFactors.factors_for(4) == [2, 2]
   end
 
-  @tag :skip
+  @tag :pending
   test "6" do
     assert PrimeFactors.factors_for(6) == [2, 3]
   end
 
-  @tag :skip
+  @tag :pending
   test "8" do
     assert PrimeFactors.factors_for(8) == [2, 2, 2]
   end
 
-  @tag :skip
+  @tag :pending
   test "9" do
     assert PrimeFactors.factors_for(9) == [3, 3]
   end
 
-  @tag :skip
+  @tag :pending
   test "27" do
     assert PrimeFactors.factors_for(27) == [3, 3, 3]
   end
 
-  @tag :skip
+  @tag :pending
   test "625" do
     assert PrimeFactors.factors_for(625) == [5, 5, 5, 5]
   end
 
-  @tag :skip
+  @tag :pending
   test "901255" do
     assert PrimeFactors.factors_for(901255) == [5, 17, 23, 461]
   end
 
-  @tag :skip
+  @tag :pending
   test "93819012551" do
     assert PrimeFactors.factors_for(93819012551) == [11, 9539, 894119]
   end
 
-  @tag :skip
+  @tag :pending
   # @tag timeout: 2000
   #
   # The timeout tag above will set the below test to fail unless it completes

data/tracks/elixir/exercises/pythagorean-triplet/pythagorean_triplet_test.exs

@@ -3,48 +3,48 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule PythagoreanTripletTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "sum" do
     triplet = [3, 4, 5]
     assert Triplet.sum(triplet) == 12
   end
 
-  @tag :skip
+  @tag :pending
   test "product" do
     triplet = [3, 4, 5]
     assert Triplet.product(triplet) == 60
   end
 
-  @tag :skip
+  @tag :pending
   test "pythagorean" do
     triplet = [3, 4, 5]
     assert Triplet.pythagorean?(triplet)
   end
 
-  @tag :skip
+  @tag :pending
   test "not pythagorean" do
     triplet = [5, 6, 7]
     refute Triplet.pythagorean?(triplet)
   end
 
-  @tag :skip
+  @tag :pending
   test "triplets up to 10" do
     triplets = Triplet.generate(1, 10)
     assert Enum.map(triplets, &Triplet.product/1) == [60, 480]
   end
 
-  @tag :skip
+  @tag :pending
   test "triplets from 11 up to 20" do
     triplets = Triplet.generate(11, 20)
     assert Enum.map(triplets, &Triplet.product/1) == [3840]
   end
 
-  @tag :skip
+  @tag :pending
   test "triplets where sum is 180 and max factor is 100" do
     triplets = Triplet.generate(1, 100, 180)
     assert Enum.map(triplets, &Triplet.product/1) == [118080, 168480, 202500]

data/tracks/elixir/exercises/queen-attack/queen_attack_test.exs

@@ -3,33 +3,33 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule QueenAttackTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "default positions" do
     queens = Queens.new
     assert queens.white == {0, 3}
     assert queens.black == {7, 3}
   end
 
-  @tag :skip
+  @tag :pending
   test "specific placement" do
     queens = Queens.new({3, 7}, {6, 1})
     assert queens.white == {3, 7}
     assert queens.black == {6, 1}
   end
 
-  @tag :skip
+  @tag :pending
   test "cannot occupy same space" do
     assert_raise ArgumentError, fn ->
       Queens.new({2, 4}, {2, 4})
     end
   end
 
-  @tag :skip
+  @tag :pending
   test "string representation" do
     queens = Queens.new({2, 4}, {6, 6})
     board = String.strip """
@@ -45,7 +45,7 @@ _ _ _ _ _ _ _ _
     assert Queens.to_string(queens) == board
   end
 
-  @tag :skip
+  @tag :pending
   test "another string representation" do
     queens = Queens.new({7, 1}, {0, 0})
     board = String.strip """
@@ -61,7 +61,7 @@ _ W _ _ _ _ _ _
     assert Queens.to_string(queens) == board
   end
 
-  @tag :skip
+  @tag :pending
   test "yet another string representation" do
     queens = Queens.new({4, 3}, {3, 4})
     board = String.strip """
@@ -77,7 +77,7 @@ _ _ _ _ _ _ _ _
     assert Queens.to_string(queens) == board
   end
 
-  @tag :skip
+  @tag :pending
   test "queen placed on the bottom right corner" do
     queens = Queens.new({4, 3}, {7, 7})
     board = String.strip """
@@ -93,7 +93,7 @@ _ _ _ _ _ _ _ B
     assert Queens.to_string(queens) == board
   end
 
-  @tag :skip
+  @tag :pending
   test "queen placed on the edge of the board" do
     queens = Queens.new({4, 3}, {2, 7})
     board = String.strip """
@@ -109,43 +109,43 @@ _ _ _ _ _ _ _ _
     assert Queens.to_string(queens) == board
   end
 
-  @tag :skip
+  @tag :pending
   test "cannot attack" do
     queens = Queens.new({2, 3}, {4, 7})
     refute Queens.can_attack?(queens)
   end
 
-  @tag :skip
+  @tag :pending
   test "can attack on same row" do
     queens = Queens.new({2, 4}, {2, 7})
     assert Queens.can_attack?(queens)
   end
 
-  @tag :skip
+  @tag :pending
   test "can attack on same column" do
     queens = Queens.new({5, 4}, {2, 4})
     assert Queens.can_attack?(queens)
   end
 
-  @tag :skip
+  @tag :pending
   test "can attack on diagonal" do
     queens = Queens.new({1, 1}, {6, 6})
     assert Queens.can_attack?(queens)
   end
 
-  @tag :skip
+  @tag :pending
   test "can attack on other diagonal" do
     queens = Queens.new({0, 6}, {1, 7})
     assert Queens.can_attack?(queens)
   end
 
-  @tag :skip
+  @tag :pending
   test "can attack on yet another diagonal" do
     queens = Queens.new({4, 1}, {6, 3})
     assert Queens.can_attack?(queens)
   end
 
-  @tag :skip
+  @tag :pending
   test "can attack on a diagonal slanted the other way" do
     queens = Queens.new({6, 1}, {1, 6})
     assert Queens.can_attack?(queens)

data/tracks/elixir/exercises/rail-fence-cipher/rail_fence_cipher_test.exs

@@ -3,74 +3,74 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule RailFenceCipherTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "encode with ending at the first rail" do
     assert RailFenceCipher.encode("XOXOXOXOXOXOXOXOXO", 2) == "XXXXXXXXXOOOOOOOOO"
   end
 
-  @tag :skip
+  @tag :pending
   test "encode with ending in the middle" do
     msg = "WEAREDISCOVEREDFLEEATONCE"
     assert RailFenceCipher.encode(msg, 3) == "WECRLTEERDSOEEFEAOCAIVDEN"
   end
 
-  @tag :skip
+  @tag :pending
   test "encode empty string" do
     assert RailFenceCipher.encode("", 4) == ""
   end
 
-  @tag :skip
+  @tag :pending
   test "encode a more diverse text" do
     msg = "The quick brown fox jumps over the lazy dog."
     cipher = "Tioxs aghucrwo p rtlzo.eqkbnfjmoeh yd   uve "
     assert RailFenceCipher.encode(msg, 4) == cipher
   end
 
-  @tag :skip
+  @tag :pending
   test "encode with one rail" do
     msg = "One rail, only one rail"
     assert RailFenceCipher.encode(msg, 1) == msg
   end
 
-  @tag :skip
+  @tag :pending
   test "encode letters of less than rails" do
     msg = "More rails than letters"
     assert RailFenceCipher.encode(msg, 24) == msg
   end
 
-  @tag :skip
+  @tag :pending
   test "decode full zigzag cipher" do
     cipher = "TEITELHDVLSNHDTIEIIEA"
     assert RailFenceCipher.decode(cipher, 3) == "THEDEVILISINTHEDETAIL"
   end
 
-  @tag :skip
+  @tag :pending
   test "decode with ending in the middle" do
     cipher = "EIEXMSMESAORIWSCE"
     assert RailFenceCipher.decode(cipher, 5) == "EXERCISMISAWESOME"
   end
 
-  @tag :skip
+  @tag :pending
   test "decode empty string" do
     assert RailFenceCipher.decode("", 4) == ""
   end
 
-  @tag :skip
+  @tag :pending
   test "decode with one rail" do
     assert RailFenceCipher.decode("ABCDEFGHIJKLMNOP", 1) == "ABCDEFGHIJKLMNOP"
   end
 
-  @tag :skip
+  @tag :pending
   test "decode letters of less than rails" do
     assert RailFenceCipher.decode("More rails than letters", 24) == "More rails than letters"
   end
 
-  @tag :skip
+  @tag :pending
   test "decode a more diverse text" do
     msg = "The quick brown fox jumps over the lazy dog."
     cipher = RailFenceCipher.encode(msg, 4)

data/tracks/elixir/exercises/raindrops/raindrops_test.exs

@@ -3,87 +3,87 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule RaindropsTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "1" do
     assert Raindrops.convert(1) == "1"
   end
 
-  @tag :skip
+  @tag :pending
   test "3" do
     assert Raindrops.convert(3) == "Pling"
   end
 
-  @tag :skip
+  @tag :pending
   test "5" do
     assert Raindrops.convert(5) == "Plang"
   end
 
-  @tag :skip
+  @tag :pending
   test "7" do
     assert Raindrops.convert(7) == "Plong"
   end
 
-  @tag :skip
+  @tag :pending
   test "6" do
     assert Raindrops.convert(6) == "Pling"
   end
 
-  @tag :skip
+  @tag :pending
   test "9" do
     assert Raindrops.convert(9) == "Pling"
   end
 
-  @tag :skip
+  @tag :pending
   test "10" do
     assert Raindrops.convert(10) == "Plang"
   end
 
-  @tag :skip
+  @tag :pending
   test "14" do
     assert Raindrops.convert(14) == "Plong"
   end
 
-  @tag :skip
+  @tag :pending
   test "15" do
     assert Raindrops.convert(15) == "PlingPlang"
   end
 
-  @tag :skip
+  @tag :pending
   test "21" do
     assert Raindrops.convert(21) == "PlingPlong"
   end
 
-  @tag :skip
+  @tag :pending
   test "25" do
     assert Raindrops.convert(25) == "Plang"
   end
 
-  @tag :skip
+  @tag :pending
   test "35" do
     assert Raindrops.convert(35) == "PlangPlong"
   end
 
-  @tag :skip
+  @tag :pending
   test "49" do
     assert Raindrops.convert(49) == "Plong"
   end
 
-  @tag :skip
+  @tag :pending
   test "52" do
     assert Raindrops.convert(52) == "52"
   end
 
-  @tag :skip
+  @tag :pending
   test "105" do
     assert Raindrops.convert(105) == "PlingPlangPlong"
   end
 
-  @tag :skip
+  @tag :pending
   test "12121" do
     assert Raindrops.convert(12121) == "12121"
   end