Hide obvious failures from type system

Author: josevalim

lib/elixir/test/elixir/kernel/raise_test.exs

@@ -458,12 +458,10 @@ defmodule Kernel.RaiseTest do
       assert result == "no match of right hand side value: 0"
     end
 
-    defp empty_map(), do: %{}
-
     test "bad key error" do
       result =
         try do
-          %{empty_map() | foo: :bar}
+          %{Process.get(:unused, %{}) | foo: :bar}
         rescue
           x in [KeyError] -> Exception.message(x)
         end
@@ -472,7 +470,7 @@ defmodule Kernel.RaiseTest do
 
       result =
         try do
-          empty_map().foo
+          Process.get(:unused, %{}).foo
         rescue
           x in [KeyError] -> Exception.message(x)
         end

lib/elixir/test/elixir/kernel/special_forms_test.exs

@@ -68,12 +68,10 @@ defmodule Kernel.SpecialFormsTest do
       end
     end
 
-    def false_fun(), do: false
-
     test "cond_clause error keeps line number in stacktrace" do
       try do
         cond do
-          false_fun() -> :ok
+          Process.get(:unused, false) -> :ok
         end
       rescue
         _ ->

lib/elixir/test/elixir/kernel/with_test.exs

@@ -126,7 +126,7 @@ defmodule Kernel.WithTest do
     end
 
     assert_raise RuntimeError, fn ->
-      with({:ok, res} <- ok(42), res = res + oops(), do: res)
+      with({:ok, res} <- ok(42), oops(), do: res)
     end
   end
 

lib/elixir/test/elixir/kernel_test.exs

@@ -11,7 +11,6 @@ defmodule KernelTest do
 
   def id(arg), do: arg
   def id(arg1, arg2), do: {arg1, arg2}
-  def empty_list(), do: []
   def empty_map, do: %{}
 
   defp purge(module) do
@@ -1359,7 +1358,7 @@ defmodule KernelTest do
     assert is_map_key(Map.new(a: 1), :a) == true
 
     assert_raise BadMapError, fn ->
-      is_map_key(empty_list(), :a)
+      is_map_key(Process.get(:unused, []), :a)
     end
 
     case Map.new(a: 1) do
@@ -1381,15 +1380,15 @@ defmodule KernelTest do
   test "tl/1" do
     assert tl([:one]) == []
     assert tl([1, 2, 3]) == [2, 3]
-    assert_raise ArgumentError, fn -> tl(empty_list()) end
+    assert_raise ArgumentError, fn -> tl(Process.get(:unused, [])) end
 
     assert tl([:a | :b]) == :b
     assert tl([:a, :b | :c]) == [:b | :c]
   end
 
   test "hd/1" do
     assert hd([1, 2, 3, 4]) == 1
-    assert_raise ArgumentError, fn -> hd(empty_list()) end
+    assert_raise ArgumentError, fn -> hd(Process.get(:unused, [])) end
     assert hd([1 | 2]) == 1
   end
 

lib/elixir/test/elixir/map_test.exs

@@ -6,8 +6,7 @@ defmodule MapTest do
   doctest Map
 
   @sample %{a: 1, b: 2}
-
-  defp sample, do: @sample
+  defp sample, do: Process.get(:unused, %{a: 1, b: 2})
 
   test "maps in attributes" do
     assert @sample == %{a: 1, b: 2}
@@ -82,7 +81,7 @@ defmodule MapTest do
 
   test "map_size/1" do
     assert map_size(%{}) == 0
-    assert map_size(@sample) == 2
+    assert map_size(sample()) == 2
   end
 
   test "new/1" do
@@ -282,8 +281,6 @@ defmodule MapTest do
     defstruct name: "john", age: 27
   end
 
-  defp empty_map(), do: %{}
-
   test "structs" do
     assert %ExternalUser{} == %{__struct__: ExternalUser, name: "john", age: 27}
 
@@ -294,10 +291,6 @@ defmodule MapTest do
 
     %ExternalUser{name: name} = %ExternalUser{}
     assert name == "john"
-
-    assert_raise BadStructError, "expected a struct named MapTest.ExternalUser, got: %{}", fn ->
-      %ExternalUser{empty_map() | name: "meg"}
-    end
   end
 
   describe "structs with variable name" do
@@ -325,12 +318,11 @@ defmodule MapTest do
       end
     end
 
-    defp foo(), do: "foo"
     defp destruct1(%module{}), do: module
     defp destruct2(%_{}), do: :ok
 
     test "does not match" do
-      invalid_struct = %{__struct__: foo()}
+      invalid_struct = Process.get(:unused, %{__struct__: "foo"})
 
       assert_raise CaseClauseError, fn ->
         case invalid_struct do
@@ -345,7 +337,7 @@ defmodule MapTest do
       end
 
       assert_raise CaseClauseError, fn ->
-        foo = foo()
+        foo = Process.get(:unused, "foo")
 
         case invalid_struct do
           %^foo{} -> :ok
@@ -370,7 +362,7 @@ defmodule MapTest do
       end
 
       assert_raise MatchError, fn ->
-        foo = foo()
+        foo = Process.get(:unused, "foo")
         %^foo{} = invalid_struct
       end
     end

lib/ex_unit/test/ex_unit/assertions_test.exs

@@ -314,13 +314,13 @@ defmodule ExUnit.AssertionsTest do
     true = assert match?({2, 1}, Value.tuple())
 
     try do
-      assert match?({:ok, _}, error(true))
+      assert match?({:ok, _}, Process.get(:unused, :ok))
       flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
         "match (match?) failed" = error.message
-        "assert match?({:ok, _}, error(true))" = Macro.to_string(error.expr)
-        "{:error, true}" = Macro.to_string(error.right)
+        "assert match?({:ok, _}, Process.get(:unused, :ok))" = Macro.to_string(error.expr)
+        ":ok" = Macro.to_string(error.right)
     end
   end
 

lib/ex_unit/test/ex_unit/callbacks_test.exs

@@ -446,10 +446,14 @@ defmodule ExUnit.CallbacksNoTests do
   use ExUnit.Case, async: true
 
   setup_all do
-    raise "never run"
+    if :rand.uniform() >= 0 do
+      raise "never run"
+    end
   end
 
   setup do
-    raise "never run"
+    if :rand.uniform() >= 0 do
+      raise "never run"
+    end
   end
 end