Fix test_supervisor:try_again_restart/0 test

Test was flappy but in fact it was succeeding because of a race condition.
If intensity if 5, supervisor should not have 5 restarts in its children or
will shut down. Make test more robust using monitors and add a new test to
assert the number of restarts that cause a shutdown.

Signed-off-by: Paul Guyot <pguyot@kallisys.net>

Author: pguyot

tests/libs/estdlib/test_supervisor.erl

@@ -38,6 +38,7 @@ test() ->
     ok = test_one_for_all(),
     ok = test_crash_limits(),
     ok = try_again_restart(),
+    ok = try_again_restart4(),
     ok.
 
 test_basic_supervisor() ->
@@ -603,24 +604,45 @@ try_again_restart() ->
     process_flag(trap_exit, true),
 
     %% Intensity is 5, use the arbitrator to prevent the child from restarting
-    %% 4 times. This should not exit the supervisor due to intensity.
-    Arbitrator1 = erlang:spawn(fun() -> arbitrator_start(4) end),
+    %% 3 times. With the other child, we'll have 4 restarts, and this should not
+    % exit the supervisor due to intensity.
+    Arbitrator1 = erlang:spawn(fun() -> arbitrator_start(3) end),
     {ok, SupPid1} = supervisor:start_link(
         {local, try_again_test1}, ?MODULE, {test_try_again, Arbitrator1, self()}
     ),
     ChildPid = wait_child_pid("ChildPid"),
 
+    ChildMonitor = monitor(process, ChildPid),
     ChildPid ! stop,
-    ChildPid1 = wait_child_pid("ChildPid1"),
+    normal =
+        receive
+            {'DOWN', ChildMonitor, process, ChildPid, ChildReason} -> ChildReason
+        after 5000 -> timeout
+        end,
 
+    ChildPid1 = wait_child_pid("ChildPid1"),
+    ChildMonitor1 = monitor(process, ChildPid1),
     ChildPid1 ! stop,
+    normal =
+        receive
+            {'DOWN', ChildMonitor1, process, ChildPid1, ChildReason1} -> ChildReason1
+        after 5000 -> timeout
+        end,
+
+    ArbitratorMonitor1 = monitor(process, Arbitrator1),
     Arbitrator1 ! shutdown,
+    normal =
+        receive
+            {'DOWN', ArbitratorMonitor1, process, Arbitrator1, ArbitratorReason1} ->
+                ArbitratorReason1
+        after 5000 -> timeout
+        end,
     exit(SupPid1, normal),
-    ok =
+    normal =
         receive
-            {'EXIT', SupPid1, normal} ->
-                ok
-        after 2000 ->
+            {'EXIT', SupPid1, Reason} ->
+                Reason
+        after 5000 ->
             error({supervisor_not_stopped, normal})
         end,
 
@@ -633,11 +655,18 @@ try_again_restart() ->
     ),
     ChildPid2 = wait_child_pid("ChildPid2"),
 
+    ChildMonitor2 = monitor(process, ChildPid2),
     ChildPid2 ! stop,
-    ok =
+    normal =
         receive
-            {'EXIT', SupPid2, shutdown} ->
-                ok
+            {'DOWN', ChildMonitor2, process, ChildPid2, ChildReason2} -> ChildReason2
+        after 5000 -> timeout
+        end,
+
+    shutdown =
+        receive
+            {'EXIT', SupPid2, ShutdownReason} ->
+                ShutdownReason
         after 2000 ->
             error({supervisor_not_stopped, restart_try_again_exceeded})
         end,
@@ -677,6 +706,54 @@ try_again_restart() ->
     process_flag(trap_exit, false),
     ok.
 
+try_again_restart4() ->
+    process_flag(trap_exit, true),
+
+    %% Intensity is 5, use the arbitrator to prevent the child from restarting
+    %% 4 times. With the other child, we'll have 4 restarts, so the supervisor
+    %% will shutdown due to intensity
+    Arbitrator1 = erlang:spawn(fun() -> arbitrator_start(4) end),
+    {ok, SupPid1} = supervisor:start_link(
+        {local, try_again_test1}, ?MODULE, {test_try_again, Arbitrator1, self()}
+    ),
+    ChildPid = wait_child_pid("ChildPid"),
+
+    ChildMonitor = monitor(process, ChildPid),
+    ChildPid ! stop,
+    normal =
+        receive
+            {'DOWN', ChildMonitor, process, ChildPid, ChildReason} -> ChildReason
+        after 5000 -> timeout
+        end,
+
+    ChildPid1 = wait_child_pid("ChildPid1"),
+    ChildMonitor1 = monitor(process, ChildPid1),
+    ChildPid1 ! stop,
+    normal =
+        receive
+            {'DOWN', ChildMonitor1, process, ChildPid1, ChildReason1} -> ChildReason1
+        after 5000 -> timeout
+        end,
+
+    ArbitratorMonitor1 = monitor(process, Arbitrator1),
+    Arbitrator1 ! shutdown,
+    normal =
+        receive
+            {'DOWN', ArbitratorMonitor1, process, Arbitrator1, ArbitratorReason1} ->
+                ArbitratorReason1
+        after 5000 -> timeout
+        end,
+    shutdown =
+        receive
+            {'EXIT', SupPid1, Reason} ->
+                Reason
+        after 5000 ->
+            error({supervisor_not_stopped, normal})
+        end,
+
+    process_flag(trap_exit, false),
+    ok.
+
 wait_child_pid(Name) ->
     receive
         Pid when is_pid(Pid) ->