Tidy up GenEvent docs and test suite

Author: José Valim

lib/elixir/lib/gen_event.ex

@@ -57,7 +57,7 @@ defmodule GenEvent do
   Notifications can be sent to the event manager which will then
   invoke `handle_event/2` for each registered handler.
 
-  We can add new handlers with `add_handler/4`. Calls can also
+  We can add new handlers with `add_handler/3`. Calls can also
   be made to specific handlers by using `call/3`.
 
   ## Callbacks
@@ -447,7 +447,7 @@ defmodule GenEvent do
 
   The return value `reply` is defined in the return value of `handle_call/2`.
   If the specified event handler is not installed, the function returns
-  `{:error, :handler_not_found}`.
+  `{:error, :not_found}`.
   """
   @spec call(manager, handler, term, timeout) ::  term | {:error, term}
   def call(manager, handler, request, timeout \\ 5000) do
@@ -466,7 +466,7 @@ defmodule GenEvent do
 
   The event manager will call `terminate/2` to terminate the event handler
   and return the callback value. If the specified event handler is not
-  installed, the function returns `{:error, :handler_not_found}`.
+  installed, the function returns `{:error, :not_found}`.
   """
   @spec remove_handler(manager, handler, term) :: term | {:error, term}
   def remove_handler(manager, handler, args) do
@@ -894,7 +894,7 @@ defmodule GenEvent do
   defp server_call(module, query, handlers, name) do
     case :lists.keyfind(module, handler(:id) + 1, handlers) do
       false ->
-        {false, {:error, :handler_not_found}, handlers}
+        {false, {:error, :not_found}, handlers}
       handler ->
         case server_call_update(handler, query, name, handlers) do
           {{hib, handler}, reply} ->
@@ -1016,7 +1016,7 @@ defmodule GenEvent do
       {:value, handler, handlers} ->
         {do_terminate(handler, args, last_in, name, reason), handlers}
       false ->
-        {{:error, :handler_not_found}, handlers}
+        {{:error, :not_found}, handlers}
     end
   end
 

lib/elixir/test/elixir/gen_event/stream_test.exs

@@ -147,8 +147,8 @@ defmodule GenEvent.StreamTest do
     Process.flag(:trap_exit, true)
     Process.exit(pid, :kill)
     assert_receive {:EXIT, ^pid, :killed}, @receive_timeout
-    assert_receive {:EXIT, ^child,
-                     {:killed, {Enumerable.GenEvent.Stream, :stop, [_,_]}}}, @receive_timeout
+    assert_receive ({:EXIT, ^child, {stat, {Enumerable.GenEvent.Stream, :stop, [_,_]}}}
+                     when stat in [:killed, :noproc]), @receive_timeout
   end
 
   test "stream/2 with manager not alive" do

lib/elixir/test/elixir/gen_event_test.exs

@@ -18,8 +18,8 @@ defmodule GenEventTest do
       raise "oops"
     end
 
-    def init({:swap, {:error, :handler_not_found}}) do
-      {:error, :handler_not_found_on_swap}
+    def init({:swap, {:error, :not_found}}) do
+      {:error, :not_found_on_swap}
     end
 
     def init({:swap, parent}) when is_pid(parent) do
@@ -291,15 +291,15 @@ defmodule GenEventTest do
     GenEvent.add_mon_handler(pid, ReplyHandler, {self(), false})
 
     assert GenEvent.remove_handler(pid, {ReplyHandler, self()}, :ok) ==
-           {:error, :handler_not_found}
+           {:error, :not_found}
     assert GenEvent.remove_handler(pid, ReplyHandler, :ok) ==
            {:terminate, :ok}
     assert_receive {:terminate, :ok}
 
     GenEvent.add_mon_handler(pid, {ReplyHandler, self()}, {self(), false})
 
     assert GenEvent.remove_handler(pid, ReplyHandler, :ok) ==
-           {:error, :handler_not_found}
+           {:error, :not_found}
     assert {:error, {%RuntimeError{}, _}} =
            GenEvent.remove_handler(pid, {ReplyHandler, self()}, :raise)
 
@@ -326,7 +326,7 @@ defmodule GenEventTest do
     # The handler is initialized even when the module does not exist
     # on swap. However, in this case, we are returning an error on init.
     assert GenEvent.swap_handler(pid, ReplyHandler, :swapped, ReplyHandler, :swap) ==
-           {:error, :handler_not_found_on_swap}
+           {:error, :not_found_on_swap}
   end
 
   test "notify/2" do
@@ -475,7 +475,7 @@ defmodule GenEventTest do
 
     assert GenEvent.add_handler(pid, DefaultHandler, []) == :ok
     assert GenEvent.call(pid, UnknownHandler, :messages) ==
-            {:error, :handler_not_found}
+            {:error, :not_found}
     assert GenEvent.call(pid, DefaultHandler, :whatever) ==
             {:error, {:bad_call, :whatever}}
     assert GenEvent.which_handlers(pid) == []

lib/ex_unit/lib/ex_unit/assertions.ex

@@ -273,19 +273,31 @@ defmodule ExUnit.Assertions do
 
   defp do_assert_receive(expected, timeout, message) do
     binary = Macro.to_string(expected)
-    message = message || "No message matching #{binary}"
+
+    pattern =
+      case expected do
+        {:when, meta, [left, right]} ->
+          {:when, meta, [quote(do: unquote(left) = received), right]}
+        left ->
+          quote(do: unquote(left) = received)
+      end
 
     {:receive, meta, args} =
       quote do
         receive do
-          unquote(expected) = received -> received
+          unquote(pattern) ->
+            received
         after
-          unquote(timeout) ->
-            flunk(unquote(message) <> ExUnit.Assertions.__mailbox__(self()))
+          timeout ->
+            message = unquote(message) || "No message matching #{unquote(binary)} after #{timeout}ms"
+            flunk(message <> ExUnit.Assertions.__mailbox__(self()))
         end
       end
 
-    {:receive, [{:export_head, true}|meta], args}
+    quote do
+      timeout = unquote(timeout)
+      unquote({:receive, [{:export_head, true}|meta], args})
+    end
   end
 
   @max_mailbox_length 10

lib/ex_unit/test/ex_unit/assertions_test.exs

@@ -91,7 +91,7 @@ defmodule ExUnit.AssertionsTest do
       "This should never be tested" = assert_received :hello
     rescue
       error in [ExUnit.AssertionError] ->
-        "No message matching :hello. The process mailbox is empty." = error.message
+        "No message matching :hello after 0ms. The process mailbox is empty." = error.message
     end
   end
 
@@ -101,17 +101,17 @@ defmodule ExUnit.AssertionsTest do
       "This should never be tested" = assert_received :hello
     rescue
       error in [ExUnit.AssertionError] ->
-        "No message matching :hello. Process mailbox:\n{:message, :not_expected, :at_all}" = error.message
+        "No message matching :hello after 0ms. Process mailbox:\n{:message, :not_expected, :at_all}" = error.message
     end
   end
 
   test "assert received when different message having more than 10 on mailbox" do
     for i <- 1..11, do: send(self, {:message, i})
     try do
-      "This should never be tested" = assert_received :hello
+      "This should never be tested" = assert_received x when x == :hello
     rescue
       error in [ExUnit.AssertionError] ->
-        "No message matching :hello. Process mailbox:\n" <>
+        "No message matching x when x == :hello after 0ms. Process mailbox:\n" <>
         "{:message, 1}\n{:message, 2}\n{:message, 3}\n{:message, 4}\n" <>
         "{:message, 5}\n{:message, 6}\n{:message, 7}\n{:message, 8}\n" <>
         "{:message, 9}\n{:message, 10}\nShowing only 10 of 11 messages." = error.message

lib/logger/test/logger_test.exs

@@ -34,7 +34,7 @@ defmodule LoggerTest do
     assert :ok = Logger.remove_backend(:console)
     assert Application.get_env(:logger, :backends) == []
     assert Logger.remove_backend(:console) ==
-           {:error, :handler_not_found}
+           {:error, :not_found}
 
     assert capture_log(fn ->
       assert Logger.debug("hello", []) == :ok