Remove redundant tests

Author: josevalim

lib/elixir/lib/access.ex

@@ -873,11 +873,6 @@ defmodule Access do
       ...> end)
       {[], [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]}
 
-  An error is raised if the predicate is not a function or is of the incorrect arity:
-
-      iex> get_in([], [Access.filter(5)])
-      ** (FunctionClauseError) no function clause matching in Access.filter/1
-
   An error is raised if the accessed structure is not a list:
 
       iex> get_in(%{}, [Access.filter(fn a -> a == 10 end)])
@@ -1154,11 +1149,6 @@ defmodule Access do
       ...> end)
       {nil, [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]}
 
-  An error is raised if the predicate is not a function or is of the incorrect arity:
-
-      iex> get_in([], [Access.find(5)])
-      ** (FunctionClauseError) no function clause matching in Access.find/1
-
   An error is raised if the accessed structure is not a list:
 
       iex> get_in(%{}, [Access.find(fn a -> a == 10 end)])

lib/elixir/lib/exception.ex

@@ -1930,8 +1930,8 @@ defmodule FunctionClauseError do
 
   For example:
 
-      iex> URI.parse(:wrong_argument)
-      ** (FunctionClauseError) no function clause matching in URI.parse/1
+      iex> List.duplicate(:ok, -3)
+      ** (FunctionClauseError) no function clause matching in List.duplicate/2
 
   The following fields of this exception are public and can be accessed freely:
 

lib/elixir/lib/list.ex

@@ -187,9 +187,10 @@ defmodule List do
   """
   @spec duplicate(any, 0) :: []
   @spec duplicate(elem, pos_integer) :: [elem, ...] when elem: var
-  def duplicate(elem, n) do
-    :lists.duplicate(n, elem)
-  end
+  def duplicate(elem, n) when is_integer(n) and n >= 0, do: duplicate(n, elem, [])
+
+  defp duplicate(0, _elem, acc), do: acc
+  defp duplicate(n, elem, acc), do: duplicate(n - 1, elem, [elem | acc])
 
   @doc """
   Flattens the given `list` of nested lists.

lib/elixir/test/elixir/inspect/algebra_test.exs

@@ -50,10 +50,7 @@ defmodule Inspect.AlgebraTest do
     # Consistent with definitions
     assert break("break") == {:doc_break, "break", :strict}
     assert break("") == {:doc_break, "", :strict}
-
-    # Wrong argument type
-    assert_raise FunctionClauseError, fn -> break(42) end
-
+    Fun
     # Consistent formatting
     assert render(break("_"), 80) == "_"
     assert render(glue("foo", " ", glue("bar", " ", "baz")), 10) == "foo\nbar\nbaz"
@@ -64,9 +61,6 @@ defmodule Inspect.AlgebraTest do
     assert flex_break("break") == {:doc_break, "break", :flex}
     assert flex_break("") == {:doc_break, "", :flex}
 
-    # Wrong argument type
-    assert_raise FunctionClauseError, fn -> flex_break(42) end
-
     # Consistent formatting
     assert render(flex_break("_"), 80) == "_"
     assert render(flex_glue("foo", " ", flex_glue("bar", " ", "baz")), 10) == "foo bar\nbaz"
@@ -76,9 +70,6 @@ defmodule Inspect.AlgebraTest do
     # Consistent with definitions
     assert glue("a", "->", "b") == ["a", {:doc_break, "->", :strict} | "b"]
     assert glue("a", "b") == glue("a", " ", "b")
-
-    # Wrong argument type
-    assert_raise FunctionClauseError, fn -> glue("a", 42, "b") end
   end
 
   test "flex glue doc" do
@@ -87,9 +78,6 @@ defmodule Inspect.AlgebraTest do
              ["a", {:doc_break, "->", :flex} | "b"]
 
     assert flex_glue("a", "b") == flex_glue("a", " ", "b")
-
-    # Wrong argument type
-    assert_raise FunctionClauseError, fn -> flex_glue("a", 42, "b") end
   end
 
   test "binary doc" do
@@ -115,9 +103,6 @@ defmodule Inspect.AlgebraTest do
     assert nest(empty(), 1) == {:doc_nest, empty(), 1, :always}
     assert nest(empty(), 0) == []
 
-    # Wrong argument type
-    assert_raise FunctionClauseError, fn -> nest("foo", empty()) end
-
     # Consistent formatting
     assert render(nest("a", 1), 80) == "a"
     assert render(nest(glue("a", "b"), 1), 2) == "a\n b"
@@ -129,9 +114,6 @@ defmodule Inspect.AlgebraTest do
     assert nest(empty(), 1, :break) == {:doc_nest, empty(), 1, :break}
     assert nest(empty(), 0, :break) == []
 
-    # Wrong argument type
-    assert_raise FunctionClauseError, fn -> nest("foo", empty(), :break) end
-
     # Consistent formatting
     assert render(nest("a", 1, :break), 80) == "a"
     assert render(nest(glue("a", "b"), 1, :break), 2) == "a\n b"
@@ -231,10 +213,6 @@ defmodule Inspect.AlgebraTest do
     # Consistent with definitions
     assert collapse_lines(3) == {:doc_collapse, 3}
 
-    # Wrong argument type
-    assert_raise FunctionClauseError, fn -> collapse_lines(0) end
-    assert_raise FunctionClauseError, fn -> collapse_lines(empty()) end
-
     # Consistent formatting
     doc = concat([collapse_lines(2), line(), line(), line()])
     assert render(doc, 10) == "\n\n"

lib/elixir/test/elixir/list_test.exs

@@ -386,10 +386,6 @@ defmodule ListTest do
     refute List.improper?([[1]])
     refute List.improper?([1, 2])
     refute List.improper?([1, 2, 3])
-
-    assert_raise FunctionClauseError, fn ->
-      List.improper?(%{})
-    end
   end
 
   describe "ascii_printable?/2" do

lib/elixir/test/elixir/string_test.exs

@@ -418,14 +418,6 @@ defmodule StringTest do
     assert String.pad_leading("---", 5, ["abc"]) == "abcabc---"
     assert String.pad_leading("--", 6, ["a", "bc"]) == "abcabc--"
 
-    assert_raise FunctionClauseError, fn ->
-      String.pad_leading("-", -1)
-    end
-
-    assert_raise FunctionClauseError, fn ->
-      String.pad_leading("-", 1, [])
-    end
-
     message = "expected a string padding element, got: 10"
 
     assert_raise ArgumentError, message, fn ->
@@ -447,14 +439,6 @@ defmodule StringTest do
     assert String.pad_trailing("---", 5, ["abc"]) == "---abcabc"
     assert String.pad_trailing("--", 6, ["a", "bc"]) == "--abcabc"
 
-    assert_raise FunctionClauseError, fn ->
-      String.pad_trailing("-", -1)
-    end
-
-    assert_raise FunctionClauseError, fn ->
-      String.pad_trailing("-", 1, [])
-    end
-
     message = "expected a string padding element, got: 10"
 
     assert_raise ArgumentError, message, fn ->
@@ -720,14 +704,6 @@ defmodule StringTest do
     assert String.at("л", -3) == nil
     assert String.at("Ā̀stute", 1) == "s"
     assert String.at("elixir", 6) == nil
-
-    assert_raise FunctionClauseError, fn ->
-      String.at("elixir", 0.1)
-    end
-
-    assert_raise FunctionClauseError, fn ->
-      String.at("elixir", -0.1)
-    end
   end
 
   test "slice/3" do
@@ -781,10 +757,6 @@ defmodule StringTest do
     assert String.slice("abc", -1..14) == "c"
     assert String.slice("a·̀ͯ‿.⁀:", 0..-2//1) == "a·̀ͯ‿.⁀"
 
-    assert_raise FunctionClauseError, fn ->
-      String.slice(nil, 0..1)
-    end
-
     assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
              assert String.slice("elixir", 0..-2//-1) == "elixi"
            end) =~ "negative steps are not supported in String.slice/2, pass 0..-2//1 instead"

lib/ex_unit/lib/ex_unit/assertions.ex

@@ -1119,6 +1119,6 @@ defmodule ExUnit.Assertions do
   @spec flunk :: no_return
   @spec flunk(String.t()) :: no_return
   def flunk(message \\ "Flunked!") when is_binary(message) do
-    assert false, message: message
+    raise ExUnit.AssertionError, message
   end
 end