trackler 1.0.0 → 1.0.0.1

data/tracks/elixir/exercises/rna-transcription/rna_transcription_test.exs

@@ -3,32 +3,32 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule RNATranscriptionTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "transcribes guanine to cytosine" do
     assert RNATranscription.to_rna('G') == 'C'
   end
 
-  @tag :skip
+  @tag :pending
   test "transcribes cytosine to guanine" do
     assert RNATranscription.to_rna('C') == 'G'
   end
 
-  @tag :skip
+  @tag :pending
   test "transcribes thymidine to adenine" do
     assert RNATranscription.to_rna('T') == 'A'
   end
 
-  @tag :skip
+  @tag :pending
   test "transcribes adenine to uracil" do
     assert RNATranscription.to_rna('A') == 'U'
   end
 
-  @tag :skip
+  @tag :pending
   test "it transcribes all dna nucleotides to rna equivalents" do
     assert RNATranscription.to_rna('ACGTGGTCTTAA') == 'UGCACCAGAAUU'
   end

data/tracks/elixir/exercises/robot-simulator/robot_simulator_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 RobotSimulatorTest do
   use ExUnit.Case
@@ -14,7 +14,7 @@ defmodule RobotSimulatorTest do
     assert RobotSimulator.direction(robot) == :north
   end
 
-  @tag :skip
+  @tag :pending
   test "create works with valid arguments" do
     robot = RobotSimulator.create(:north, { 0, 0 })
     assert RobotSimulator.position(robot) == { 0, 0 }
@@ -33,7 +33,7 @@ defmodule RobotSimulatorTest do
     assert RobotSimulator.direction(robot) == :west
   end
 
-  @tag :skip
+  @tag :pending
   test "create errors if invalid direction given" do
     position = {0, 0}
     invalid_direction = { :error, "invalid direction" }
@@ -43,7 +43,7 @@ defmodule RobotSimulatorTest do
     assert RobotSimulator.create("east", position) == invalid_direction
   end
 
-  @tag :skip
+  @tag :pending
   test "create errors if invalid position given" do
     direction = :north
     invalid_position = { :error, "invalid position" }
@@ -58,7 +58,7 @@ defmodule RobotSimulatorTest do
     assert RobotSimulator.create(direction, nil) == invalid_position
   end
 
-  @tag :skip
+  @tag :pending
   test "simulate robots" do
     robot1 = RobotSimulator.create(:north, { 0, 0 }) |> RobotSimulator.simulate("LAAARALA")
     assert RobotSimulator.direction(robot1) == :west
@@ -73,7 +73,7 @@ defmodule RobotSimulatorTest do
     assert RobotSimulator.position(robot3) == { 11, 5 }
   end
 
-  @tag :skip
+  @tag :pending
   test "simulate errors on invalid instructions" do
     assert RobotSimulator.create |> RobotSimulator.simulate("UUDDLRLRBASTART") == { :error, "invalid instruction" }
   end

data/tracks/elixir/exercises/roman-numerals/roman_numerals_test.exs

@@ -3,97 +3,97 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule RomanTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "1" do
     assert Roman.numerals(1) == "I"
   end
 
-  @tag :skip
+  @tag :pending
   test "2" do
     assert Roman.numerals(2) == "II"
   end
 
-  @tag :skip
+  @tag :pending
   test "3" do
     assert Roman.numerals(3) == "III"
   end
 
-  @tag :skip
+  @tag :pending
   test "4" do
     assert Roman.numerals(4) == "IV"
   end
 
-  @tag :skip
+  @tag :pending
   test "5" do
     assert Roman.numerals(5) == "V"
   end
 
-  @tag :skip
+  @tag :pending
   test "6" do
     assert Roman.numerals(6) == "VI"
   end
 
-  @tag :skip
+  @tag :pending
   test "9" do
     assert Roman.numerals(9) == "IX"
   end
 
-  @tag :skip
+  @tag :pending
   test "27" do
     assert Roman.numerals(27) == "XXVII"
   end
 
-  @tag :skip
+  @tag :pending
   test "48" do
     assert Roman.numerals(48) == "XLVIII"
   end
 
-  @tag :skip
+  @tag :pending
   test "59" do
     assert Roman.numerals(59) == "LIX"
   end
 
-  @tag :skip
+  @tag :pending
   test "93" do
     assert Roman.numerals(93) == "XCIII"
   end
 
-  @tag :skip
+  @tag :pending
   test "141" do
     assert Roman.numerals(141) == "CXLI"
   end
 
-  @tag :skip
+  @tag :pending
   test "163" do
     assert Roman.numerals(163) == "CLXIII"
   end
 
-  @tag :skip
+  @tag :pending
   test "402" do
     assert Roman.numerals(402) == "CDII"
   end
 
-  @tag :skip
+  @tag :pending
   test "575" do
     assert Roman.numerals(575) == "DLXXV"
   end
 
-  @tag :skip
+  @tag :pending
   test "911" do
     assert Roman.numerals(911) == "CMXI"
   end
 
-  @tag :skip
+  @tag :pending
   test "1024" do
     assert Roman.numerals(1024) == "MXXIV"
   end
 
-  @tag :skip
+  @tag :pending
   test "3000" do
     assert Roman.numerals(3000) == "MMM"
   end

data/tracks/elixir/exercises/run-length-encoding/rle_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 RunLengthEncoderTest do
   use ExUnit.Case
@@ -12,27 +12,27 @@ defmodule RunLengthEncoderTest do
     assert RunLengthEncoder.encode("") === ""
   end
 
-  @tag :skip
+  @tag :pending
   test "simple string gets encoded" do
     assert RunLengthEncoder.encode("AAA") === "3A"
   end
 
-  @tag :skip
+  @tag :pending
   test "more complicated string" do
     assert RunLengthEncoder.encode("HORSE") == "1H1O1R1S1E"
   end
 
-  @tag :skip
+  @tag :pending
   test "an even more complex string" do
     assert RunLengthEncoder.encode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB") === "12W1B12W3B24W1B"
   end
 
-  @tag :skip
+  @tag :pending
   test "it decodes an encoded simple string" do
     assert RunLengthEncoder.decode("3A") === "AAA"
   end
 
-  @tag :skip
+  @tag :pending
   test "it decodes a more complicated string" do
     assert RunLengthEncoder.decode("12W1B12W3B24W1B") === "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
   end

data/tracks/elixir/exercises/saddle-points/saddle_points_test.exs

@@ -3,66 +3,66 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule SaddlePointsTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "extract rows" do
     rows = Matrix.rows("1 2\n10 20")
     assert rows == [[1, 2], [10, 20]]
   end
 
-  @tag :skip
+  @tag :pending
   test "extract a row" do
     rows = Matrix.rows("9 7\n8 6")
     assert Enum.at(rows, 0) == [9, 7]
   end
 
-  @tag :skip
+  @tag :pending
   test "extract other row" do
     rows = Matrix.rows("9 8 7\n19 18 17")
     assert Enum.at(rows, 1) == [19, 18, 17]
   end
 
-  @tag :skip
+  @tag :pending
   test "extract other row again" do
     rows = Matrix.rows("1 4 9\n16 25 36")
     assert Enum.at(rows, 1) == [16, 25, 36]
   end
 
-  @tag :skip
+  @tag :pending
   test "extract a column" do
     columns = Matrix.columns("1 2 3\n4 5 6\n7 8 9\n8 7 6")
     assert Enum.at(columns, 0) == [1, 4, 7, 8]
   end
 
-  @tag :skip
+  @tag :pending
   test "extract another column" do
     columns = Matrix.columns("89 1903 3\n18 3 1\n9 4 800")
     assert Enum.at(columns, 1) == [1903, 3, 4]
   end
 
-  @tag :skip
+  @tag :pending
   test "no saddle point" do
     saddle_points = Matrix.saddle_points("2 1\n1 2")
     assert saddle_points == []
   end
 
-  @tag :skip
+  @tag :pending
   test "a saddle point" do
     saddle_points = Matrix.saddle_points("1 2\n3 4")
     assert saddle_points == [{0, 1}]
   end
 
-  @tag :skip
+  @tag :pending
   test "another saddle point" do
     saddle_points = Matrix.saddle_points("18 3 39 19 91\n38 10 8 77 320\n3 4 8 6 7")
     assert saddle_points == [{2, 2}]
   end
 
-  @tag :skip
+  @tag :pending
   test "multiple saddle points" do
     saddle_points = Matrix.saddle_points("4 5 4\n3 5 5\n1 5 4")
     assert saddle_points == [{0, 1}, {1, 1}, {2, 1}]

data/tracks/elixir/exercises/scrabble-score/scrabble_score_test.exs

@@ -3,47 +3,47 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule ScrabbleScoreTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "empty word scores zero" do
     assert Scrabble.score("") == 0
   end
 
-  @tag :skip
+  @tag :pending
   test "whitespace scores zero" do
     assert Scrabble.score(" \t\n") == 0
   end
 
-  @tag :skip
+  @tag :pending
   test "scores very short word" do
     assert Scrabble.score("a") == 1
   end
 
-  @tag :skip
+  @tag :pending
   test "scores other very short word" do
     assert Scrabble.score("f") == 4
   end
 
-  @tag :skip
+  @tag :pending
   test "simple word scores the number of letters" do
     assert Scrabble.score("street") == 6
   end
 
-  @tag :skip
+  @tag :pending
   test "complicated word scores more" do
     assert Scrabble.score("quirky") == 22
   end
 
-  @tag :skip
+  @tag :pending
   test "scores are case insensitive" do
     assert Scrabble.score("OXYPHENBUTAZONE") == 41
   end
 
-  @tag :skip
+  @tag :pending
   test "convenient scoring" do
     assert Scrabble.score("alacrity") == 13
   end

data/tracks/elixir/exercises/sieve/sieve_test.exs

@@ -3,17 +3,17 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule SieveTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "a few primes" do
     assert Sieve.primes_to(10) == [2, 3, 5, 7]
   end
 
-  @tag :skip
+  @tag :pending
   test "primes to 1000" do
     result = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
     41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,

data/tracks/elixir/exercises/space-age/space_age_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
 
 # You need to define a SpaceAge module containing a function age_on that given a
 # planet (:earth, :saturn, etc) and a number of seconds returns the age in years
@@ -12,55 +12,55 @@ ExUnit.configure trace: true
 defmodule SpageAgeTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "age on Earth" do
     input = 1_000_000_000
     assert_in_delta 31.69, SpaceAge.age_on(:earth, input), 0.005
   end
 
-  @tag :skip
+  @tag :pending
   test "age on Mercury" do
     input = 2_134_835_688
     assert_in_delta 67.65, SpaceAge.age_on(:earth, input), 0.005
     assert_in_delta 280.88, SpaceAge.age_on(:mercury, input), 0.005
   end
 
-  @tag :skip
+  @tag :pending
   test "age on Venus" do
     input = 189_839_836
     assert_in_delta 6.02, SpaceAge.age_on(:earth, input), 0.005
     assert_in_delta 9.78, SpaceAge.age_on(:venus, input), 0.005
   end
 
-  @tag :skip
+  @tag :pending
   test "age on Mars" do
     input = 2_329_871_239
     assert_in_delta 73.83, SpaceAge.age_on(:earth, input), 0.005
     assert_in_delta 39.25, SpaceAge.age_on(:mars, input), 0.005
   end
 
-  @tag :skip
+  @tag :pending
   test "age on Jupiter" do
     input = 901_876_382
     assert_in_delta 28.58, SpaceAge.age_on(:earth, input), 0.005
     assert_in_delta 2.41, SpaceAge.age_on(:jupiter, input), 0.005
   end
 
-  @tag :skip
+  @tag :pending
   test "age on Saturn" do
     input = 3_000_000_000
     assert_in_delta 95.06, SpaceAge.age_on(:earth, input), 0.005
     assert_in_delta 3.23, SpaceAge.age_on(:saturn, input), 0.005
   end
 
-  @tag :skip
+  @tag :pending
   test "age on Uranus" do
     input = 3_210_123_456
     assert_in_delta 101.72, SpaceAge.age_on(:earth, input), 0.005
     assert_in_delta 1.21, SpaceAge.age_on(:uranus, input), 0.005
   end
 
-  @tag :skip
+  @tag :pending
   test "age on Neptune" do
     input = 8_210_123_456
     assert_in_delta 260.16, SpaceAge.age_on(:earth, input), 0.005