diff --git a/lib/elixir/test/elixir/task/supervisor_test.exs b/lib/elixir/test/elixir/task/supervisor_test.exs index 20896deb948..8d9a0d7b08b 100644 --- a/lib/elixir/test/elixir/task/supervisor_test.exs +++ b/lib/elixir/test/elixir/task/supervisor_test.exs @@ -1,4 +1,4 @@ -Code.require_file "../test_helper.exs", __DIR__ +Code.require_file("../test_helper.exs", __DIR__) defmodule Task.SupervisorTest do use ExUnit.Case @@ -12,9 +12,9 @@ defmodule Task.SupervisorTest do end def wait_and_send(caller, atom) do - send caller, :ready + send(caller, :ready) receive do: (true -> true) - send caller, atom + send(caller, atom) end def sleep(number) do @@ -36,8 +36,10 @@ defmodule Task.SupervisorTest do end test "can be supervised directly", config do - assert {:ok, _} = - Supervisor.start_link([{Task.Supervisor, name: config.test}], strategy: :one_for_one) + modules = [{Task.Supervisor, name: config.test}] + + assert {:ok, _} = Supervisor.start_link(modules, strategy: :one_for_one) + assert Process.whereis(config.test) end @@ -50,8 +52,8 @@ defmodule Task.SupervisorTest do # Assert the struct assert task.__struct__ == Task - assert is_pid task.pid - assert is_reference task.ref + assert is_pid(task.pid) + assert is_reference(task.ref) # Assert the link {:links, links} = Process.info(self(), :links) @@ -64,7 +66,7 @@ defmodule Task.SupervisorTest do assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(task.pid) # Run the task - send task.pid, true + send(task.pid, true) # Assert response and monitoring messages ref = task.ref @@ -79,7 +81,7 @@ defmodule Task.SupervisorTest do receive do: (:ready -> :ok) assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(task.pid) - send task.pid, true + send(task.pid, true) assert task.__struct__ == Task assert Task.await(task) == :done end @@ -93,8 +95,8 @@ defmodule Task.SupervisorTest do # Assert the struct assert task.__struct__ == Task - assert is_pid task.pid - assert is_reference task.ref + assert is_pid(task.pid) + assert is_reference(task.ref) # Refute the link {:links, links} = Process.info(self(), :links) @@ -107,7 +109,7 @@ defmodule Task.SupervisorTest do assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(task.pid) # Run the task - send task.pid, true + send(task.pid, true) # Assert response and monitoring messages ref = task.ref @@ -116,13 +118,18 @@ defmodule Task.SupervisorTest do end test "async_nolink/3", config do - task = Task.Supervisor.async_nolink(config[:supervisor], __MODULE__, :wait_and_send, [self(), :done]) + task = + Task.Supervisor.async_nolink(config[:supervisor], __MODULE__, :wait_and_send, [ + self(), + :done + ]) + assert Task.Supervisor.children(config[:supervisor]) == [task.pid] receive do: (:ready -> :ok) assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(task.pid) - send task.pid, true + send(task.pid, true) assert task.__struct__ == Task assert Task.await(task) == :done end @@ -140,12 +147,14 @@ defmodule Task.SupervisorTest do {:name, fun_name} = :erlang.fun_info(fun, :name) assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(pid) - send pid, true + send(pid, true) assert_receive :done end test "start_child/3", config do - {:ok, pid} = Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, [self(), :done]) + {:ok, pid} = + Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, [self(), :done]) + assert Task.Supervisor.children(config[:supervisor]) == [pid] {:links, links} = Process.info(self(), :links) @@ -154,7 +163,7 @@ defmodule Task.SupervisorTest do receive do: (:ready -> :ok) assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(pid) - send pid, true + send(pid, true) assert_receive :done assert_raise FunctionClauseError, fn -> @@ -162,12 +171,17 @@ defmodule Task.SupervisorTest do end assert_raise FunctionClauseError, fn -> - Task.Supervisor.start_child(config[:supervisor], __MODULE__, "wait_and_send", [self(), :done]) + Task.Supervisor.start_child(config[:supervisor], __MODULE__, "wait_and_send", [ + self(), + :done + ]) end end test "terminate_child/2", config do - {:ok, pid} = Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, [self(), :done]) + {:ok, pid} = + Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, [self(), :done]) + assert Task.Supervisor.children(config[:supervisor]) == [pid] assert Task.Supervisor.terminate_child(config[:supervisor], pid) == :ok assert Task.Supervisor.children(config[:supervisor]) == [] @@ -177,23 +191,22 @@ defmodule Task.SupervisorTest do describe "await/1" do test "exits on task throw", config do Process.flag(:trap_exit, true) - task = Task.Supervisor.async(config[:supervisor], fn -> throw :unknown end) + task = Task.Supervisor.async(config[:supervisor], fn -> throw(:unknown) end) + assert {{{:nocatch, :unknown}, _}, {Task, :await, [^task, 5000]}} = - catch_exit(Task.await(task)) + catch_exit(Task.await(task)) end test "exits on task error", config do Process.flag(:trap_exit, true) task = Task.Supervisor.async(config[:supervisor], fn -> raise "oops" end) - assert {{%RuntimeError{}, _}, {Task, :await, [^task, 5000]}} = - catch_exit(Task.await(task)) + assert {{%RuntimeError{}, _}, {Task, :await, [^task, 5000]}} = catch_exit(Task.await(task)) end test "exits on task exit", config do Process.flag(:trap_exit, true) - task = Task.Supervisor.async(config[:supervisor], fn -> exit :unknown end) - assert {:unknown, {Task, :await, [^task, 5000]}} = - catch_exit(Task.await(task)) + task = Task.Supervisor.async(config[:supervisor], fn -> exit(:unknown) end) + assert {:unknown, {Task, :await, [^task, 5000]}} = catch_exit(Task.await(task)) end end @@ -202,54 +215,60 @@ defmodule Task.SupervisorTest do test "streams an enumerable with fun", %{supervisor: supervisor} do assert supervisor |> Task.Supervisor.async_stream(1..4, &sleep/1, @opts) - |> Enum.to_list == - [ok: 1, ok: 2, ok: 3, ok: 4] + |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4] end test "streams an enumerable with mfa", %{supervisor: supervisor} do assert supervisor |> Task.Supervisor.async_stream(1..4, __MODULE__, :sleep, [], @opts) - |> Enum.to_list == - [ok: 1, ok: 2, ok: 3, ok: 4] + |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4] end test "streams an enumerable without leaking tasks", %{supervisor: supervisor} do assert supervisor |> Task.Supervisor.async_stream(1..4, &sleep/1, @opts) - |> Enum.to_list == - [ok: 1, ok: 2, ok: 3, ok: 4] + |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4] + refute_received _ end test "streams an enumerable with slowest first", %{supervisor: supervisor} do Process.flag(:trap_exit, true) + assert supervisor |> Task.Supervisor.async_stream(4..1, &sleep/1, @opts) - |> Enum.to_list == - [ok: 4, ok: 3, ok: 2, ok: 1] + |> Enum.to_list() == [ok: 4, ok: 3, ok: 2, ok: 1] end test "streams an enumerable with exits", %{supervisor: supervisor} do Process.flag(:trap_exit, true) + assert supervisor |> Task.Supervisor.async_stream(1..4, &exit(Integer.to_string(&1)), @opts) - |> Enum.to_list == - [exit: "1", exit: "2", exit: "3", exit: "4"] + |> Enum.to_list() == [exit: "1", exit: "2", exit: "3", exit: "4"] end test "shuts down unused tasks", %{supervisor: supervisor} do assert supervisor - |> Task.Supervisor.async_stream([0, :infinity, :infinity, :infinity], &sleep/1, @opts) - |> Enum.take(1) == - [ok: 0] + |> Task.Supervisor.async_stream( + [0, :infinity, :infinity, :infinity], + &sleep/1, + @opts + ) + |> Enum.take(1) == [ok: 0] + assert Process.info(self(), :links) == {:links, [supervisor]} end test "shuts down unused tasks without leaking messages", %{supervisor: supervisor} do assert supervisor - |> Task.Supervisor.async_stream([0, :infinity, :infinity, :infinity], &sleep/1, @opts) - |> Enum.take(1) == - [ok: 0] + |> Task.Supervisor.async_stream( + [0, :infinity, :infinity, :infinity], + &sleep/1, + @opts + ) + |> Enum.take(1) == [ok: 0] + refute_received _ end @@ -258,50 +277,63 @@ defmodule Task.SupervisorTest do assert fn i -> if rem(i, 2) == 0, do: supervisor, else: other_supervisor end |> Task.Supervisor.async_stream(1..4, &sleep_and_return_ancestor/1, @opts) - |> Enum.to_list == - [ok: other_supervisor, ok: supervisor, ok: other_supervisor, ok: supervisor] + |> Enum.to_list() == + [ok: other_supervisor, ok: supervisor, ok: other_supervisor, ok: supervisor] end test "streams an enumerable with mfa and supervisor fun", %{supervisor: supervisor} do {:ok, other_supervisor} = Task.Supervisor.start_link() assert fn i -> if rem(i, 2) == 0, do: supervisor, else: other_supervisor end - |> Task.Supervisor.async_stream(1..4, __MODULE__, :sleep_and_return_ancestor, [], @opts) - |> Enum.to_list == - [ok: other_supervisor, ok: supervisor, ok: other_supervisor, ok: supervisor] + |> Task.Supervisor.async_stream( + 1..4, + __MODULE__, + :sleep_and_return_ancestor, + [], + @opts + ) + |> Enum.to_list() == + [ok: other_supervisor, ok: supervisor, ok: other_supervisor, ok: supervisor] end test "streams an enumerable with mfa with args and supervisor fun", %{supervisor: supervisor} do {:ok, other_supervisor} = Task.Supervisor.start_link() assert fn i -> if rem(i, 2) == 0, do: supervisor, else: other_supervisor end - |> Task.Supervisor.async_stream(1..4, __MODULE__, :sleep_and_return_ancestor, [:another_arg], @opts) - |> Enum.to_list == - [ok: other_supervisor, ok: supervisor, ok: other_supervisor, ok: supervisor] + |> Task.Supervisor.async_stream( + 1..4, + __MODULE__, + :sleep_and_return_ancestor, + [:another_arg], + @opts + ) + |> Enum.to_list() == + [ok: other_supervisor, ok: supervisor, ok: other_supervisor, ok: supervisor] end - test "streams an enumerable with fun and executes supervisor fun in monitor process", %{supervisor: supervisor} do + test "streams an enumerable with fun and executes supervisor fun in monitor process", %{ + supervisor: supervisor + } do parent = self() supervisor_fun = fn _i -> {:links, links} = Process.info(self(), :links) assert parent in links - send parent, {parent, self()} + send(parent, {parent, self()}) supervisor end assert supervisor_fun |> Task.Supervisor.async_stream(1..4, &sleep_and_return_ancestor/1, @opts) - |> Enum.to_list == - [ok: supervisor, ok: supervisor, ok: supervisor, ok: supervisor] + |> Enum.to_list() == [ok: supervisor, ok: supervisor, ok: supervisor, ok: supervisor] receive do {^parent, linked} -> - for _ <- 1..3, do: assert_received {^parent, ^linked} + for _ <- 1..3, do: assert_received({^parent, ^linked}) after 0 -> - flunk "Did not receive any message from monitor process." + flunk("Did not receive any message from monitor process.") end end @@ -309,16 +341,20 @@ defmodule Task.SupervisorTest do Process.flag(:trap_exit, true) assert {{%RuntimeError{message: "bad"}, _stacktrace}, _mfa} = - catch_exit fn _i -> raise "bad" end - |> Task.Supervisor.async_stream(1..4, &sleep_and_return_ancestor/1, @opts) - |> Stream.run() + catch_exit( + fn _i -> raise "bad" end + |> Task.Supervisor.async_stream(1..4, &sleep_and_return_ancestor/1, @opts) + |> Stream.run() + ) refute_received _ assert {{:noproc, _stacktrace}, _mfa} = - catch_exit fn _i -> :not_a_supervisor end - |> Task.Supervisor.async_stream(1..4, &sleep_and_return_ancestor/1, @opts) - |> Stream.run() + catch_exit( + fn _i -> :not_a_supervisor end + |> Task.Supervisor.async_stream(1..4, &sleep_and_return_ancestor/1, @opts) + |> Stream.run() + ) refute_received _ end @@ -330,52 +366,56 @@ defmodule Task.SupervisorTest do test "streams an enumerable with fun", %{supervisor: supervisor} do assert supervisor |> Task.Supervisor.async_stream_nolink(1..4, &sleep/1, @opts) - |> Enum.to_list == - [ok: 1, ok: 2, ok: 3, ok: 4] + |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4] end test "streams an enumerable with mfa", %{supervisor: supervisor} do assert supervisor |> Task.Supervisor.async_stream_nolink(1..4, __MODULE__, :sleep, [], @opts) - |> Enum.to_list == - [ok: 1, ok: 2, ok: 3, ok: 4] + |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4] end test "streams an enumerable without leaking tasks", %{supervisor: supervisor} do assert supervisor |> Task.Supervisor.async_stream_nolink(1..4, &sleep/1, @opts) - |> Enum.to_list == - [ok: 1, ok: 2, ok: 3, ok: 4] + |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4] + refute_received _ end test "streams an enumerable with slowest first", %{supervisor: supervisor} do assert supervisor |> Task.Supervisor.async_stream_nolink(4..1, &sleep/1, @opts) - |> Enum.to_list == - [ok: 4, ok: 3, ok: 2, ok: 1] + |> Enum.to_list() == [ok: 4, ok: 3, ok: 2, ok: 1] end test "streams an enumerable with exits", %{supervisor: supervisor} do assert supervisor |> Task.Supervisor.async_stream_nolink(1..4, &exit/1, @opts) - |> Enum.to_list == - [exit: 1, exit: 2, exit: 3, exit: 4] + |> Enum.to_list() == [exit: 1, exit: 2, exit: 3, exit: 4] end test "shuts down unused tasks", %{supervisor: supervisor} do assert supervisor - |> Task.Supervisor.async_stream_nolink([0, :infinity, :infinity, :infinity], &sleep/1, @opts) - |> Enum.take(1) == - [ok: 0] + |> Task.Supervisor.async_stream_nolink( + [0, :infinity, :infinity, :infinity], + &sleep/1, + @opts + ) + |> Enum.take(1) == [ok: 0] + assert Process.info(self(), :links) == {:links, [supervisor]} end test "shuts down unused tasks without leaking messages", %{supervisor: supervisor} do assert supervisor - |> Task.Supervisor.async_stream_nolink([0, :infinity, :infinity, :infinity], &sleep/1, @opts) - |> Enum.take(1) == - [ok: 0] + |> Task.Supervisor.async_stream_nolink( + [0, :infinity, :infinity, :infinity], + &sleep/1, + @opts + ) + |> Enum.take(1) == [ok: 0] + refute_received _ end end