trackler 1.0.0 → 1.0.0.1

data/tracks/elixir/exercises/isogram/isogram_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 IsogramTest do
   use ExUnit.Case
@@ -12,47 +12,47 @@ defmodule IsogramTest do
     assert Isogram.isogram?("subdermatoglyphic")
   end
 
-  @tag :skip
+  @tag :pending
   test "not isogram lowercase " do
     refute Isogram.isogram?("eleven")
   end
 
-  @tag :skip
+  @tag :pending
   test "isogram uppercase" do
     assert Isogram.isogram?("DEMONSTRABLY")
   end
 
-  @tag :skip
+  @tag :pending
   test "not isogram uppercase" do
     refute Isogram.isogram?("ALPHABET")
   end
 
-  @tag :skip
+  @tag :pending
   test "isogram with dash" do
     assert Isogram.isogram?("hjelmqvist-gryb-zock-pfund-wax")
   end
 
-  @tag :skip
+  @tag :pending
   test "not isogram with dash" do
     refute Isogram.isogram?("twenty-five")
   end
 
-  @tag :skip
+  @tag :pending
   test "isogram with utf-8 letters" do
     assert Isogram.isogram?("heizölrückstoßabdämpfung")
   end
 
-  @tag :skip
+  @tag :pending
   test "not isogram with utf-8 letters" do
     refute Isogram.isogram?("éléphant")
   end
 
-  @tag :skip
+  @tag :pending
   test "phrase is isogram" do
     assert Isogram.isogram?("emily jung schwartzkopf")
   end
 
-  @tag :skip
+  @tag :pending
   test "phrase is not isogram" do
     refute Isogram.isogram?("the quick brown fox")
   end

data/tracks/elixir/exercises/kindergarten-garden/garden_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 GardenTest do
   use ExUnit.Case
@@ -13,25 +13,25 @@ defmodule GardenTest do
     assert garden_info.alice == {:radishes, :clover, :grass, :grass}
   end
 
-  @tag :skip
+  @tag :pending
   test "gets another garden for Alice with just her plants" do
     garden_info = Garden.info("VC\nRC")
     assert garden_info.alice == {:violets, :clover, :radishes, :clover}
   end
 
-  @tag :skip
+  @tag :pending
   test "returns an empty tuple if the child has no plants" do
     garden_info = Garden.info("VC\nRC")
     assert garden_info.bob == {}
   end
 
-  @tag :skip
+  @tag :pending
   test "gets the garden for Bob" do
     garden_info = Garden.info("VVCG\nVVRC")
     assert garden_info.bob == {:clover, :grass, :radishes, :clover}
   end
 
-  @tag :skip
+  @tag :pending
   test "gets the garden for all students" do
     garden_info = Garden.info("VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV")
     assert garden_info.alice == {:violets, :radishes, :violets, :radishes}
@@ -48,14 +48,14 @@ defmodule GardenTest do
     assert garden_info.larry == {:grass, :violets, :clover, :violets}
   end
 
-  @tag :skip
+  @tag :pending
   test "accepts custom child names" do
     garden_info = Garden.info("VC\nRC", [:nate, :maggie])
     assert garden_info.maggie == {:violets, :clover, :radishes, :clover}
     assert garden_info.nate == {}
   end
 
-  @tag :skip
+  @tag :pending
   test "gets the garden for all students with custom child names" do
     names = [:maggie, :nate, :xander, :ophelia, :pete, :reggie, :sylvia,
              :tanner, :ursula, :victor, :winnie, :ynold]

data/tracks/elixir/exercises/largest-series-product/largest_series_product_test.exs

@@ -3,91 +3,91 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule LargestSeriesProductTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "largest product of 2" do
     assert Series.largest_product("0123456789", 2) == 72
   end
 
-  @tag :skip
+  @tag :pending
   test "largest product of a tiny number" do
     assert Series.largest_product("12", 2) == 2
   end
 
-  @tag :skip
+  @tag :pending
   test "another tiny number" do
     assert Series.largest_product("19", 2) == 9
   end
 
-  @tag :skip
+  @tag :pending
   test "largest product of 2 shuffled" do
     assert Series.largest_product("576802143", 2) == 48
   end
 
-  @tag :skip
+  @tag :pending
   test "largest product of 3" do
     assert Series.largest_product("0123456789", 3) == 504
   end
 
-  @tag :skip
+  @tag :pending
   test "largest product of 3 shuffled" do
     assert Series.largest_product("1027839564", 3) == 270
   end
 
-  @tag :skip
+  @tag :pending
   test "largest product of 5" do
     assert Series.largest_product("0123456789", 5) == 15120
   end
 
-  @tag :skip
+  @tag :pending
   test "some big number" do
     assert Series.largest_product("73167176531330624919225119674426574742355349194934", 6) == 23520
   end
 
-  @tag :skip
+  @tag :pending
   test "some other big number" do
     assert Series.largest_product("52677741234314237566414902593461595376319419139427", 6) == 28350
   end
 
-  @tag :skip
+  @tag :pending
   test "number with all zeroes" do
     assert Series.largest_product("0000", 2) == 0
   end
 
-  @tag :skip
+  @tag :pending
   test "number where all products are zero" do
     assert Series.largest_product("99099", 3) == 0
   end
 
-  @tag :skip
+  @tag :pending
   test "identity with empty string" do
     assert Series.largest_product("", 0) == 1
   end
 
-  @tag :skip
+  @tag :pending
   test "identity with non-empty string" do
     assert Series.largest_product("123", 0) == 1
   end
 
-  @tag :skip
+  @tag :pending
   test "raises if span is too large" do
     assert_raise ArgumentError, fn ->
       Series.largest_product("123", 4)
     end
   end
 
-  @tag :skip
+  @tag :pending
   test "raises with empty string but non-zero span size" do
     assert_raise ArgumentError, fn ->
       Series.largest_product("", 1)
     end
   end
 
-  @tag :skip
+  @tag :pending
   test "raises with non-empty string and negative span size" do
     assert_raise ArgumentError, fn ->
       Series.largest_product("1234", -1)

data/tracks/elixir/exercises/leap/leap_test.exs

@@ -3,27 +3,27 @@ if !System.get_env("EXERCISM_TEST_EXAMPLES") do
 end
 
 ExUnit.start
-ExUnit.configure trace: true
+ExUnit.configure exclude: :pending, trace: true
 
 defmodule LeapTest do
   use ExUnit.Case
 
-  # @tag :skip
+  # @tag :pending
   test "vanilla leap year" do
     assert Year.leap_year?(1996)
   end
 
-  @tag :skip
+  @tag :pending
   test "any old year" do
     refute Year.leap_year?(1997), "1997 is not a leap year."
   end
 
-  @tag :skip
+  @tag :pending
   test "century" do
     refute Year.leap_year?(1900), "1900 is not a leap year."
   end
 
-  @tag :skip
+  @tag :pending
   test "exceptional century" do
     assert Year.leap_year?(2400)
   end

data/tracks/elixir/exercises/list-ops/list_ops_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 ListOpsTest do
   alias ListOps, as: L
@@ -12,132 +12,132 @@ defmodule ListOpsTest do
 
   defp odd?(n), do: rem(n, 2) == 1
 
-  # @tag :skip
+  # @tag :pending
   test "count of empty list" do
     assert L.count([]) == 0
   end
 
-  @tag :skip
+  @tag :pending
   test "count of normal list" do
     assert L.count([1,3,5,7]) == 4
   end
 
-  @tag :skip
+  @tag :pending
   test "count of huge list" do
     assert L.count(Enum.to_list(1..1_000_000)) == 1_000_000
   end
 
-  @tag :skip
+  @tag :pending
   test "reverse of empty list" do
     assert L.reverse([]) == []
   end
 
-  @tag :skip
+  @tag :pending
   test "reverse of normal list" do
     assert L.reverse([1,3,5,7]) == [7,5,3,1]
   end
 
-  @tag :skip
+  @tag :pending
   test "reverse of huge list" do
     assert L.reverse(Enum.to_list(1..1_000_000)) == Enum.to_list(1_000_000..1)
   end
 
-  @tag :skip
+  @tag :pending
   test "map of empty list" do
     assert L.map([], &(&1+1)) == []
   end
 
-  @tag :skip
+  @tag :pending
   test "map of normal list" do
     assert L.map([1,3,5,7], &(&1+1)) == [2,4,6,8]
   end
 
-  @tag :skip
+  @tag :pending
   test "map of huge list" do
     assert L.map(Enum.to_list(1..1_000_000), &(&1+1)) ==
       Enum.to_list(2..1_000_001)
   end
 
-  @tag :skip
+  @tag :pending
   test "filter of empty list" do
     assert L.filter([], &odd?/1) == []
   end
 
-  @tag :skip
+  @tag :pending
   test "filter of normal list" do
     assert L.filter([1,2,3,4], &odd?/1) == [1,3]
   end
 
-  @tag :skip
+  @tag :pending
   test "filter of huge list" do
     assert L.filter(Enum.to_list(1..1_000_000), &odd?/1) ==
       Enum.map(1..500_000, &(&1*2-1))
   end
 
-  @tag :skip
+  @tag :pending
   test "reduce of empty list" do
     assert L.reduce([], 0, &(&1+&2)) == 0
   end
 
-  @tag :skip
+  @tag :pending
   test "reduce of normal list" do
     assert L.reduce([1,2,3,4], -3, &(&1+&2)) == 7
   end
 
-  @tag :skip
+  @tag :pending
   test "reduce of huge list" do
     assert L.reduce(Enum.to_list(1..1_000_000), 0, &(&1+&2)) ==
       Enum.reduce(1..1_000_000, 0, &(&1+&2))
   end
 
-  @tag :skip
+  @tag :pending
   test "reduce with non-commutative function" do
     assert L.reduce([1,2,3,4], 10, fn x, acc -> acc - x end) == 0
   end
 
-  @tag :skip
+  @tag :pending
   test "append of empty lists" do
     assert L.append([], []) == []
   end
 
-  @tag :skip
+  @tag :pending
   test "append of empty and non-empty list" do
     assert L.append([], [1,2,3,4]) == [1,2,3,4]
   end
 
-  @tag :skip
+  @tag :pending
   test "append of non-empty and empty list" do
     assert L.append([1,2,3,4], []) == [1,2,3,4]
   end
 
-  @tag :skip
+  @tag :pending
   test "append of non-empty lists" do
     assert L.append([1,2,3], [4,5]) == [1,2,3,4,5]
   end
 
-  @tag :skip
+  @tag :pending
   test "append of huge lists" do
     assert L.append(Enum.to_list(1..1_000_000), Enum.to_list(1_000_001..2_000_000)) ==
       Enum.to_list(1..2_000_000)
   end
 
-  @tag :skip
+  @tag :pending
   test "concat of empty list of lists" do
     assert L.concat([]) == []
   end
 
-  @tag :skip
+  @tag :pending
   test "concat of normal list of lists" do
     assert L.concat([[1,2],[3],[],[4,5,6]]) == [1,2,3,4,5,6]
   end
 
-  @tag :skip
+  @tag :pending
   test "concat of huge list of small lists" do
     assert L.concat(Enum.map(1..1_000_000, &[&1])) ==
       Enum.to_list(1..1_000_000)
   end
 
-  @tag :skip
+  @tag :pending
   test "concat of small list of huge lists" do
     assert L.concat(Enum.map(0..9, &Enum.to_list((&1*100_000+1)..((&1+1)*100_000)))) ==
       Enum.to_list(1..1_000_000)

data/tracks/elixir/exercises/luhn/luhn_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 LuhnTest do
   use ExUnit.Case
@@ -12,32 +12,32 @@ defmodule LuhnTest do
     assert Luhn.checksum("4913") == 22
   end
 
-  @tag :skip
+  @tag :pending
   test "checksum again" do
     assert Luhn.checksum("201773") == 21
   end
 
-  @tag :skip
+  @tag :pending
   test "invalid number" do
     assert Luhn.valid?("738") == false
   end
 
-  @tag :skip
+  @tag :pending
   test "valid number" do
     assert Luhn.valid?("8739567") == true
   end
 
-  @tag :skip
+  @tag :pending
   test "create valid number" do
     assert Luhn.create("123") == "1230"
   end
 
-  @tag :skip
+  @tag :pending
   test "create other valid number" do
     assert Luhn.create("873956") == "8739567"
   end
 
-  @tag :skip
+  @tag :pending
   test "create yet another valid number" do
     assert Luhn.create("837263756") == "8372637564"
   end