     assert List.flatten([[]]) == []
   end
 
-  test "flatten with tail" do
+  test "flatten/2" do
     assert List.flatten([1, 2, 3], [4, 5]) == [1, 2, 3, 4, 5]
     assert List.flatten([1, [2], 3], [4, 5]) == [1, 2, 3, 4, 5]
     assert List.flatten([[1, [2], 3]], [4, 5]) == [1, 2, 3, 4, 5]
   end
 
-  test "foldl" do
+  test "foldl/3" do
     assert List.foldl([1, 2, 3], 0, fn x, y -> x + y end) == 6
     assert List.foldl([1, 2, 3], 10, fn x, y -> x + y end) == 16
     assert List.foldl([1, 2, 3, 4], 0, fn x, y -> x - y end) == 2
   end
 
-  test "foldr" do
+  test "foldr/3" do
     assert List.foldr([1, 2, 3], 0, fn x, y -> x + y end) == 6
     assert List.foldr([1, 2, 3], 10, fn x, y -> x + y end) == 16
     assert List.foldr([1, 2, 3, 4], 0, fn x, y -> x - y end) == -2
   end
 
-  test "duplicate" do
+  test "duplicate/2" do
     assert List.duplicate(1, 3) == [1, 1, 1]
     assert List.duplicate([1], 1) == [[1]]
   end
 
-  test "last" do
+  test "last/1" do
     assert List.last([]) == nil
     assert List.last([1]) == 1
     assert List.last([1, 2, 3]) == 3
   end
 
-  test "zip" do
+  test "zip/1" do
     assert List.zip([[1, 4], [2, 5], [3, 6]]) == [{1, 2, 3}, {4, 5, 6}]
     assert List.zip([[1, 4], [2, 5, 0], [3, 6]]) == [{1, 2, 3}, {4, 5, 6}]
     assert List.zip([[1], [2, 5], [3, 6]]) == [{1, 2, 3}]
     assert List.zip([[1, 4], [2, 5], []]) == []
   end
 
-  test "keyfind" do
+  test "keyfind/4" do
     assert List.keyfind([a: 1, b: 2], :a, 0) == {:a, 1}
     assert List.keyfind([a: 1, b: 2], 2, 1) == {:b, 2}
     assert List.keyfind([a: 1, b: 2], :c, 0) == nil
   end
 
-  test "keyreplace" do
+  test "keyreplace/4" do
     assert List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3}) == [a: 3, b: 2]
     assert List.keyreplace([a: 1], :b, 0, {:b, 2}) == [a: 1]
   end
 
-  test "keysort" do
+  test "keysort/2" do
     assert List.keysort([a: 4, b: 3, c: 5], 1) == [b: 3, a: 4, c: 5]
     assert List.keysort([a: 4, c: 1, b: 2], 0) == [a: 4, b: 2, c: 1]
   end
 
-  test "keystore" do
+  test "keystore/4" do
     assert List.keystore([a: 1, b: 2], :a, 0, {:a, 3}) == [a: 3, b: 2]
     assert List.keystore([a: 1], :b, 0, {:b, 2}) == [a: 1, b: 2]
   end
 
-  test "keymember?" do
+  test "keymember?/3" do
     assert List.keymember?([a: 1, b: 2], :a, 0) == true
     assert List.keymember?([a: 1, b: 2], 2, 1) == true
     assert List.keymember?([a: 1, b: 2], :c, 0) == false
   end
 
-  test "keydelete" do
+  test "keydelete/3" do
     assert List.keydelete([a: 1, b: 2], :a, 0) == [{:b, 2}]
     assert List.keydelete([a: 1, b: 2], 2, 1) == [{:a, 1}]
     assert List.keydelete([a: 1, b: 2], :c, 0) == [{:a, 1}, {:b, 2}]
   end
 
-  test "insert at" do
+  test "insert_at/3" do
     assert List.insert_at([1, 2, 3], 0, 0) == [0, 1, 2, 3]
     assert List.insert_at([1, 2, 3], 3, 0) == [1, 2, 3, 0]
     assert List.insert_at([1, 2, 3], 2, 0) == [1, 2, 0, 3]

    assert List.update_at([1, 2, 3], -4, &(&1 + 1)) == [1, 2, 3]
  end

  test "delete at" do
    Enum.each [-1, 0, 1], fn i ->
      assert [] = List.delete_at([], i)
    end

    assert List.replace_at([1, 2, 3], -4, 0) == [1, 2, 3]
  end

  test "update_at/3" do
    assert List.update_at([1, 2, 3], 0, &(&1 + 1)) == [2, 2, 3]
    assert List.update_at([1, 2, 3], 1, &(&1 + 1)) == [1, 3, 3]
    assert List.update_at([1, 2, 3], 2, &(&1 + 1)) == [1, 2, 4]
