aboutsummaryrefslogtreecommitdiffstats
path: root/erts
diff options
context:
space:
mode:
authorMicael Karlberg <[email protected]>2018-10-29 14:58:53 +0100
committerMicael Karlberg <[email protected]>2018-10-29 14:58:53 +0100
commitf8ce6043ff330a34644f03f5589c33ad7e57bfab (patch)
treec6c9d6a084c156231d4082c4d0fc0edfce88ec89 /erts
parent944c0714c9342c4b72fc4433448058db4cb7861f (diff)
downloadotp-f8ce6043ff330a34644f03f5589c33ad7e57bfab.tar.gz
otp-f8ce6043ff330a34644f03f5589c33ad7e57bfab.tar.bz2
otp-f8ce6043ff330a34644f03f5589c33ad7e57bfab.zip
[socket-nif|test] All test cases now using evaluator module
All test cases has been updated using the new evaluator module (and their macros). OTP-14831
Diffstat (limited to 'erts')
-rw-r--r--erts/emulator/test/socket_SUITE.erl1490
-rw-r--r--erts/emulator/test/socket_test_evaluator.erl68
-rw-r--r--erts/emulator/test/socket_test_evaluator.hrl24
3 files changed, 669 insertions, 913 deletions
diff --git a/erts/emulator/test/socket_SUITE.erl b/erts/emulator/test/socket_SUITE.erl
index f4b8d94346..208d8037fb 100644
--- a/erts/emulator/test/socket_SUITE.erl
+++ b/erts/emulator/test/socket_SUITE.erl
@@ -253,7 +253,7 @@ sc_rc_cases() ->
%% traffic_cases() ->
-%% [].
+%% [snr_send_and_recv_chunks].
%% ticket_cases() ->
@@ -413,7 +413,7 @@ api_b_open_and_close(InitState) ->
end},
%% *** We are done ***
- ?FINISH_NORMAL
+ ?SEV_FINISH_NORMAL
],
Evaluator = ?SEV_START("tester", Seq, InitState),
ok = ?SEV_AWAIT_FINISH([Evaluator]).
@@ -555,7 +555,7 @@ api_b_send_and_recv_udp(InitState) ->
end},
%% *** We are done ***
- ?FINISH_NORMAL
+ ?SEV_FINISH_NORMAL
],
Evaluator = ?SEV_START("tester", Seq, InitState),
ok = ?SEV_AWAIT_FINISH([Evaluator]).
@@ -681,7 +681,7 @@ api_b_send_and_recv_tcp(InitState) ->
cmd => fun(#{lsock := LSock} = State) ->
case socket:accept(LSock) of
{ok, Sock} ->
- ei("accepted: ~n ~p", [Sock]),
+ ?SEV_IPRINT("accepted: ~n ~p", [Sock]),
{ok, State#{csock => Sock}};
{error, _} = ERROR ->
ERROR
@@ -740,7 +740,7 @@ api_b_send_and_recv_tcp(InitState) ->
end},
%% *** We are done ***
- ?FINISH_NORMAL
+ ?SEV_FINISH_NORMAL
],
ClientSeq =
@@ -844,7 +844,7 @@ api_b_send_and_recv_tcp(InitState) ->
end},
%% *** We are done ***
- ?FINISH_NORMAL
+ ?SEV_FINISH_NORMAL
],
TesterSeq =
@@ -962,7 +962,7 @@ api_b_send_and_recv_tcp(InitState) ->
end},
%% *** We are done ***
- ?FINISH_NORMAL
+ ?SEV_FINISH_NORMAL
],
i("start server evaluator"),
@@ -1239,15 +1239,15 @@ api_opt_simple_otp_options() ->
i("start tcp (stream) evaluator"),
InitState1 = #{domain => inet, type => stream, protocol => tcp},
- Tester1 = evaluator_start("tcp-tester", Seq, InitState1),
+ Tester1 = ?SEV_START("tcp-tester", Seq, InitState1),
i("await tcp evaluator"),
- ok = await_evaluator_finish([Tester1]),
+ ok = ?SEV_AWAIT_FINISH([Tester1]),
i("start udp (dgram) socket"),
InitState2 = #{domain => inet, type => dgram, protocol => udp},
- Tester2 = evaluator_start("udp-tester", Seq, InitState2),
+ Tester2 = ?SEV_START("udp-tester", Seq, InitState2),
i("await udp evaluator"),
- ok = await_evaluator_finish([Tester2]).
+ ok = ?SEV_AWAIT_FINISH([Tester2]).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -1275,12 +1275,7 @@ api_opt_simple_otp_controlling_process() ->
%% *** Init part ***
#{desc => "await start",
cmd => fun(State) ->
- %% receive
- %% {start, Tester, Socket} ->
- %% {ok, State#{tester => Tester,
- %% sock => Socket}}
- %% end
- {Tester, Sock} = ev_await_start(),
+ {Tester, Sock} = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester,
sock => Sock}}
end},
@@ -1315,13 +1310,12 @@ api_opt_simple_otp_controlling_process() ->
end},
#{desc => "announce ready (not owner)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_ready(Tester, not_owner),
- %% Tester ! {ready, self()},
+ ?SEV_ANNOUNCE_READY(Tester, not_owner),
ok
end},
#{desc => "await continue (owner)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_await_continue(Tester, tester, owner)
+ ?SEV_AWAIT_CONTINUE(Tester, tester, owner)
end},
#{desc => "verify self as controlling-process",
cmd => fun(#{sock := Sock} = _State) ->
@@ -1352,8 +1346,7 @@ api_opt_simple_otp_controlling_process() ->
end},
#{desc => "announce ready (owner)",
cmd => fun(#{tester := Tester} = _State) ->
- %% Tester ! {ready, self()},
- ev_ready(Tester, owner),
+ ?SEV_ANNOUNCE_READY(Tester, owner),
ok
end},
@@ -1361,23 +1354,14 @@ api_opt_simple_otp_controlling_process() ->
%% *** Termination ***
#{desc => "await termination",
cmd => fun(#{tester := Tester} = State) ->
- %% receive
- %% {terminate, Tester} ->
- %% State1 = maps:remove(tester, State),
- %% State2 = maps:remove(sock, State1),
- %% {ok, State2}
- %% end
- ev_await_terminate(Tester, tester),
+ ?SEV_AWAIT_TERMINATE(Tester, tester),
State1 = maps:remove(tester, State),
State2 = maps:remove(sock, State1),
{ok, State2}
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
TesterSeq =
@@ -1411,17 +1395,12 @@ api_opt_simple_otp_controlling_process() ->
end},
#{desc => "order (client) start",
cmd => fun(#{client := Client, sock := Sock} = _State) ->
- %% Client ! {start, self(), Sock},
- ev_start(Client, Sock),
+ ?SEV_ANNOUNCE_START(Client, Sock),
ok
end},
#{desc => "await (client) ready (not owner)",
cmd => fun(#{client := Client} = _State) ->
- %% receive
- %% {ready, Client} ->
- %% ok
- %% end
- ev_await_ready(Client, client, not_owner)
+ ?SEV_AWAIT_READY(Client, client, not_owner)
end},
#{desc => "attempt controlling-process transfer to client",
cmd => fun(#{client := Client, sock := Sock} = _State) ->
@@ -1451,17 +1430,12 @@ api_opt_simple_otp_controlling_process() ->
end},
#{desc => "order (client) continue (owner)",
cmd => fun(#{client := Client} = _State) ->
- %% Client ! {continue, self()},
- ev_continue(Client, owner),
+ ?SEV_ANNOUNCE_CONTINUE(Client, owner),
ok
end},
#{desc => "await (client) ready (2)",
cmd => fun(#{client := Client} = _State) ->
- %% receive
- %% {ready, Client} ->
- %% ok
- %% end
- ev_await_ready(Client, client, owner),
+ ?SEV_AWAIT_READY(Client, client, owner),
ok
end},
#{desc => "verify self as controlling-process",
@@ -1480,17 +1454,12 @@ api_opt_simple_otp_controlling_process() ->
%% *** Termination ***
#{desc => "order (client) terminate",
cmd => fun(#{client := Client} = _State) ->
- %% Client ! {terminate, self()},
- ev_terminate(Client),
+ ?SEV_ANNOUNCE_TERMINATE(Client),
ok
end},
#{desc => "await client termination",
cmd => fun(#{client := Client} = State) ->
- %% receive
- %% {'DOWN', _, process, Client, _} ->
- %% {ok, maps:remove(client, State)}
- %% end
- ev_await_termination(Client),
+ ?SEV_AWAIT_TERMINATION(Client),
{ok, maps:remove(client, State)}
end},
#{desc => "close socket",
@@ -1500,33 +1469,36 @@ api_opt_simple_otp_controlling_process() ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
- i("start tcp (stream) socket"),
+ i("start tcp (stream) client evaluator"),
ClientInitState1 = #{},
- Client1 = evaluator_start("tcp-client", ClientSeq, ClientInitState1),
+ Client1 = ?SEV_START("tcp-client", ClientSeq, ClientInitState1),
+
+ i("start tcp (stream) tester evaluator"),
TesterInitState1 = #{domain => inet,
type => stream,
protocol => tcp,
client => Client1#ev.pid},
- Tester1 = evaluator_start("tcp-tester", TesterSeq, TesterInitState1),
- i("await tcp evaluator"),
- ok = await_evaluator_finish([Tester1, Client1]),
+ Tester1 = ?SEV_START("tcp-tester", TesterSeq, TesterInitState1),
- i("start udp (dgram) socket"),
+ i("await tcp evaluator(s)"),
+ ok = ?SEV_AWAIT_FINISH([Tester1, Client1]),
+
+ i("start udp (dgram) client evaluator"),
ClientInitState2 = #{},
- Client2 = evaluator_start("udp-client", ClientSeq, ClientInitState2),
+ Client2 = ?SEV_START("udp-client", ClientSeq, ClientInitState2),
+
+ i("start udp (dgram) tester evaluator"),
TesterInitState2 = #{domain => inet,
type => dgram,
protocol => udp,
client => Client2#ev.pid},
- Tester2 = evaluator_start("udp-tester", TesterSeq, TesterInitState2),
- i("await udp evaluator"),
- ok = await_evaluator_finish([Tester2, Client2]).
+ Tester2 = ?SEV_START("udp-tester", TesterSeq, TesterInitState2),
+
+ i("await udp evaluator(s)"),
+ ok = ?SEV_AWAIT_FINISH([Tester2, Client2]).
@@ -1588,7 +1560,7 @@ api_to_connect_tcp(InitState) ->
%% *** Wait for start order part ***
#{desc => "await start (from tester)",
cmd => fun(State) ->
- Tester = ev_await_start(),
+ Tester = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester}}
end},
#{desc => "monitor tester",
@@ -1628,14 +1600,14 @@ api_to_connect_tcp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester, lport := Port}) ->
- ev_ready(Tester, init, Port),
+ ?SEV_ANNOUNCE_READY(Tester, init, Port),
ok
end},
%% Termination
#{desc => "await terminate",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -1651,10 +1623,7 @@ api_to_connect_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
TesterSeq =
@@ -1729,12 +1698,12 @@ api_to_connect_tcp(InitState) ->
%% *** Synchronize with the server ***
#{desc => "order server start",
cmd => fun(#{server := Server}) ->
- ev_start(Server),
+ ?SEV_ANNOUNCE_START(Server),
ok
end},
#{desc => "await server ready (init)",
cmd => fun(#{server := Server, local_sa := LSA} = State) ->
- {ok, Port} = ev_await_ready(Server, server, init),
+ {ok, Port} = ?SEV_AWAIT_READY(Server, server, init),
ServerSA = LSA#{port => Port},
{ok, State#{server_sa => ServerSA}}
end},
@@ -1753,12 +1722,12 @@ api_to_connect_tcp(InitState) ->
%% *** Terminate server ***
#{desc => "order (server) terminate",
cmd => fun(#{server := Server} = _State) ->
- ev_terminate(Server),
+ ?SEV_ANNOUNCE_TERMINATE(Server),
ok
end},
#{desc => "await (server) down",
cmd => fun(#{server := Server} = State) ->
- ev_await_termination(Server),
+ ?SEV_AWAIT_TERMINATION(Server),
State1 = maps:remove(server, State),
State2 = maps:remove(server_sa, State1),
{ok, State2}
@@ -1783,22 +1752,19 @@ api_to_connect_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
i("create server evaluator"),
ServerInitState = InitState,
- Server = evaluator_start("server", ServerSeq, ServerInitState),
+ Server = ?SEV_START("server", ServerSeq, ServerInitState),
i("create tester evaluator"),
TesterInitState = InitState#{server => Server#ev.pid},
- Tester = evaluator_start("tester", TesterSeq, TesterInitState),
+ Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
i("await evaluator(s)"),
- ok = await_evaluator_finish([Server, Tester]).
+ ok = ?SEV_AWAIT_FINISH([Server, Tester]).
api_to_connect_tcp_await_timeout(Socks, To, ServerSA) ->
@@ -1807,11 +1773,11 @@ api_to_connect_tcp_await_timeout(Socks, To, ServerSA) ->
api_to_connect_tcp_await_timeout([], _To, _ServerSA, _ID) ->
?FAIL(unexpected_success);
api_to_connect_tcp_await_timeout([Sock|Socks], To, ServerSA, ID) ->
- ei("~w: try connect", [ID]),
+ ?SEV_IPRINT("~w: try connect", [ID]),
Start = t(),
case socket:connect(Sock, ServerSA, To) of
{error, timeout} ->
- ei("expected timeout (~w)", [ID]),
+ ?SEV_IPRINT("expected timeout (~w)", [ID]),
Stop = t(),
TDiff = tdiff(Start, Stop),
if
@@ -1821,13 +1787,13 @@ api_to_connect_tcp_await_timeout([Sock|Socks], To, ServerSA, ID) ->
{error, {unexpected_timeout, TDiff, To}}
end;
{error, econnreset = Reason} ->
- ei("failed connecting: ~p - giving up", [Reason]),
+ ?SEV_IPRINT("failed connecting: ~p - giving up", [Reason]),
ok;
{error, Reason} ->
- ee("failed connecting: ~p", [Reason]),
+ ?SEV_EPRINT("failed connecting: ~p", [Reason]),
?FAIL({connect, Reason});
ok ->
- ei("unexpected success (~w) - try next", [ID]),
+ ?SEV_IPRINT("unexpected success (~w) - try next", [ID]),
api_to_connect_tcp_await_timeout(Socks, To, ServerSA, ID+1)
end.
@@ -1936,17 +1902,14 @@ api_to_accept_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
i("create tester evaluator"),
- Tester = evaluator_start("tester", TesterSeq, InitState),
+ Tester = ?SEV_START("tester", TesterSeq, InitState),
i("await evaluator"),
- ok = await_evaluator_finish([Tester]).
+ ok = ?SEV_AWAIT_FINISH([Tester]).
@@ -1994,7 +1957,7 @@ api_to_maccept_tcp(InitState) ->
%% *** Init part ***
#{desc => "await start",
cmd => fun(State) ->
- Tester = ev_await_start(),
+ Tester = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester}}
end},
#{desc => "monitor tester",
@@ -2032,14 +1995,14 @@ api_to_maccept_tcp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{lsock := LSock, tester := Tester}) ->
- ev_ready(Tester, init, LSock),
+ ?SEV_ANNOUNCE_READY(Tester, init, LSock),
ok
end},
%% *** The actual test ***
#{desc => "await continue (accept)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_await_continue(Tester, tester, accept)
+ ?SEV_AWAIT_CONTINUE(Tester, tester, accept)
end},
#{desc => "attempt to accept (without success)",
cmd => fun(#{lsock := LSock, timeout := To} = State) ->
@@ -2048,8 +2011,8 @@ api_to_maccept_tcp(InitState) ->
{error, timeout} ->
{ok, State#{start => Start, stop => t()}};
{ok, Sock} ->
- ee("Unexpected accept success: "
- "~n ~p", [Sock]),
+ ?SEV_EPRINT("Unexpected accept success: "
+ "~n ~p", [Sock]),
(catch socket:close(Sock)),
{error, unexpected_success};
{error, _} = ERROR ->
@@ -2068,14 +2031,14 @@ api_to_maccept_tcp(InitState) ->
end},
#{desc => "announce ready (accept)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, accept),
+ ?SEV_ANNOUNCE_READY(Tester, accept),
ok
end},
%% *** Terminate ***
#{desc => "await terminate",
cmd => fun(#{tester := Tester} = _State) ->
- ev_await_terminate(Tester, tester),
+ ?SEV_AWAIT_TERMINATE(Tester, tester),
ok
end},
%% *** Close (listen) socket ***
@@ -2086,10 +2049,7 @@ api_to_maccept_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
@@ -2098,7 +2058,7 @@ api_to_maccept_tcp(InitState) ->
%% *** Init part ***
#{desc => "await start",
cmd => fun(State) ->
- {Tester, LSock} = ev_await_start(),
+ {Tester, LSock} = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester,
lsock => LSock}}
@@ -2110,14 +2070,14 @@ api_to_maccept_tcp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_ready(Tester, init),
+ ?SEV_ANNOUNCE_READY(Tester, init),
ok
end},
%% *** The actual test part ***
#{desc => "await continue (accept)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_await_continue(Tester, tester, accept)
+ ?SEV_AWAIT_CONTINUE(Tester, tester, accept)
end},
#{desc => "attempt to accept (without success)",
cmd => fun(#{lsock := LSock, timeout := To} = State) ->
@@ -2146,14 +2106,14 @@ api_to_maccept_tcp(InitState) ->
end},
#{desc => "announce ready (accept)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_ready(Tester, accept),
+ ?SEV_ANNOUNCE_READY(Tester, accept),
ok
end},
%% *** Terminate ***
#{desc => "await terminate",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -2162,10 +2122,7 @@ api_to_maccept_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
@@ -2192,133 +2149,139 @@ api_to_maccept_tcp(InitState) ->
%% Start the prim-acceptor
#{desc => "start prim-acceptor",
cmd => fun(#{prim_acceptor := Pid} = _State) ->
- ev_start(Pid),
+ ?SEV_ANNOUNCE_START(Pid),
ok
end},
#{desc => "await prim-acceptor ready (init)",
cmd => fun(#{prim_acceptor := Pid} = State) ->
- {ok, Sock} = ev_await_ready(Pid, prim_acceptor, init),
+ {ok, Sock} = ?SEV_AWAIT_READY(Pid, prim_acceptor, init),
{ok, State#{lsock => Sock}}
end},
%% Start sec-acceptor-1
#{desc => "start sec-acceptor 1",
cmd => fun(#{sec_acceptor1 := Pid, lsock := LSock} = _State) ->
- ev_start(Pid, LSock),
+ ?SEV_ANNOUNCE_START(Pid, LSock),
ok
end},
#{desc => "await sec-acceptor 1 ready (init)",
cmd => fun(#{sec_acceptor1 := Pid} = _State) ->
- ev_await_ready(Pid, sec_acceptor1, init)
+ ?SEV_AWAIT_READY(Pid, sec_acceptor1, init)
end},
%% Start sec-acceptor-2
#{desc => "start sec-acceptor 2",
cmd => fun(#{sec_acceptor2 := Pid, lsock := LSock} = _State) ->
- ev_start(Pid, LSock),
+ ?SEV_ANNOUNCE_START(Pid, LSock),
ok
end},
#{desc => "await sec-acceptor 2 ready (init)",
cmd => fun(#{sec_acceptor2 := Pid} = _State) ->
- ev_await_ready(Pid, sec_acceptor2, init)
+ ?SEV_AWAIT_READY(Pid, sec_acceptor2, init)
end},
%% Activate the acceptor(s)
#{desc => "active prim-acceptor",
cmd => fun(#{prim_acceptor := Pid} = _State) ->
- ev_continue(Pid, accept),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
ok
end},
#{desc => "active sec-acceptor 1",
cmd => fun(#{sec_acceptor1 := Pid} = _State) ->
- ev_continue(Pid, accept),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
ok
end},
#{desc => "active sec-acceptor 2",
cmd => fun(#{sec_acceptor2 := Pid} = _State) ->
- ev_continue(Pid, accept),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
ok
end},
%% Await acceptor(s) completions
#{desc => "await prim-acceptor ready (accept)",
cmd => fun(#{prim_acceptor := Pid} = _State) ->
- ev_await_ready(Pid, prim_acceptor, accept)
+ ?SEV_AWAIT_READY(Pid, prim_acceptor, accept)
end},
#{desc => "await sec-acceptor 1 ready (accept)",
cmd => fun(#{sec_acceptor1 := Pid} = _State) ->
- ev_await_ready(Pid, sec_acceptor1, accept)
+ ?SEV_AWAIT_READY(Pid, sec_acceptor1, accept)
end},
#{desc => "await sec-acceptor 2 ready (accept)",
cmd => fun(#{sec_acceptor2 := Pid} = _State) ->
- ev_await_ready(Pid, sec_acceptor2, accept)
+ ?SEV_AWAIT_READY(Pid, sec_acceptor2, accept)
end},
%% Terminate
#{desc => "order prim-acceptor to terminate",
cmd => fun(#{prim_acceptor := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await prim-acceptor termination",
cmd => fun(#{prim_acceptor := Pid} = State) ->
- ev_await_termination(Pid),
- State1 = maps:remove(prim_acceptor, State),
- {ok, State1}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ State1 = maps:remove(prim_acceptor, State),
+ {ok, State1};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order sec-acceptor 1 to terminate",
cmd => fun(#{sec_acceptor1 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await sec-acceptor 1 termination",
cmd => fun(#{sec_acceptor1 := Pid} = State) ->
- ev_await_termination(Pid),
- State1 = maps:remove(sec_acceptor1, State),
- {ok, State1}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ State1 = maps:remove(sec_acceptor1, State),
+ {ok, State1};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order sec-acceptor 2 to terminate",
cmd => fun(#{sec_acceptor2 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await sec-acceptor 2 termination",
cmd => fun(#{sec_acceptor2 := Pid} = State) ->
- ev_await_termination(Pid),
- State1 = maps:remove(sec_acceptor2, State),
- {ok, State1}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ State1 = maps:remove(sec_acceptor2, State),
+ {ok, State1};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
i("create prim-acceptor evaluator"),
PrimAInitState = InitState,
- PrimAcceptor = evaluator_start("prim-acceptor",
- PrimAcceptorSeq, PrimAInitState),
+ PrimAcceptor = ?SEV_START("prim-acceptor", PrimAcceptorSeq, PrimAInitState),
i("create sec-acceptor 1 evaluator"),
SecAInitState1 = maps:remove(domain, InitState),
- SecAcceptor1 = evaluator_start("sec-acceptor-1",
- SecAcceptorSeq, SecAInitState1),
+ SecAcceptor1 = ?SEV_START("sec-acceptor-1", SecAcceptorSeq, SecAInitState1),
i("create sec-acceptor 2 evaluator"),
SecAInitState2 = SecAInitState1,
- SecAcceptor2 = evaluator_start("sec-acceptor-2",
- SecAcceptorSeq, SecAInitState2),
+ SecAcceptor2 = ?SEV_START("sec-acceptor-2", SecAcceptorSeq, SecAInitState2),
i("create tester evaluator"),
TesterInitState = #{prim_acceptor => PrimAcceptor#ev.pid,
sec_acceptor1 => SecAcceptor1#ev.pid,
sec_acceptor2 => SecAcceptor2#ev.pid},
- Tester = evaluator_start("tester", TesterSeq, TesterInitState),
+ Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
i("await evaluator(s)"),
- ok = await_evaluator_finish([PrimAcceptor, SecAcceptor1, SecAcceptor2, Tester]).
+ ok = ?SEV_AWAIT_FINISH([PrimAcceptor, SecAcceptor1, SecAcceptor2, Tester]).
@@ -2510,7 +2473,7 @@ api_to_receive_tcp(InitState) ->
%% *** Wait for start order ***
#{desc => "await start (from tester)",
cmd => fun(State) ->
- Tester = ev_await_start(),
+ Tester = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester}}
end},
#{desc => "monitor tester",
@@ -2550,14 +2513,14 @@ api_to_receive_tcp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester, lport := Port}) ->
- ev_ready(Tester, init, Port),
+ ?SEV_ANNOUNCE_READY(Tester, init, Port),
ok
end},
%% *** The actual test ***
#{desc => "await continue (accept and recv)",
cmd => fun(#{tester := Tester}) ->
- ev_await_continue(Tester, tester, accept_recv)
+ ?SEV_AWAIT_CONTINUE(Tester, tester, accept_recv)
end},
#{desc => "attempt accept",
cmd => fun(#{lsock := LSock} = State) ->
@@ -2594,15 +2557,14 @@ api_to_receive_tcp(InitState) ->
end},
#{desc => "announce ready (recv timeout success)",
cmd => fun(#{tester := Tester} = _State) ->
- %% ok
- ev_ready(Tester, accept_recv),
+ ?SEV_ANNOUNCE_READY(Tester, accept_recv),
ok
end},
%% *** Termination ***
#{desc => "await terminate",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -2621,10 +2583,7 @@ api_to_receive_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
ClientSeq =
@@ -2632,7 +2591,7 @@ api_to_receive_tcp(InitState) ->
%% *** Wait for start order part ***
#{desc => "await start (from tester)",
cmd => fun(State) ->
- {Tester, Port} = ev_await_start(),
+ {Tester, Port} = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester,
server_port => Port}}
end},
@@ -2671,14 +2630,14 @@ api_to_receive_tcp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_ready(Tester, init),
+ ?SEV_ANNOUNCE_READY(Tester, init),
ok
end},
%% *** The actual test ***
#{desc => "await continue (with connect)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_await_continue(Tester, tester, connect)
+ ?SEV_AWAIT_CONTINUE(Tester, tester, connect)
end},
#{desc => "connect",
cmd => fun(#{sock := Sock, server_sa := SSA}) ->
@@ -2689,7 +2648,7 @@ api_to_receive_tcp(InitState) ->
%% *** Termination ***
#{desc => "await terminate",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -2703,10 +2662,7 @@ api_to_receive_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
TesterSeq =
@@ -2726,90 +2682,95 @@ api_to_receive_tcp(InitState) ->
%% *** Activate server ***
#{desc => "start server",
cmd => fun(#{server := Server} = _State) ->
- ev_start(Server),
+ ?SEV_ANNOUNCE_START(Server),
ok
end},
#{desc => "await server ready (init)",
cmd => fun(#{server := Server} = State) ->
- {ok, Port} = ev_await_ready(Server, server, init),
+ {ok, Port} = ?SEV_AWAIT_READY(Server, server, init),
{ok, State#{server_port => Port}}
end},
#{desc => "order server to continue (with accept)",
cmd => fun(#{server := Server} = _State) ->
- ev_continue(Server, accept_recv),
+ ?SEV_ANNOUNCE_CONTINUE(Server, accept_recv),
ok
end},
%% *** Activate client ***
#{desc => "start client",
cmd => fun(#{client := Client, server_port := Port} = _State) ->
- ev_start(Client, Port),
+ ?SEV_ANNOUNCE_START(Client, Port),
ok
end},
#{desc => "await client ready (init)",
cmd => fun(#{client := Client} = _State) ->
- ev_await_ready(Client, client, init)
+ ?SEV_AWAIT_READY(Client, client, init)
end},
%% *** The actual test ***
#{desc => "order client to continue (with connect)",
cmd => fun(#{client := Client} = _State) ->
- ev_continue(Client, connect),
+ ?SEV_ANNOUNCE_CONTINUE(Client, connect),
ok
end},
#{desc => "await server ready (accept/recv)",
cmd => fun(#{server := Server} = _State) ->
- ev_await_ready(Server, server, accept_recv)
+ ?SEV_AWAIT_READY(Server, server, accept_recv)
end},
%% *** Termination ***
#{desc => "order client to terminate",
cmd => fun(#{client := Client} = _State) ->
- ev_terminate(Client),
+ ?SEV_ANNOUNCE_TERMINATE(Client),
ok
end},
#{desc => "await client termination",
cmd => fun(#{client := Client} = State) ->
- ev_await_termination(Client),
- State1 = maps:remove(client, State),
- {ok, State1}
+ case ?SEV_AWAIT_TERMINATION(Client) of
+ ok ->
+ State1 = maps:remove(client, State),
+ {ok, State1};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order server to terminate",
cmd => fun(#{server := Server} = _State) ->
- ev_terminate(Server),
+ ?SEV_ANNOUNCE_TERMINATE(Server),
ok
end},
#{desc => "await server termination",
cmd => fun(#{server := Server} = State) ->
- ev_await_termination(Server),
- State1 = maps:remove(server, State),
- State2 = maps:remove(server_port, State1),
- {ok, State2}
+ case ?SEV_AWAIT_TERMINATION(Server) of
+ ok ->
+ State1 = maps:remove(server, State),
+ State2 = maps:remove(server_port, State1),
+ {ok, State2};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
i("start server evaluator"),
ServerInitState = InitState,
- Server = evaluator_start("server", ServerSeq, ServerInitState),
+ Server = ?SEV_START("server", ServerSeq, ServerInitState),
i("start client evaluator"),
ClientInitState = InitState,
- Client = evaluator_start("client", ClientSeq, ClientInitState),
+ Client = ?SEV_START("client", ClientSeq, ClientInitState),
i("start tester evaluator"),
TesterInitState = #{server => Server#ev.pid,
client => Client#ev.pid},
- Tester = evaluator_start("tester", TesterSeq, TesterInitState),
+ Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
i("await evaluator(s)"),
- ok = await_evaluator_finish([Server, Client, Tester]).
+ ok = ?SEV_AWAIT_FINISH([Server, Client, Tester]).
@@ -2917,17 +2878,14 @@ api_to_receive_udp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
i("start tester evaluator"),
- Tester = evaluator_start("tester", TesterSeq, InitState),
+ Tester = ?SEV_START("tester", TesterSeq, InitState),
i("await evaluator"),
- ok = await_evaluator_finish([Tester]).
+ ok = ?SEV_AWAIT_FINISH([Tester]).
@@ -3114,16 +3072,16 @@ sc_cpe_socket_cleanup(InitState) ->
%% *** Wait for start order part ***
#{desc => "await start (from tester)",
cmd => fun(State) ->
- Tester = ev_await_start(),
+ Tester = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester}}
end},
-
- %% *** Init part ***
#{desc => "monitor tester",
cmd => fun(#{tester := Tester} = _State) ->
_MRef = erlang:monitor(process, Tester),
ok
end},
+
+ %% *** Init part ***
#{desc => "create socket",
cmd => fun(#{domain := Domain,
type := Type,
@@ -3137,7 +3095,7 @@ sc_cpe_socket_cleanup(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester, sock := Sock} = _State) ->
- ev_ready(Tester, init, Sock),
+ ?SEV_ANNOUNCE_READY(Tester, init, Sock),
ok
end},
@@ -3145,7 +3103,7 @@ sc_cpe_socket_cleanup(InitState) ->
%% We *intentially* leave the socket "as is", no explicit close
#{desc => "await terminate (from tester)",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -3154,10 +3112,7 @@ sc_cpe_socket_cleanup(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
TesterSeq =
@@ -3170,12 +3125,12 @@ sc_cpe_socket_cleanup(InitState) ->
end},
#{desc => "order (owner) start",
cmd => fun(#{owner := Pid} = _State) ->
- ev_start(Pid),
+ ?SEV_ANNOUNCE_START(Pid),
ok
end},
#{desc => "await (owner) ready",
cmd => fun(#{owner := Pid} = State) ->
- {ok, Sock} = ev_await_ready(Pid, owner, init),
+ {ok, Sock} = ?SEV_AWAIT_READY(Pid, owner, init),
{ok, State#{sock => Sock}}
end},
#{desc => "verify owner as controlling-process",
@@ -3191,13 +3146,17 @@ sc_cpe_socket_cleanup(InitState) ->
end},
#{desc => "order (owner) terminate",
cmd => fun(#{owner := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await (owner) termination",
cmd => fun(#{owner := Pid} = _State) ->
- ev_await_termination(Pid),
- ok
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ ok;
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
%% The reason we get closed, is that as long as there is a ref to
%% the resource (socket), then it will not be garbage collected.
@@ -3209,27 +3168,24 @@ sc_cpe_socket_cleanup(InitState) ->
{error, closed} ->
ok;
{error, Reason} ->
- ei("expected failure: ~p", [Reason]),
+ ?SEV_IPRINT("expected failure: ~p", [Reason]),
{error, {unexpected_failure, Reason}}
end
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
i("start (socket) owner evaluator"),
- #ev{pid = Pid} = Owner = evaluator_start("owner", OwnerSeq, InitState),
+ Owner = ?SEV_START("owner", OwnerSeq, InitState),
i("start tester evaluator"),
- TesterInitState = #{owner => Pid},
- Tester = evaluator_start("tester", TesterSeq, TesterInitState),
+ TesterInitState = #{owner => Owner#ev.pid},
+ Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
i("await evaluator"),
- ok = await_evaluator_finish([Owner, Tester]).
+ ok = ?SEV_AWAIT_FINISH([Owner, Tester]).
@@ -3297,7 +3253,7 @@ sc_lc_receive_response_tcp(InitState) ->
%% *** Wait for start order part ***
#{desc => "await start (from tester)",
cmd => fun(State) ->
- Tester = ev_await_start(),
+ Tester = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester}}
end},
#{desc => "monitor tester",
@@ -3339,24 +3295,27 @@ sc_lc_receive_response_tcp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester, lport := Port}) ->
- ev_ready(Tester, init, Port),
+ ?SEV_ANNOUNCE_READY(Tester, init, Port),
ok
end},
%% The actual test
#{desc => "await continue (accept)",
cmd => fun(#{tester := Tester} = State) ->
- {ok, {H1, H2, H3}} =
- ev_await_continue(Tester, tester, accept),
- {ok, State#{handler1 => H1,
- handler2 => H2,
- handler3 => H3}}
+ case ?SEV_AWAIT_CONTINUE(Tester, tester, accept) of
+ {ok, {H1, H2, H3}} ->
+ {ok, State#{handler1 => H1,
+ handler2 => H2,
+ handler3 => H3}};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "await accept",
cmd => fun(#{lsock := LSock} = State) ->
case socket:accept(LSock) of
{ok, Sock} ->
- ei("connection accepted"),
+ ?SEV_IPRINT("connection accepted"),
{ok, State#{csock => Sock}};
{error, _} = ERROR ->
ERROR
@@ -3364,27 +3323,27 @@ sc_lc_receive_response_tcp(InitState) ->
end},
#{desc => "announce ready (accept)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, accept),
+ ?SEV_ANNOUNCE_READY(Tester, accept),
ok
end},
#{desc => "transfer connection to handler 1",
cmd => fun(#{handler1 := Handler, csock := Sock}) ->
- ev_continue(Handler, transfer, Sock),
+ ?SEV_ANNOUNCE_CONTINUE(Handler, transfer, Sock),
ok
end},
#{desc => "transfer connection to handler 2",
cmd => fun(#{handler2 := Handler, csock := Sock}) ->
- ev_continue(Handler, transfer, Sock),
+ ?SEV_ANNOUNCE_CONTINUE(Handler, transfer, Sock),
ok
end},
#{desc => "transfer connection to handler 3",
cmd => fun(#{handler3 := Handler, csock := Sock}) ->
- ev_continue(Handler, transfer, Sock),
+ ?SEV_ANNOUNCE_CONTINUE(Handler, transfer, Sock),
ok
end},
#{desc => "await continue (close)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_await_continue(Tester, tester, close),
+ ?SEV_AWAIT_CONTINUE(Tester, tester, close),
ok
end},
#{desc => "close the connection socket",
@@ -3398,14 +3357,14 @@ sc_lc_receive_response_tcp(InitState) ->
end},
#{desc => "announce ready (close)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, close),
+ ?SEV_ANNOUNCE_READY(Tester, close),
ok
end},
%% *** Terminate ***
#{desc => "await terminate",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -3425,10 +3384,7 @@ sc_lc_receive_response_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
%% The point of this is to perform the recv for which we are testing the reponse
@@ -3437,7 +3393,7 @@ sc_lc_receive_response_tcp(InitState) ->
%% *** Wait for start order part ***
#{desc => "await start (from tester)",
cmd => fun(State) ->
- {Tester, Acceptor} = ev_await_start(),
+ {Tester, Acceptor} = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester,
acceptor => Acceptor}}
end},
@@ -3453,48 +3409,51 @@ sc_lc_receive_response_tcp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, init),
+ ?SEV_ANNOUNCE_READY(Tester, init),
ok
end},
%% The actual test
#{desc => "await continue (transfer)",
cmd => fun(#{acceptor := Pid} = State) ->
- {ok, Sock} =
- ev_await_continue(Pid, acceptor, transfer),
- {ok, State#{sock => Sock}}
+ case ?SEV_AWAIT_CONTINUE(Pid, acceptor, transfer) of
+ {ok, Sock} ->
+ {ok, State#{sock => Sock}};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "announce ready (transfer)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, transfer),
+ ?SEV_ANNOUNCE_READY(Tester, transfer),
ok
end},
#{desc => "attempt recv (=> closed)",
cmd => fun(#{sock := Sock, recv := Recv} = State) ->
case Recv(Sock) of
{ok, _Data} ->
- ee("Unexpected data received"),
+ ?SEV_EPRINT("Unexpected data received"),
{error, unexpected_success};
{error, closed} ->
- ei("received expected 'closed' result"),
+ ?SEV_IPRINT("received expected 'closed' result"),
State1 = maps:remove(sock, State),
{ok, State1};
{error, Reason} = ERROR ->
- ee("Unexpected read faulure: "
- "~n ~p", [Reason]),
+ ?SEV_EPRINT("Unexpected read faulure: "
+ "~n ~p", [Reason]),
ERROR
end
end},
#{desc => "announce ready (recv closed)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, recv_closed),
+ ?SEV_ANNOUNCE_READY(Tester, recv_closed),
ok
end},
%% *** Terminate ***
#{desc => "await terminate",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -3504,10 +3463,7 @@ sc_lc_receive_response_tcp(InitState) ->
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
%% The point of this is basically just to create the connection.
@@ -3516,7 +3472,7 @@ sc_lc_receive_response_tcp(InitState) ->
%% *** Wait for start order part ***
#{desc => "await start (from tester)",
cmd => fun(State) ->
- Tester = ev_await_start(),
+ Tester = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester}}
end},
#{desc => "monitor tester",
@@ -3554,16 +3510,20 @@ sc_lc_receive_response_tcp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_ready(Tester, init),
+ ?SEV_ANNOUNCE_READY(Tester, init),
ok
end},
%% The actual test
#{desc => "await continue (connect)",
cmd => fun(#{tester := Tester, local_sa := LSA} = State) ->
- {ok, Port} = ev_await_continue(Tester, tester, connect),
- ServerSA = LSA#{port => Port},
- {ok, State#{server_sa => ServerSA}}
+ case ?SEV_AWAIT_CONTINUE(Tester, tester, connect) of
+ {ok, Port} ->
+ ServerSA = LSA#{port => Port},
+ {ok, State#{server_sa => ServerSA}};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "connect to server",
cmd => fun(#{sock := Sock, server_sa := ServerSA}) ->
@@ -3571,14 +3531,14 @@ sc_lc_receive_response_tcp(InitState) ->
end},
#{desc => "announce ready (connect)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_ready(Tester, connect),
+ ?SEV_ANNOUNCE_READY(Tester, connect),
ok
end},
%% *** Terminate ***
#{desc => "await terminate (from tester)",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -3592,10 +3552,7 @@ sc_lc_receive_response_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
TesterSeq =
@@ -3630,53 +3587,57 @@ sc_lc_receive_response_tcp(InitState) ->
%% Start the acceptor
#{desc => "order acceptor start",
cmd => fun(#{acceptor := Pid} = _State) ->
- ev_start(Pid),
+ ?SEV_ANNOUNCE_START(Pid),
ok
end},
#{desc => "await acceptor ready (init)",
cmd => fun(#{acceptor := Pid} = State) ->
- {ok, Port} = ev_await_ready(Pid, acceptor, init),
- {ok, State#{lport => Port}}
+ case ?SEV_AWAIT_READY(Pid, acceptor, init) of
+ {ok, Port} ->
+ {ok, State#{lport => Port}};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
%% Start the handler(s)
#{desc => "order handler 1 start",
cmd => fun(#{acceptor := Acceptor, handler1 := Pid} = _State) ->
- ev_start(Pid, Acceptor),
+ ?SEV_ANNOUNCE_START(Pid, Acceptor),
ok
end},
#{desc => "await handler 1 ready (init)",
cmd => fun(#{handler1 := Pid} = _State) ->
- ev_await_ready(Pid, handler1, init)
+ ?SEV_AWAIT_READY(Pid, handler1, init)
end},
#{desc => "order handler 2 start",
cmd => fun(#{acceptor := Acceptor, handler2 := Pid} = _State) ->
- ev_start(Pid, Acceptor),
+ ?SEV_ANNOUNCE_START(Pid, Acceptor),
ok
end},
#{desc => "await handler 2 ready (init)",
cmd => fun(#{handler2 := Pid} = _State) ->
- ev_await_ready(Pid, handler2, init)
+ ?SEV_AWAIT_READY(Pid, handler2, init)
end},
#{desc => "order handler 3 start",
cmd => fun(#{acceptor := Acceptor, handler3 := Pid} = _State) ->
- ev_start(Pid, Acceptor),
+ ?SEV_ANNOUNCE_START(Pid, Acceptor),
ok
end},
#{desc => "await handler 3 ready (init)",
cmd => fun(#{handler3 := Pid} = _State) ->
- ev_await_ready(Pid, handler3, init)
+ ?SEV_AWAIT_READY(Pid, handler3, init)
end},
%% Start the client
#{desc => "order client start",
cmd => fun(#{client := Pid} = _State) ->
- ev_start(Pid),
+ ?SEV_ANNOUNCE_START(Pid),
ok
end},
#{desc => "await client ready (init)",
cmd => fun(#{client := Pid} = _State) ->
- ev_await_ready(Pid, client, init)
+ ?SEV_AWAIT_READY(Pid, client, init)
end},
%% The actual test
@@ -3685,143 +3646,152 @@ sc_lc_receive_response_tcp(InitState) ->
handler1 := H1,
handler2 := H2,
handler3 := H3} = _State) ->
- ev_continue(Pid, accept, {H1, H2, H3}),
- ok
- end},
- #{desc => "sleep",
- cmd => fun(_) ->
- ?SLEEP(?SECS(1)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, accept, {H1, H2, H3}),
ok
end},
+ ?SEV_SLEEP(?SECS(1)),
#{desc => "order client to continue (connect)",
cmd => fun(#{client := Pid, lport := Port} = _State) ->
- ev_continue(Pid, connect, Port),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, connect, Port),
ok
end},
#{desc => "await acceptor ready (accept)",
cmd => fun(#{acceptor := Pid} = _State) ->
- ok = ev_await_ready(Pid, acceptor, accept)
+ ok = ?SEV_AWAIT_READY(Pid, acceptor, accept)
end},
#{desc => "await client ready (connect)",
cmd => fun(#{client := Pid} = _State) ->
- ok = ev_await_ready(Pid, client, connect)
+ ok = ?SEV_AWAIT_READY(Pid, client, connect)
end},
#{desc => "await handler 1 ready (transfer)",
cmd => fun(#{handler1 := Pid} = _State) ->
- ok = ev_await_ready(Pid, handler1, transfer)
+ ok = ?SEV_AWAIT_READY(Pid, handler1, transfer)
end},
#{desc => "await handler 2 ready (transfer)",
cmd => fun(#{handler2 := Pid} = _State) ->
- ok = ev_await_ready(Pid, handler2, transfer)
+ ok = ?SEV_AWAIT_READY(Pid, handler2, transfer)
end},
#{desc => "await handler 3 ready (transfer)",
cmd => fun(#{handler3 := Pid} = _State) ->
- ok = ev_await_ready(Pid, handler3, transfer)
- end},
- #{desc => "sleep",
- cmd => fun(_State) ->
- ?SLEEP(?SECS(1)),
- ok
+ ok = ?SEV_AWAIT_READY(Pid, handler3, transfer)
end},
+ ?SEV_SLEEP(?SECS(1)),
#{desc => "order acceptor to continue (close connection socket)",
cmd => fun(#{acceptor := Pid} = _State) ->
- ev_continue(Pid, close),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, close),
ok
end},
#{desc => "await acceptor ready (close)",
cmd => fun(#{acceptor := Pid} = _State) ->
- ok = ev_await_ready(Pid, acceptor, close)
+ ok = ?SEV_AWAIT_READY(Pid, acceptor, close)
end},
#{desc => "await handler 1 ready (recv closed)",
cmd => fun(#{handler1 := Pid} = _State) ->
- ok = ev_await_ready(Pid, handler1, recv_closed)
+ ok = ?SEV_AWAIT_READY(Pid, handler1, recv_closed)
end},
#{desc => "await handler 2 ready (recv closed)",
cmd => fun(#{handler2 := Pid} = _State) ->
- ok = ev_await_ready(Pid, handler2, recv_closed)
+ ok = ?SEV_AWAIT_READY(Pid, handler2, recv_closed)
end},
#{desc => "await handler 3 ready (recv closed)",
cmd => fun(#{handler3 := Pid} = _State) ->
- ok = ev_await_ready(Pid, handler3, recv_closed)
+ ok = ?SEV_AWAIT_READY(Pid, handler3, recv_closed)
end},
%% Terminations
#{desc => "order client to terminate",
cmd => fun(#{client := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await client termination",
cmd => fun(#{client := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(client, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(client, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order handler 1 to terminate",
cmd => fun(#{handler1 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await handler 1 termination",
cmd => fun(#{handler1 := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(handler1, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(handler1, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order handler 2 to terminate",
cmd => fun(#{handler2 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await handler 2 termination",
cmd => fun(#{handler2 := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(handler2, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(handler2, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order handler 3 to terminate",
cmd => fun(#{handler3 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await handler 3 termination",
cmd => fun(#{handler3 := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(handler3, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(handler3, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order acceptor to terminate",
cmd => fun(#{acceptor := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await acceptor termination",
cmd => fun(#{acceptor := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(acceptor, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(acceptor, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
i("start acceptor evaluator"),
AccInitState = InitState,
- Acceptor = evaluator_start("acceptor", AcceptorSeq, AccInitState),
+ Acceptor = ?SEV_START("acceptor", AcceptorSeq, AccInitState),
i("start handler 1 evaluator"),
HandlerInitState = #{recv => maps:get(recv, InitState)},
- Handler1 = evaluator_start("handler-1", HandlerSeq, HandlerInitState),
+ Handler1 = ?SEV_START("handler-1", HandlerSeq, HandlerInitState),
i("start handler 2 evaluator"),
- Handler2 = evaluator_start("handler-2", HandlerSeq, HandlerInitState),
+ Handler2 = ?SEV_START("handler-2", HandlerSeq, HandlerInitState),
i("start handler 3 evaluator"),
- Handler3 = evaluator_start("handler-3", HandlerSeq, HandlerInitState),
+ Handler3 = ?SEV_START("handler-3", HandlerSeq, HandlerInitState),
i("start client evaluator"),
ClientInitState = InitState,
- Client = evaluator_start("client", ClientSeq, ClientInitState),
+ Client = ?SEV_START("client", ClientSeq, ClientInitState),
i("start tester evaluator"),
TesterInitState = #{acceptor => Acceptor#ev.pid,
@@ -3829,12 +3799,12 @@ sc_lc_receive_response_tcp(InitState) ->
handler2 => Handler2#ev.pid,
handler3 => Handler3#ev.pid,
client => Client#ev.pid},
- Tester = evaluator_start("tester", TesterSeq, TesterInitState),
+ Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
i("await evaluator"),
- ok = await_evaluator_finish([Acceptor,
- Handler1, Handler2, Handler3,
- Client, Tester]).
+ ok = ?SEV_AWAIT_FINISH([Acceptor,
+ Handler1, Handler2, Handler3,
+ Client, Tester]).
@@ -3887,10 +3857,10 @@ sc_lc_recvfrom_response_udp6(_Config) when is_list(_Config) ->
sc_lc_receive_response_udp(InitState) ->
PrimServerSeq =
[
- %% *** Init part ***
+ %% *** Wait for start order part ***
#{desc => "await start",
cmd => fun(State) ->
- Tester = ev_await_start(),
+ Tester = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester}}
end},
#{desc => "monitor tester",
@@ -3898,6 +3868,8 @@ sc_lc_receive_response_udp(InitState) ->
_MRef = erlang:monitor(process, Tester),
ok
end},
+
+ %% *** Init part ***
#{desc => "local address",
cmd => fun(#{domain := Domain} = State) ->
LAddr = which_local_addr(Domain),
@@ -3917,15 +3889,19 @@ sc_lc_receive_response_udp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester, sock := Sock}) ->
- ev_ready(Tester, init, Sock),
+ ?SEV_ANNOUNCE_READY(Tester, init, Sock),
ok
end},
%% The actual test
#{desc => "await continue (recv, with timeout)",
cmd => fun(#{tester := Tester} = State) ->
- {ok, Timeout} = ev_await_continue(Tester, tester, recv),
- {ok, State#{timeout => Timeout}}
+ case ?SEV_AWAIT_CONTINUE(Tester, tester, recv) of
+ {ok, Timeout} ->
+ {ok, State#{timeout => Timeout}};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "receive, with timeout",
cmd => fun(#{sock := Sock, recv := Recv, timeout := Timeout}) ->
@@ -3940,12 +3916,12 @@ sc_lc_receive_response_udp(InitState) ->
end},
#{desc => "announce ready (recv, with timeout)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, recv),
+ ?SEV_ANNOUNCE_READY(Tester, recv),
ok
end},
#{desc => "await continue (close)",
cmd => fun(#{tester := Tester} = _State) ->
- ok = ev_await_continue(Tester, tester, close)
+ ok = ?SEV_AWAIT_CONTINUE(Tester, tester, close)
end},
#{desc => "close socket",
cmd => fun(#{sock := Sock} = State) ->
@@ -3958,14 +3934,14 @@ sc_lc_receive_response_udp(InitState) ->
end},
#{desc => "announce ready (close)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, close),
+ ?SEV_ANNOUNCE_READY(Tester, close),
ok
end},
%% Termination
#{desc => "await terminate (from tester)",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, terminate) of
+ case ?SEV_AWAIT_TERMINATE(Tester, terminate) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -3974,10 +3950,7 @@ sc_lc_receive_response_udp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
SecServerSeq =
@@ -3985,7 +3958,7 @@ sc_lc_receive_response_udp(InitState) ->
%% *** Init part ***
#{desc => "await start",
cmd => fun(State) ->
- {Tester, Sock} = ev_await_start(),
+ {Tester, Sock} = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester, sock => Sock}}
end},
#{desc => "monitor tester",
@@ -3995,14 +3968,14 @@ sc_lc_receive_response_udp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, init),
+ ?SEV_ANNOUNCE_READY(Tester, init),
ok
end},
%% The actual test
#{desc => "await continue (recv)",
cmd => fun(#{tester := Tester} = _State) ->
- ok = ev_await_continue(Tester, tester, recv)
+ ok = ?SEV_AWAIT_CONTINUE(Tester, tester, recv)
end},
#{desc => "receive",
@@ -4018,14 +3991,14 @@ sc_lc_receive_response_udp(InitState) ->
end},
#{desc => "announce ready (recv closed)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, recv_closed),
+ ?SEV_ANNOUNCE_READY(Tester, recv_closed),
ok
end},
%% Termination
#{desc => "await terminate (from tester)",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -4034,10 +4007,7 @@ sc_lc_receive_response_udp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
@@ -4068,46 +4038,46 @@ sc_lc_receive_response_udp(InitState) ->
%% Start the primary server
#{desc => "order 'primary server' start",
cmd => fun(#{prim_server := Pid} = _State) ->
- ev_start(Pid),
+ ?SEV_ANNOUNCE_START(Pid),
ok
end},
#{desc => "await 'primary server' ready (init)",
cmd => fun(#{prim_server := Pid} = State) ->
- {ok, Sock} = ev_await_ready(Pid, prim_server, init),
+ {ok, Sock} = ?SEV_AWAIT_READY(Pid, prim_server, init),
{ok, State#{sock => Sock}}
end},
%% Start the secondary server 1
#{desc => "order 'secondary server 1' start",
cmd => fun(#{sec_server1 := Pid, sock := Sock} = _State) ->
- ev_start(Pid, Sock),
+ ?SEV_ANNOUNCE_START(Pid, Sock),
ok
end},
#{desc => "await 'secondary server 1' ready (init)",
cmd => fun(#{sec_server1 := Pid} = _State) ->
- ok = ev_await_ready(Pid, sec_server1, init)
+ ok = ?SEV_AWAIT_READY(Pid, sec_server1, init)
end},
%% Start the secondary server 2
#{desc => "order 'secondary server 2' start",
cmd => fun(#{sec_server2 := Pid, sock := Sock} = _State) ->
- ev_start(Pid, Sock),
+ ?SEV_ANNOUNCE_START(Pid, Sock),
ok
end},
#{desc => "await 'secondary server 2' ready (init)",
cmd => fun(#{sec_server2 := Pid} = _State) ->
- ok = ev_await_ready(Pid, sec_server2, init)
+ ok = ?SEV_AWAIT_READY(Pid, sec_server2, init)
end},
%% Start the secondary server 3
#{desc => "order 'secondary server 3' start",
cmd => fun(#{sec_server3 := Pid, sock := Sock} = _State) ->
- ev_start(Pid, Sock),
+ ?SEV_ANNOUNCE_START(Pid, Sock),
ok
end},
#{desc => "await 'secondary server 3' ready (init)",
cmd => fun(#{sec_server3 := Pid} = _State) ->
- ok = ev_await_ready(Pid, sec_server3, init)
+ ok = ?SEV_AWAIT_READY(Pid, sec_server3, init)
end},
@@ -4120,142 +4090,142 @@ sc_lc_receive_response_udp(InitState) ->
#{desc => "order 'secondary server 1' to continue (recv)",
cmd => fun(#{sec_server1 := Pid} = _State) ->
- ev_continue(Pid, recv),
- ok
- end},
- #{desc => "sleep",
- cmd => fun(_) ->
- ?SLEEP(?SECS(1)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, recv),
ok
end},
+ ?SEV_SLEEP(?SECS(1)),
#{desc => "order 'secondary server 2' to continue (recv)",
cmd => fun(#{sec_server2 := Pid} = _State) ->
- ev_continue(Pid, recv),
- ok
- end},
- #{desc => "sleep",
- cmd => fun(_) ->
- ?SLEEP(?SECS(1)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, recv),
ok
end},
+ ?SEV_SLEEP(?SECS(1)),
#{desc => "order 'secondary server 3' to continue (recv)",
cmd => fun(#{sec_server3 := Pid} = _State) ->
- ev_continue(Pid, recv),
- ok
- end},
- #{desc => "sleep",
- cmd => fun(_) ->
- ?SLEEP(?SECS(1)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, recv),
ok
end},
+ ?SEV_SLEEP(?SECS(1)),
#{desc => "order 'primary server' to continue (recv, with timeout)",
cmd => fun(#{prim_server := Pid} = _State) ->
- ev_continue(Pid, recv, ?SECS(5)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, recv, ?SECS(5)),
ok
end},
#{desc => "await 'primary server' ready (recv, with timeout)",
cmd => fun(#{prim_server := Pid} = _State) ->
- ev_await_ready(Pid, prim_server, recv)
+ ?SEV_AWAIT_READY(Pid, prim_server, recv)
end},
#{desc => "order 'primary server' to continue (close)",
cmd => fun(#{prim_server := Pid} = _State) ->
- %% Pid ! {continue, self()},
- ev_continue(Pid, close),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, close),
ok
end},
#{desc => "await 'primary server' ready (close)",
cmd => fun(#{prim_server := Pid} = _State) ->
- ev_await_ready(Pid, prim_server, close)
+ ?SEV_AWAIT_READY(Pid, prim_server, close)
end},
#{desc => "await 'secondary server 1' ready (closed)",
cmd => fun(#{sec_server1 := Pid} = _State) ->
- ev_await_ready(Pid, sec_server1, recv_closed)
+ ?SEV_AWAIT_READY(Pid, sec_server1, recv_closed)
end},
#{desc => "await 'secondary server 2' ready (closed)",
cmd => fun(#{sec_server2 := Pid} = _State) ->
- ev_await_ready(Pid, sec_server2, recv_closed)
+ ?SEV_AWAIT_READY(Pid, sec_server2, recv_closed)
end},
#{desc => "await 'secondary server 3' ready (closed)",
cmd => fun(#{sec_server3 := Pid} = _State) ->
- ev_await_ready(Pid, sec_server3, recv_closed)
+ ?SEV_AWAIT_READY(Pid, sec_server3, recv_closed)
end},
%% Terminations
#{desc => "order 'secondary server 3' to terminate",
cmd => fun(#{sec_server3 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await 'secondary server 3' termination",
cmd => fun(#{sec_server3 := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(sec_server3, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(sec_server3, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order 'secondary server 2' to terminate",
cmd => fun(#{sec_server2 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await 'secondary server 2' termination",
cmd => fun(#{sec_server2 := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(sec_server2, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(sec_server2, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order 'secondary server 1' to terminate",
cmd => fun(#{sec_server1 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await 'secondary server 1' termination",
cmd => fun(#{sec_server1 := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(sec_server1, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(sec_server1, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order 'primary server' to terminate",
cmd => fun(#{prim_server := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await 'primary server' termination",
cmd => fun(#{prim_server := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(prim_server, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(prim_server, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
i("start 'primary server' evaluator"),
PrimSrvInitState = InitState,
- PrimServer = evaluator_start("prim-server", PrimServerSeq, PrimSrvInitState),
+ PrimServer = ?SEV_START("prim-server", PrimServerSeq, PrimSrvInitState),
i("start 'secondary server 1' evaluator"),
SecSrvInitState = #{recv => maps:get(recv, InitState)},
- SecServer1 = evaluator_start("sec-server-1", SecServerSeq, SecSrvInitState),
+ SecServer1 = ?SEV_START("sec-server-1", SecServerSeq, SecSrvInitState),
i("start 'secondary server 2' evaluator"),
- SecServer2 = evaluator_start("sec-server-2", SecServerSeq, SecSrvInitState),
+ SecServer2 = ?SEV_START("sec-server-2", SecServerSeq, SecSrvInitState),
i("start 'secondary server 3' evaluator"),
- SecServer3 = evaluator_start("sec-server-3", SecServerSeq, SecSrvInitState),
+ SecServer3 = ?SEV_START("sec-server-3", SecServerSeq, SecSrvInitState),
i("start 'tester' evaluator"),
TesterInitState = #{prim_server => PrimServer#ev.pid,
sec_server1 => SecServer1#ev.pid,
sec_server2 => SecServer2#ev.pid,
sec_server3 => SecServer3#ev.pid},
- Tester = evaluator_start("tester", TesterSeq, TesterInitState),
+ Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
i("await evaluator"),
- ok = await_evaluator_finish([PrimServer,
- SecServer1, SecServer2, SecServer3,
- Tester]).
+ ok = ?SEV_AWAIT_FINISH([PrimServer,
+ SecServer1, SecServer2, SecServer3,
+ Tester]).
@@ -4403,10 +4373,10 @@ sc_rc_receive_response_tcp(InitState) ->
%% by the server!
ServerSeq =
[
- %% *** Init part ***
+ %% *** Wait for start order part ***
#{desc => "await start",
cmd => fun(State) ->
- Tester = ev_await_start(),
+ Tester = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester}}
end},
#{desc => "monitor tester",
@@ -4414,6 +4384,8 @@ sc_rc_receive_response_tcp(InitState) ->
_MRef = erlang:monitor(process, Tester),
ok
end},
+
+ %% *** Init part ***
#{desc => "which local address",
cmd => fun(#{domain := Domain} = State) ->
LAddr = which_local_addr(Domain),
@@ -4445,24 +4417,24 @@ sc_rc_receive_response_tcp(InitState) ->
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester, local_sa := LSA, lport := Port}) ->
ServerSA = LSA#{port => Port},
- ev_ready(Tester, init, ServerSA),
+ ?SEV_ANNOUNCE_READY(Tester, init, ServerSA),
ok
end},
%% The actual test (we expect three connections)
#{desc => "await continue (accept all three connections)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_await_continue(Tester, tester, accept)
+ ?SEV_ANNOUNCE_CONTINUE(Tester, tester, accept)
end},
#{desc => "accept 1",
cmd => fun(#{lsock := LSock, recv := Recv} = State) ->
case socket:accept(LSock) of
{ok, Sock} ->
- ei("accepted: try start handler"),
+ ?SEV_IPRINT("accepted: try start handler"),
{ok, Handler} = sc_rc_tcp_handler_start(1,
Recv,
Sock),
- ei("handler started"),
+ ?SEV_IPRINT("handler started"),
{ok, State#{csock1 => Sock,
handler1 => Handler}};
{error, _} = ERROR ->
@@ -4473,11 +4445,11 @@ sc_rc_receive_response_tcp(InitState) ->
cmd => fun(#{lsock := LSock, recv := Recv} = State) ->
case socket:accept(LSock) of
{ok, Sock} ->
- ei("accepted: try start handler"),
+ ?SEV_IPRINT("accepted: try start handler"),
{ok, Handler} = sc_rc_tcp_handler_start(2,
Recv,
Sock),
- ei("handler started"),
+ ?SEV_IPRINT("handler started"),
{ok, State#{csock2 => Sock,
handler2 => Handler}};
{error, _} = ERROR ->
@@ -4488,11 +4460,11 @@ sc_rc_receive_response_tcp(InitState) ->
cmd => fun(#{lsock := LSock, recv := Recv} = State) ->
case socket:accept(LSock) of
{ok, Sock} ->
- ei("accepted: try start handler"),
+ ?SEV_IPRINT("accepted: try start handler"),
{ok, Handler} = sc_rc_tcp_handler_start(3,
Recv,
Sock),
- ei("handler started"),
+ ?SEV_IPRINT("handler started"),
{ok, State#{csock3 => Sock,
handler3 => Handler}};
{error, _} = ERROR ->
@@ -4501,12 +4473,12 @@ sc_rc_receive_response_tcp(InitState) ->
end},
#{desc => "announce ready (accept all three connections)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, accept),
+ ?SEV_ANNOUNCE_READY(Tester, accept),
ok
end},
#{desc => "await continue (recv)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_await_continue(Tester, tester, recv)
+ ?SEV_AWAIT_CONTINUE(Tester, tester, recv)
end},
#{desc => "order handler 1 to receive",
cmd => fun(#{handler1 := Pid} = _State) ->
@@ -4558,14 +4530,14 @@ sc_rc_receive_response_tcp(InitState) ->
end},
#{desc => "announce ready (recv closed from all handlers)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, recv_closed),
+ ?SEV_ANNOUNCE_READY(Tester, recv_closed),
ok
end},
%% Termination
#{desc => "await terminate (from tester)",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -4625,18 +4597,15 @@ sc_rc_receive_response_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
ClientSeq =
[
- %% *** Init part ***
+ %% *** Wait for start order part ***
#{desc => "await start",
cmd => fun(State) ->
- {Tester, {Node, ServerSA}} = ev_await_start(),
+ {Tester, {Node, ServerSA}} = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester,
node => Node,
server_sa => ServerSA}}
@@ -4646,10 +4615,12 @@ sc_rc_receive_response_tcp(InitState) ->
_MRef = erlang:monitor(process, Tester),
ok
end},
+
+ %% *** Init part ***
#{desc => "start remote client on client node",
cmd => fun(#{node := Node} = State) ->
Pid = sc_rc_tcp_client_start(Node),
- ei("client ~p started", [Pid]),
+ ?SEV_IPRINT("client ~p started", [Pid]),
{ok, State#{client => Pid}}
end},
#{desc => "monitor remote client",
@@ -4669,18 +4640,20 @@ sc_rc_receive_response_tcp(InitState) ->
{ready, Client} ->
ok;
{'DOWN', _, process, Tester, Reason} ->
- ee("Unexpected DOWN regarding tester ~p: "
- "~n ~p", [Tester, Reason]),
+ ?SEV_EPRINT("Unexpected DOWN regarding "
+ "tester ~p: "
+ "~n ~p", [Tester, Reason]),
{error, {unexpected_exit, tester}};
{'DOWN', _, process, Client, Reason} ->
- ee("Unexpected DOWN regarding client ~p: "
- "~n ~p", [Client, Reason]),
+ ?SEV_EPRINT("Unexpected DOWN regarding "
+ "client ~p: "
+ "~n ~p", [Client, Reason]),
{error, {unexpected_exit, client}}
end
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, init),
+ ?SEV_ANNOUNCE_READY(Tester, init),
ok
end},
@@ -4688,8 +4661,8 @@ sc_rc_receive_response_tcp(InitState) ->
#{desc => "await continue (connect)",
cmd => fun(#{tester := Tester,
client := Client} = _State) ->
- ev_await_continue(Tester, tester, connect,
- [{rclient, Client}]),
+ ?SEV_AWAIT_CONTINUE(Tester, tester, connect,
+ [{rclient, Client}]),
ok
end},
#{desc => "order remote client to continue (connect)",
@@ -4704,25 +4677,27 @@ sc_rc_receive_response_tcp(InitState) ->
{ready, Client} ->
ok;
{'DOWN', _, process, Tester, Reason} ->
- ee("Unexpected DOWN regarding tester ~p: "
- "~n ~p", [Tester, Reason]),
+ ?SEV_EPRINT("Unexpected DOWN regarding "
+ "tester ~p: "
+ "~n ~p", [Tester, Reason]),
{error, {unexpected_exit, tester}};
{'DOWN', _, process, Client, Reason} ->
- ee("Unexpected DOWN regarding client ~p: "
- "~n ~p", [Client, Reason]),
+ ?SEV_EPRINT("Unexpected DOWN regarding "
+ "client ~p: "
+ "~n ~p", [Client, Reason]),
{error, {unexpected_exit, client}}
end
end},
#{desc => "announce ready (connected)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, connect),
+ ?SEV_ANNOUNCE_READY(Tester, connect),
ok
end},
#{desc => "await continue (close)",
cmd => fun(#{tester := Tester,
client := Client} = _State) ->
- ev_await_continue(Tester, tester, close,
- [{rclient, Client}]),
+ ?SEV_AWAIT_CONTINUE(Tester, tester, close,
+ [{rclient, Client}]),
ok
end},
#{desc => "order remote client to close",
@@ -4737,26 +4712,33 @@ sc_rc_receive_response_tcp(InitState) ->
{ready, Client} ->
ok;
{'DOWN', _, process, Tester, Reason} ->
- ee("Unexpected DOWN regarding tester ~p: "
- "~n ~p", [Tester, Reason]),
+ ?SEV_EPRINT("Unexpected DOWN regarding "
+ "tester ~p: "
+ "~n ~p", [Tester, Reason]),
{error, {unexpected_exit, tester}};
{'DOWN', _, process, Client, Reason} ->
- ee("Unexpected DOWN regarding client ~p: "
- "~n ~p", [Client, Reason]),
+ ?SEV_EPRINT("Unexpected DOWN regarding "
+ "client ~p: "
+ "~n ~p", [Client, Reason]),
{error, {unexpected_exit, client}}
end
end},
#{desc => "announce ready (close)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, close),
+ ?SEV_ANNOUNCE_READY(Tester, close),
ok
end},
%% Termination
#{desc => "await terminate (from tester)",
cmd => fun(#{tester := Tester, client := Client} = State) ->
- ev_await_terminate(Tester, tester, [{rclient, Client}]),
- {ok, maps:remove(tester, State)}
+ case ?SEV_AWAIT_TERMINATE(Tester, tester,
+ [{rclient, Client}]) of
+ ok ->
+ {ok, maps:remove(tester, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "kill remote client",
cmd => fun(#{client := Client}) ->
@@ -4772,10 +4754,7 @@ sc_rc_receive_response_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
TesterSeq =
@@ -4785,7 +4764,8 @@ sc_rc_receive_response_tcp(InitState) ->
cmd => fun(#{host := Host} = State) ->
case start_node(Host, client_1) of
{ok, Node} ->
- ei("client node (1) ~p started", [Node]),
+ ?SEV_IPRINT("client node (1) ~p started",
+ [Node]),
{ok, State#{client_node1 => Node}};
{error, Reason, _} ->
{error, Reason}
@@ -4800,7 +4780,8 @@ sc_rc_receive_response_tcp(InitState) ->
cmd => fun(#{host := Host} = State) ->
case start_node(Host, client_2) of
{ok, Node} ->
- ei("client node (2) ~p started", [Node]),
+ ?SEV_IPRINT("client node (2) ~p started",
+ [Node]),
{ok, State#{client_node2 => Node}};
{error, Reason, _} ->
{error, Reason}
@@ -4815,7 +4796,8 @@ sc_rc_receive_response_tcp(InitState) ->
cmd => fun(#{host := Host} = State) ->
case start_node(Host, client_3) of
{ok, Node} ->
- ei("client node (3) ~p started", [Node]),
+ ?SEV_IPRINT("client node (3) ~p started",
+ [Node]),
{ok, State#{client_node3 => Node}};
{error, Reason, _} ->
{error, Reason}
@@ -4850,12 +4832,12 @@ sc_rc_receive_response_tcp(InitState) ->
%% Start the server
#{desc => "order server start",
cmd => fun(#{server := Pid} = _State) ->
- ev_start(Pid),
+ ?SEV_ANNOUNCE_START(Pid),
ok
end},
#{desc => "await server ready (init)",
cmd => fun(#{server := Pid} = State) ->
- {ok, ServerSA} = ev_await_ready(Pid, server, init),
+ {ok, ServerSA} = ?SEV_AWAIT_READY(Pid, server, init),
{ok, State#{server_sa => ServerSA}}
end},
@@ -4864,50 +4846,46 @@ sc_rc_receive_response_tcp(InitState) ->
cmd => fun(#{client1 := Pid,
client_node1 := Node,
server_sa := ServerSA} = _State) ->
- ev_start(Pid, {Node, ServerSA}),
+ ?SEV_ANNOUNCE_START(Pid, {Node, ServerSA}),
ok
end},
#{desc => "await client 1 ready (init)",
cmd => fun(#{client1 := Pid} = _State) ->
- ok = ev_await_ready(Pid, client, init)
+ ok = ?SEV_AWAIT_READY(Pid, client1, init)
end},
#{desc => "order client 2 start",
cmd => fun(#{client2 := Pid,
client_node2 := Node,
server_sa := ServerSA} = _State) ->
- ev_start(Pid, {Node, ServerSA}),
+ ?SEV_ANNOUNCE_START(Pid, {Node, ServerSA}),
ok
end},
#{desc => "await client 2 ready (init)",
cmd => fun(#{client2 := Pid} = _State) ->
- ok = ev_await_ready(Pid, client, init)
+ ok = ?SEV_AWAIT_READY(Pid, client2, init)
end},
#{desc => "order client 3 start",
cmd => fun(#{client3 := Pid,
client_node3 := Node,
server_sa := ServerSA} = _State) ->
- ev_start(Pid, {Node, ServerSA}),
+ ?SEV_ANNOUNCE_START(Pid, {Node, ServerSA}),
ok
end},
#{desc => "await client 3 ready (init)",
cmd => fun(#{client3 := Pid} = _State) ->
- ok = ev_await_ready(Pid, client, init)
+ ok = ?SEV_AWAIT_READY(Pid, client3, init)
end},
%% The actual test
#{desc => "order server continue (accept)",
cmd => fun(#{server := Pid} = _State) ->
- ev_continue(Pid, accept),
- ok
- end},
- #{desc => "sleep",
- cmd => fun(_) ->
- ?SLEEP(?SECS(1)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
ok
end},
+ ?SEV_SLEEP(?SECS(1)),
#{desc => "order client 1 continue (connect)",
cmd => fun(#{client1 := Pid} = _State) ->
- ev_continue(Pid, connect),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, connect),
ok
end},
#{desc => "await client 1 ready (connect)",
@@ -4915,15 +4893,15 @@ sc_rc_receive_response_tcp(InitState) ->
client1 := Client1,
client2 := Client2,
client3 := Client3} = _State) ->
- ev_await_ready(Client1, client1, connect,
- [{server, Server},
- {client2, Client2},
- {client3, Client3}]),
+ ?SEV_AWAIT_READY(Client1, client1, connect,
+ [{server, Server},
+ {client2, Client2},
+ {client3, Client3}]),
ok
end},
#{desc => "order client 2 continue (connect)",
cmd => fun(#{client2 := Pid} = _State) ->
- ev_continue(Pid, connect),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, connect),
ok
end},
#{desc => "await client 2 ready (connect)",
@@ -4931,15 +4909,15 @@ sc_rc_receive_response_tcp(InitState) ->
client1 := Client1,
client2 := Client2,
client3 := Client3} = _State) ->
- ev_await_ready(Client2, client2, connect,
- [{server, Server},
- {client1, Client1},
- {client3, Client3}]),
+ ?SEV_AWAIT_READY(Client2, client2, connect,
+ [{server, Server},
+ {client1, Client1},
+ {client3, Client3}]),
ok
end},
#{desc => "order client 3 continue (connect)",
cmd => fun(#{client3 := Pid} = _State) ->
- ev_continue(Pid, connect),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, connect),
ok
end},
#{desc => "await client 3 ready (connect)",
@@ -4947,10 +4925,10 @@ sc_rc_receive_response_tcp(InitState) ->
client1 := Client1,
client2 := Client2,
client3 := Client3} = _State) ->
- ev_await_ready(Client3, client3, connect,
- [{server, Server},
- {client1, Client1},
- {client2, Client2}]),
+ ?SEV_AWAIT_READY(Client3, client3, connect,
+ [{server, Server},
+ {client1, Client1},
+ {client2, Client2}]),
ok
end},
#{desc => "await server ready (accept from all connections)",
@@ -4958,25 +4936,21 @@ sc_rc_receive_response_tcp(InitState) ->
client1 := Client1,
client2 := Client2,
client3 := Client3} = _State) ->
- ev_await_ready(Server, server, accept,
- [{client1, Client1},
- {client2, Client2},
- {client3, Client3}]),
+ ?SEV_AWAIT_READY(Server, server, accept,
+ [{client1, Client1},
+ {client2, Client2},
+ {client3, Client3}]),
ok
end},
#{desc => "order server continue (recv for all connections)",
cmd => fun(#{server := Pid} = _State) ->
- ev_continue(Pid, recv),
- ok
- end},
- #{desc => "sleep",
- cmd => fun(_) ->
- ?SLEEP(?SECS(1)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, recv),
ok
end},
+ ?SEV_SLEEP(?SECS(1)),
#{desc => "order client 1 continue (close)",
cmd => fun(#{client1 := Pid} = _State) ->
- ev_continue(Pid, close),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, close),
ok
end},
#{desc => "await client 1 ready (close)",
@@ -4984,15 +4958,15 @@ sc_rc_receive_response_tcp(InitState) ->
client1 := Client1,
client2 := Client2,
client3 := Client3} = _State) ->
- ev_await_ready(Client1, client1, close,
- [{server, Server},
- {client2, Client2},
- {client3, Client3}]),
+ ?SEV_AWAIT_READY(Client1, client1, close,
+ [{server, Server},
+ {client2, Client2},
+ {client3, Client3}]),
ok
end},
#{desc => "order client 2 continue (close)",
cmd => fun(#{client2 := Pid} = _State) ->
- ev_continue(Pid, close),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, close),
ok
end},
#{desc => "await client 2 ready (close)",
@@ -5000,15 +4974,15 @@ sc_rc_receive_response_tcp(InitState) ->
client1 := Client1,
client2 := Client2,
client3 := Client3} = _State) ->
- ev_await_ready(Client2, client2, close,
- [{server, Server},
- {client1, Client1},
- {client3, Client3}]),
+ ?SEV_AWAIT_READY(Client2, client2, close,
+ [{server, Server},
+ {client1, Client1},
+ {client3, Client3}]),
ok
end},
#{desc => "order client 3 continue (close)",
cmd => fun(#{client3 := Pid} = _State) ->
- ev_continue(Pid, close),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, close),
ok
end},
#{desc => "await client 3 ready (close)",
@@ -5016,10 +4990,10 @@ sc_rc_receive_response_tcp(InitState) ->
client1 := Client1,
client2 := Client2,
client3 := Client3} = _State) ->
- ev_await_ready(Client3, client1, close,
- [{server, Server},
- {client1, Client1},
- {client2, Client2}]),
+ ?SEV_AWAIT_READY(Client3, client1, close,
+ [{server, Server},
+ {client1, Client1},
+ {client2, Client2}]),
ok
end},
#{desc => "await server ready (close for all connections)",
@@ -5027,57 +5001,73 @@ sc_rc_receive_response_tcp(InitState) ->
client1 := Client1,
client2 := Client2,
client3 := Client3} = _State) ->
- ev_await_ready(Server, server, recv_closed,
- [{client1, Client1},
- {client2, Client2},
- {client3, Client3}]),
+ ?SEV_AWAIT_READY(Server, server, recv_closed,
+ [{client1, Client1},
+ {client2, Client2},
+ {client3, Client3}]),
ok
end},
%% Terminations
#{desc => "order client 1 to terminate",
cmd => fun(#{client1 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await client 1 termination",
cmd => fun(#{client1 := Pid} = State) ->
- ev_await_termination(Pid),
- State1 = maps:remove(client1, State),
- {ok, State1}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ State1 = maps:remove(client1, State),
+ {ok, State1};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order client 2 to terminate",
cmd => fun(#{client2 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await client 2 termination",
cmd => fun(#{client2 := Pid} = State) ->
- ev_await_termination(Pid),
- State1 = maps:remove(client2, State),
- {ok, State1}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ State1 = maps:remove(client2, State),
+ {ok, State1};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order client 3 to terminate",
cmd => fun(#{client3 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await client 3 termination",
cmd => fun(#{client3 := Pid} = State) ->
- ev_await_termination(Pid),
- State1 = maps:remove(client3, State),
- {ok, State1}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ State1 = maps:remove(client3, State),
+ {ok, State1};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order server to terminate",
cmd => fun(#{server := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await server termination",
cmd => fun(#{server := Pid} = State) ->
- ev_await_termination(Pid),
- State1 = maps:remove(server, State),
- {ok, State1}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ State1 = maps:remove(server, State),
+ {ok, State1};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "stop client node 1",
cmd => fun(#{client_node1 := Node} = _State) ->
@@ -5114,21 +5104,18 @@ sc_rc_receive_response_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
i("start server evaluator"),
ServerInitState = InitState,
- Server = evaluator_start("server", ServerSeq, ServerInitState),
+ Server = ?SEV_START("server", ServerSeq, ServerInitState),
i("start client evaluator(s)"),
ClientInitState = InitState,
- Client1 = evaluator_start("client-1", ClientSeq, ClientInitState),
- Client2 = evaluator_start("client-2", ClientSeq, ClientInitState),
- Client3 = evaluator_start("client-3", ClientSeq, ClientInitState),
+ Client1 = ?SEV_START("client-1", ClientSeq, ClientInitState),
+ Client2 = ?SEV_START("client-2", ClientSeq, ClientInitState),
+ Client3 = ?SEV_START("client-3", ClientSeq, ClientInitState),
i("start 'tester' evaluator"),
TesterInitState = #{host => local_host(),
@@ -5136,12 +5123,12 @@ sc_rc_receive_response_tcp(InitState) ->
client1 => Client1#ev.pid,
client2 => Client2#ev.pid,
client3 => Client3#ev.pid},
- Tester = evaluator_start("tester", TesterSeq, TesterInitState),
+ Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
i("await evaluator"),
- ok = await_evaluator_finish([Server,
- Client1, Client2, Client3,
- Tester]).
+ ok = ?SEV_AWAIT_FINISH([Server,
+ Client1, Client2, Client3,
+ Tester]).
start_node(Host, NodeName) ->
@@ -5304,35 +5291,35 @@ sc_rc_tcp_handler_init(ID, Parent) ->
put(sname, f("handler-~w", [ID])),
_MRef = erlang:monitor(process, Parent),
Parent ! {started, self()},
- ei("started"),
+ ?SEV_IPRINT("started"),
ok.
sc_rc_tcp_handler_await_recv(Parent) ->
- ei("await recv"),
+ ?SEV_IPRINT("await recv"),
receive
{recv, Parent} ->
ok;
{'DOWN', _, process, Parent, Reason} ->
- ee("received DOWN regarding parent: "
+ ?SEV_EPRINT("received DOWN regarding parent: "
"~n ~p", [Reason]),
exit({parent, Reason})
end.
sc_rc_tcp_handler_recv(Recv, Sock) ->
- ei("recv"),
+ ?SEV_IPRINT("recv"),
try Recv(Sock) of
{error, closed} ->
ok;
{ok, _} ->
- ei("unexpected success"),
+ ?SEV_IPRINT("unexpected success"),
{error, unexpected_success};
{error, Reason} = ERROR ->
- ei("receive error: "
+ ?SEV_IPRINT("receive error: "
"~n ~p", [Reason]),
ERROR
catch
C:E:S ->
- ei("receive failure: "
+ ?SEV_IPRINT("receive failure: "
"~n Class: ~p"
"~n Error: ~p"
"~n Stack: ~p", [C, E, S]),
@@ -5340,18 +5327,18 @@ sc_rc_tcp_handler_recv(Recv, Sock) ->
end.
sc_rc_tcp_handler_announce_ready(Parent, Result) ->
- ei("announce ready"),
+ ?SEV_IPRINT("announce ready"),
Parent ! {ready, self(), Result},
ok.
sc_rc_tcp_handler_await_terminate(Parent) ->
- ei("await terminate"),
+ ?SEV_IPRINT("await terminate"),
receive
{terminate, Parent, Reason} ->
Reason;
{'DOWN', _, process, Parent, Reason} ->
- ee("received DOWN regarding parent: "
- "~n ~p", [Reason]),
+ ?SEV_EPRINT("received DOWN regarding parent: "
+ "~n ~p", [Reason]),
{parent, Reason}
end.
@@ -5454,7 +5441,7 @@ sc_lc_acceptor_response_tcp(InitState) ->
%% *** Wait for start order part ***
#{desc => "await start (from tester)",
cmd => fun(State) ->
- Tester = ev_await_start(),
+ Tester = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester}}
end},
#{desc => "monitor tester",
@@ -5496,16 +5483,19 @@ sc_lc_acceptor_response_tcp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester, sock := Sock} = _State) ->
- ev_ready(Tester, init, Sock),
+ ?SEV_ANNOUNCE_READY(Tester, init, Sock),
ok
end},
%% The actual test
#{desc => "await continue (accept)",
cmd => fun(#{tester := Tester} = State) ->
- {ok, Timeout} =
- ev_await_continue(Tester, tester, accept),
- {ok, State#{timeout => Timeout}}
+ case ?SEV_AWAIT_CONTINUE(Tester, tester, accept) of
+ {ok, Timeout} ->
+ {ok, State#{timeout => Timeout}};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "await connection",
cmd => fun(#{sock := Sock, timeout := Timeout} = _State) ->
@@ -5513,7 +5503,7 @@ sc_lc_acceptor_response_tcp(InitState) ->
{error, timeout} ->
ok;
{ok, Sock} ->
- ee("unexpected success"),
+ ?SEV_EPRINT("unexpected success"),
(catch socket:close(Sock)),
{error, unexpected_success};
{error, _} = ERROR ->
@@ -5522,13 +5512,12 @@ sc_lc_acceptor_response_tcp(InitState) ->
end},
#{desc => "announce ready (accept timeout)",
cmd => fun(#{tester := Tester}) ->
- Tester ! {ready, self()},
- ev_ready(Tester, accept_timeout),
+ ?SEV_ANNOUNCE_READY(Tester, accept_timeout),
ok
end},
#{desc => "await continue (close)",
cmd => fun(#{tester := Tester} = _State) ->
- ok = ev_await_continue(Tester, tester, close)
+ ok = ?SEV_AWAIT_CONTINUE(Tester, tester, close)
end},
#{desc => "close socket",
cmd => fun(#{sock := Sock} = State) ->
@@ -5541,14 +5530,14 @@ sc_lc_acceptor_response_tcp(InitState) ->
end},
#{desc => "announce ready (close)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, close),
+ ?SEV_ANNOUNCE_READY(Tester, close),
ok
end},
% Termination
#{desc => "await terminate",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -5557,10 +5546,7 @@ sc_lc_acceptor_response_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
SecAcceptorSeq =
@@ -5568,7 +5554,7 @@ sc_lc_acceptor_response_tcp(InitState) ->
%% *** Init part ***
#{desc => "await start",
cmd => fun(State) ->
- {Tester, Sock} = ev_await_start(),
+ {Tester, Sock} = ?SEV_AWAIT_START(),
{ok, State#{tester => Tester, sock => Sock}}
end},
#{desc => "monitor tester",
@@ -5578,15 +5564,13 @@ sc_lc_acceptor_response_tcp(InitState) ->
end},
#{desc => "announce ready (init)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, init),
- ok
+ ?SEV_ANNOUNCE_READY(Tester, init)
end},
%% The actual test
#{desc => "await continue (accept)",
cmd => fun(#{tester := Tester} = _State) ->
- ev_await_continue(Tester, tester, accept),
- ok
+ ok = ?SEV_AWAIT_CONTINUE(Tester, tester, accept)
end},
#{desc => "accept",
cmd => fun(#{sock := Sock} = State) ->
@@ -5601,14 +5585,13 @@ sc_lc_acceptor_response_tcp(InitState) ->
end},
#{desc => "announce ready (accept closed)",
cmd => fun(#{tester := Tester}) ->
- ev_ready(Tester, accept_closed),
- ok
+ ?SEV_ANNOUNCE_READY(Tester, accept_closed)
end},
%% Termination
#{desc => "await terminate (from tester)",
cmd => fun(#{tester := Tester} = State) ->
- case ev_await_terminate(Tester, tester) of
+ case ?SEV_AWAIT_TERMINATE(Tester, tester) of
ok ->
{ok, maps:remove(tester, State)};
{error, _} = ERROR ->
@@ -5617,10 +5600,7 @@ sc_lc_acceptor_response_tcp(InitState) ->
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
TesterSeq =
@@ -5650,49 +5630,46 @@ sc_lc_acceptor_response_tcp(InitState) ->
%% Start the primary server
#{desc => "order 'primary acceptor' start",
cmd => fun(#{prim_acc := Pid} = _State) ->
- ev_start(Pid),
+ ?SEV_ANNOUNCE_START(Pid),
ok
end},
#{desc => "await 'primary acceptor' ready (init)",
cmd => fun(#{prim_acc := Pid} = State) ->
- {ok, Sock} = ev_await_ready(Pid, prim_acc, init),
+ {ok, Sock} = ?SEV_AWAIT_READY(Pid, prim_acc, init),
{ok, State#{sock => Sock}}
end},
%% Start the secondary acceptor 1
#{desc => "order 'secondary acceptor 1' start",
cmd => fun(#{sec_acc1 := Pid, sock := Sock} = _State) ->
- ev_start(Pid, Sock),
+ ?SEV_ANNOUNCE_START(Pid, Sock),
ok
end},
#{desc => "await 'secondary acceptor 1' ready (init)",
cmd => fun(#{sec_acc1 := Pid} = _State) ->
- ev_await_ready(Pid, sec_acc1, init),
- ok
+ ok = ?SEV_AWAIT_READY(Pid, sec_acc1, init)
end},
%% Start the secondary acceptor 2
#{desc => "order 'secondary acceptor 2' start",
cmd => fun(#{sec_acc2 := Pid, sock := Sock} = _State) ->
- ev_start(Pid, Sock),
+ ?SEV_ANNOUNCE_START(Pid, Sock),
ok
end},
#{desc => "await 'secondary acceptor 2' ready (init)",
cmd => fun(#{sec_acc2 := Pid} = _State) ->
- ev_await_ready(Pid, sec_acc2, init),
- ok
+ ok = ?SEV_AWAIT_READY(Pid, sec_acc2, init)
end},
%% Start the secondary acceptor 3
#{desc => "order 'secondary acceptor 3' start",
cmd => fun(#{sec_acc3 := Pid, sock := Sock} = _State) ->
- ev_start(Pid, Sock),
+ ?SEV_ANNOUNCE_START(Pid, Sock),
ok
end},
#{desc => "await 'secondary acceptor 3' ready (init)",
cmd => fun(#{sec_acc3 := Pid} = _State) ->
- ev_await_ready(Pid, sec_acc3, init),
- ok
+ ok = ?SEV_AWAIT_READY(Pid, sec_acc3, init)
end},
@@ -5705,145 +5682,141 @@ sc_lc_acceptor_response_tcp(InitState) ->
#{desc => "order 'secondary acceptor 1' to continue (accept)",
cmd => fun(#{sec_acc1 := Pid} = _State) ->
- ev_continue(Pid, accept),
- ok
- end},
- #{desc => "sleep",
- cmd => fun(_) ->
- ?SLEEP(?SECS(1)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
ok
end},
+ ?SEV_SLEEP(?SECS(1)),
#{desc => "order 'secondary acceptor 2' to continue (accept)",
cmd => fun(#{sec_acc2 := Pid} = _State) ->
- ev_continue(Pid, accept),
- ok
- end},
- #{desc => "sleep",
- cmd => fun(_) ->
- ?SLEEP(?SECS(1)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
ok
end},
+ ?SEV_SLEEP(?SECS(1)),
#{desc => "order 'secondary acceptor 3' to continue (accept)",
cmd => fun(#{sec_acc3 := Pid} = _State) ->
- ev_continue(Pid, accept),
- ok
- end},
- #{desc => "sleep",
- cmd => fun(_) ->
- ?SLEEP(?SECS(1)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
ok
end},
+ ?SEV_SLEEP(?SECS(1)),
#{desc => "order 'primary acceptor' to continue",
cmd => fun(#{prim_acc := Pid} = _State) ->
- ev_continue(Pid, accept, ?SECS(5)),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, accept, ?SECS(5)),
ok
end},
#{desc => "await 'primary acceptor' ready (accept timeout)",
cmd => fun(#{prim_acc := Pid} = _State) ->
- ev_await_ready(Pid, prim_acc, accept_timeout),
- ok
+ ok = ?SEV_AWAIT_READY(Pid, prim_acc, accept_timeout)
end},
#{desc => "order 'primary acceptor' to continue (close)",
cmd => fun(#{prim_acc := Pid} = _State) ->
- ev_continue(Pid, close),
+ ?SEV_ANNOUNCE_CONTINUE(Pid, close),
ok
end},
#{desc => "await 'primary acceptor' ready (close)",
cmd => fun(#{prim_acc := Pid} = _State) ->
- ev_await_ready(Pid, prim_acc, close),
- ok
+ ok = ?SEV_AWAIT_READY(Pid, prim_acc, close)
end},
#{desc => "await 'secondary acceptor 1' ready (accept closed)",
cmd => fun(#{sec_acc1 := Pid} = _State) ->
- ev_await_ready(Pid, sec_acc1, accept_closed),
- ok
+ ok = ?SEV_AWAIT_READY(Pid, sec_acc1, accept_closed)
end},
#{desc => "await 'secondary acceptor 2' ready (accept closed)",
cmd => fun(#{sec_acc2 := Pid} = _State) ->
- ev_await_ready(Pid, sec_acc2, accept_closed),
- ok
+ ok = ?SEV_AWAIT_READY(Pid, sec_acc2, accept_closed)
end},
#{desc => "await 'secondary acceptor 3' ready (accept closed)",
cmd => fun(#{sec_acc3 := Pid} = _State) ->
- ev_await_ready(Pid, sec_acc3, accept_closed),
- ok
+ ok = ?SEV_AWAIT_READY(Pid, sec_acc3, accept_closed)
end},
%% Terminations
#{desc => "order 'secondary acceptor 3' to terminate",
cmd => fun(#{sec_acc3 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await 'secondary acceptor 3' termination",
cmd => fun(#{sec_acc3 := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(sec_acc3, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(sec_acc3, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order 'secondary acceptor 2' to terminate",
cmd => fun(#{sec_acc2 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await 'secondary acceptor 2' termination",
cmd => fun(#{sec_acc2 := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(sec_acc2, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(sec_acc2, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order 'secondary acceptor 1' to terminate",
cmd => fun(#{sec_acc1 := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await 'secondary acceptor 1' termination",
cmd => fun(#{sec_acc1 := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(sec_acc1, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(sec_acc1, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
#{desc => "order 'primary acceptor' to terminate",
cmd => fun(#{prim_acc := Pid} = _State) ->
- ev_terminate(Pid),
+ ?SEV_ANNOUNCE_TERMINATE(Pid),
ok
end},
#{desc => "await 'primary acceptor' termination",
cmd => fun(#{prim_acc := Pid} = State) ->
- ev_await_termination(Pid),
- {ok, maps:remove(prim_acc, State)}
+ case ?SEV_AWAIT_TERMINATION(Pid) of
+ ok ->
+ {ok, maps:remove(prim_acc, State)};
+ {error, _} = ERROR ->
+ ERROR
+ end
end},
%% *** We are done ***
- #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}
+ ?SEV_FINISH_NORMAL
],
i("start 'primary acceptor' evaluator"),
PrimAccInitState = InitState,
- PrimAcc = evaluator_start("prim-acceptor", PrimAcceptorSeq, PrimAccInitState),
+ PrimAcc = ?SEV_START("prim-acceptor", PrimAcceptorSeq, PrimAccInitState),
i("start 'secondary acceptor 1' evaluator"),
SecAccInitState = #{},
- SecAcc1 = evaluator_start("sec-acceptor-1", SecAcceptorSeq, SecAccInitState),
+ SecAcc1 = ?SEV_START("sec-acceptor-1", SecAcceptorSeq, SecAccInitState),
i("start 'secondary acceptor 2' evaluator"),
- SecAcc2 = evaluator_start("sec-acceptor-2", SecAcceptorSeq, SecAccInitState),
+ SecAcc2 = ?SEV_START("sec-acceptor-2", SecAcceptorSeq, SecAccInitState),
i("start 'secondary acceptor 3' evaluator"),
- SecAcc3 = evaluator_start("sec-acceptor-3", SecAcceptorSeq, SecAccInitState),
+ SecAcc3 = ?SEV_START("sec-acceptor-3", SecAcceptorSeq, SecAccInitState),
i("start 'tester' evaluator"),
TesterInitState = #{prim_acc => PrimAcc#ev.pid,
sec_acc1 => SecAcc1#ev.pid,
sec_acc2 => SecAcc2#ev.pid,
sec_acc3 => SecAcc3#ev.pid},
- Tester = evaluator_start("tester", TesterSeq, TesterInitState),
+ Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
i("await evaluator"),
- ok = await_evaluator_finish([PrimAcc, SecAcc1, SecAcc2, SecAcc3, Tester]).
+ ok = ?SEV_AWAIT_FINISH([PrimAcc, SecAcc1, SecAcc2, SecAcc3, Tester]).
@@ -5881,229 +5854,6 @@ which_addr2(Domain, [_|IFO]) ->
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% An evaluator is a process that executes a command sequence.
-%% A test case will consist of atleast one evaluator (one for
-%% each actor).
-%% The evaluator process *always* run locally. Which means that
-%% it will act as a "proxy" for remote nodes in necessary.
-%% When the command sequence has been processed, the final state
-%% will be used as exit reason.
-%% A successful command shall evaluate to ok | {ok, NewState}
-
--spec evaluator_start(Name, Seq, Init) -> socket_test_evaluator:ev() when
- Name :: string(),
- Seq :: [socket_test_evaluator:command()],
- Init :: socket_test_evaluator:initial_evaluator_state().
-
-evaluator_start(Name, Seq, Init)
- when is_list(Name) andalso is_list(Seq) andalso (Seq =/= []) ->
- Init2 = Init#{parent => self()},
- {Pid, MRef} = erlang:spawn_monitor(
- fun() -> evaluator_init(Name, Seq, Init2) end),
- ?MKEV(Name, Pid, MRef).
-
-evaluator_init(Name, Seq, Init) ->
- put(sname, Name),
- evaluator_loop(1, Seq, Init).
-
-evaluator_loop(_ID, [], FinalState) ->
- exit(FinalState);
-evaluator_loop(ID, [#{desc := Desc,
- cmd := Cmd}|Cmds], State) when is_function(Cmd, 1) ->
- ei("evaluate command ~2w: ~s", [ID, Desc]),
- try Cmd(State) of
- ok ->
- evaluator_loop(ID + 1, Cmds, State);
- {ok, NewState} ->
- evaluator_loop(ID + 1, Cmds, NewState);
- {error, Reason} ->
- ee("command ~w failed: "
- "~n Reason: ~p", [ID, Reason]),
- exit({command_failed, ID, Reason, State})
- catch
- C:E:S ->
- ee("command ~w crashed: "
- "~n Class: ~p"
- "~n Error: ~p"
- "~n Call Stack: ~p", [ID, C, E, S]),
- exit({command_crashed, ID, {C,E,S}, State})
- end.
-
-await_evaluator_finish(Evs) ->
- await_evaluator_finish(Evs, []).
-
-await_evaluator_finish([], []) ->
- ok;
-await_evaluator_finish([], Fails) ->
- Fails;
-await_evaluator_finish(Evs, Fails) ->
- receive
- {'DOWN', _MRef, process, Pid, normal} ->
- case lists:keysearch(Pid, #ev.pid, Evs) of
- {value, #ev{name = Name}} ->
- i("evaluator '~s' (~p) success", [Name, Pid]),
- NewEvs = lists:keydelete(Pid, #ev.pid, Evs),
- await_evaluator_finish(NewEvs, Fails);
- false ->
- i("unknown process ~p died (normal)", [Pid]),
- await_evaluator_finish(Evs, Fails)
- end;
- {'DOWN', _MRef, process, Pid, Reason} ->
- case lists:keysearch(Pid, #ev.pid, Evs) of
- {value, #ev{name = Name}} ->
- i("evaluator '~s' (~p) failed", [Name, Pid]),
- NewEvs = lists:keydelete(Pid, #ev.pid, Evs),
- await_evaluator_finish(NewEvs, [{Pid, Reason}|Fails]);
- false ->
- i("unknown process ~p died: "
- "~n ~p", [Pid, Reason]),
- await_evaluator_finish(Evs, Fails)
- end
- end.
-
-
-ei(F) ->
- ei(F, []).
-ei(F, A) ->
- eprint("", F, A).
-
-ee(F) ->
- ee(F, []).
-ee(F, A) ->
- eprint("<ERROR> ", F, A).
-
-eprint(Prefix, F, A) ->
- %% The two prints is to get the output both in the shell (for when
- %% "personal" testing is going on) and in the logs.
- FStr = f("[~s][~s][~p] ~s" ++ F,
- [formated_timestamp(), get(sname), self(), Prefix | A]),
- io:format(user, FStr ++ "~n", []),
- io:format(FStr, []).
-
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-ev_start(Pid) ->
- ev_announce(Pid, start, undefined).
-
-ev_start(Pid, Extra) ->
- ev_announce(Pid, start, undefined, Extra).
-
-ev_continue(Pid, Slogan) ->
- ev_announce(Pid, continue, Slogan).
-
-ev_continue(Pid, Slogan, Extra) ->
- ev_announce(Pid, continue, Slogan, Extra).
-
-ev_ready(Pid, Slogan) ->
- ev_announce(Pid, ready, Slogan).
-
-ev_ready(Pid, Slogan, Extra) ->
- ev_announce(Pid, ready, Slogan, Extra).
-
-ev_terminate(Pid) ->
- Pid ! {terminate, self()}.
-
-ev_announce(To, Tag, Slogan) ->
- ev_announce(To, Tag, Slogan, undefined).
-
-ev_announce(To, Tag, Slogan, Extra) ->
- To ! {Tag, self(), Slogan, Extra}.
-
-ev_await_start() ->
- receive
- {start, Pid, _, undefined} ->
- Pid;
- {start, Pid, _, Extra} ->
- {Pid, Extra}
- end.
-
-ev_await_continue(Pid, Name, Slogan) ->
- ev_await_continue(Pid, Name, Slogan, []).
-ev_await_continue(Pid, Name, Slogan, Pids) when is_pid(Pid) andalso is_list(Pids) ->
- ev_await(Pid, Name, continue, Slogan, Pids).
-
-ev_await_ready(Pid, Name, Slogan) ->
- ev_await_ready(Pid, Name, Slogan, []).
-ev_await_ready(Pid, Name, Slogan, Pids) when is_pid(Pid) andalso is_list(Pids) ->
- ev_await(Pid, Name, ready, Slogan, Pids).
-
-ev_await_terminate(Pid, Name) ->
- ev_await_terminate(Pid, Name, []).
-ev_await_terminate(Pid, Name, Pids) ->
- receive
- {terminate, Pid} ->
- ok;
- {'DOWN', _, process, Pid, Reason} ->
- ee("Unexpected DOWN regarding ~w ~p: "
- "~n ~p", [Name, Pid, Reason]),
- {error, {unexpected_exit, Name}};
- {'DOWN', _, process, DownPid, Reason} ->
- case ev_await_check_down(DownPid, Reason, Pids) of
- ok ->
- ei("DOWN from unknown process ~p: "
- "~n ~p", [DownPid, Reason]),
- ev_await_terminate(Pid, Name, Pids);
- {error, _} = ERROR ->
- ERROR
- end
- end.
-
-ev_await_termination(Pid) ->
- receive
- {'DOWN', _, process, Pid, _} ->
- ok
- end.
-
-%% We expect a message from Pid, but we also watch for DOWN from
-%% both Pid and Pids, in which case the test has failed!
-ev_await(Pid, Name, Tag, Slogan, Pids) ->
- receive
- {Tag, Pid, Slogan, undefined} ->
- ok;
- {Tag, Pid, Slogan, Extra} ->
- {ok, Extra};
- {'DOWN', _, process, Pid, Reason} ->
- ee("Unexpected DOWN regarding ~w ~p: "
- "~n ~p", [Name, Pid, Reason]),
- {error, {unexpected_exit, Name}};
- {'DOWN', _, process, DownPid, Reason} ->
- case ev_await_check_down(DownPid, Reason, Pids) of
- ok ->
- ei("DOWN from unknown process ~p: "
- "~n ~p", [DownPid, Reason]),
- ev_await(Pid, Name, Tag, Slogan, Pids);
- {error, _} = ERROR ->
- ERROR
- end
- after infinity ->
- ei("ev_await -> timeout for msg from ~p (~w): "
- "~n Messages: ~p", [Pid, Name, pi(messages)]),
- ev_await(Pid, Name, Tag, Slogan, Pids)
- end.
-
-ev_await_check_down(DownPid, DownReason, Pids) ->
- case lists:keymember(DownPid, 1, Pids) of
- {value, {_, Name}} ->
- ee("Unexpected DOWN regarding ~w ~p: "
- "~n ~p", [Name, DownPid, DownReason]),
- {error, {unexpected_exit, Name}};
- false ->
- ok
- end.
-
-
-pi(Item) ->
- pi(self(), Item).
-
-pi(Pid, Item) ->
- {Item, Info} = process_info(Pid, Item),
- Info.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
sock_open(Domain, Type, Proto) ->
try socket:open(Domain, Type, Proto) of
{ok, Socket} ->
diff --git a/erts/emulator/test/socket_test_evaluator.erl b/erts/emulator/test/socket_test_evaluator.erl
index 8498ef6a0c..bad8c92dec 100644
--- a/erts/emulator/test/socket_test_evaluator.erl
+++ b/erts/emulator/test/socket_test_evaluator.erl
@@ -44,6 +44,12 @@
await_termination/1, await_termination/2
]).
+%% Utility functions
+-export([
+ iprint/2, % Info printouts
+ eprint/2 % Error printouts
+ ]).
+
-export_type([
ev/0,
initial_evaluator_state/0,
@@ -110,22 +116,22 @@ loop(_ID, [], FinalState) ->
exit(FinalState);
loop(ID, [#{desc := Desc,
cmd := Cmd}|Cmds], State) when is_function(Cmd, 1) ->
- i("evaluate command ~2w: ~s", [ID, Desc]),
+ iprint("evaluate command ~2w: ~s", [ID, Desc]),
try Cmd(State) of
ok ->
loop(ID + 1, Cmds, State);
{ok, NewState} ->
loop(ID + 1, Cmds, NewState);
{error, Reason} ->
- e("command ~w failed: "
- "~n Reason: ~p", [ID, Reason]),
+ eprint("command ~w failed: "
+ "~n Reason: ~p", [ID, Reason]),
exit({command_failed, ID, Reason, State})
catch
C:E:S ->
- e("command ~w crashed: "
- "~n Class: ~p"
- "~n Error: ~p"
- "~n Call Stack: ~p", [ID, C, E, S]),
+ eprint("command ~w crashed: "
+ "~n Class: ~p"
+ "~n Error: ~p"
+ "~n Call Stack: ~p", [ID, C, E, S]),
exit({command_crashed, ID, {C,E,S}, State})
end.
@@ -147,28 +153,22 @@ await_finish(Evs, Fails) ->
{'DOWN', _MRef, process, Pid, normal} ->
case lists:keysearch(Pid, #ev.pid, Evs) of
{value, #ev{name = Name}} ->
-
-
- i("evaluator '~s' (~p) success", [Name, Pid]),
-
-
-
-
+ iprint("evaluator '~s' (~p) success", [Name, Pid]),
NewEvs = lists:keydelete(Pid, #ev.pid, Evs),
await_finish(NewEvs, Fails);
false ->
- i("unknown process ~p died (normal)", [Pid]),
+ iprint("unknown process ~p died (normal)", [Pid]),
await_finish(Evs, Fails)
end;
{'DOWN', _MRef, process, Pid, Reason} ->
case lists:keysearch(Pid, #ev.pid, Evs) of
{value, #ev{name = Name}} ->
- i("evaluator '~s' (~p) failed", [Name, Pid]),
+ iprint("evaluator '~s' (~p) failed", [Name, Pid]),
NewEvs = lists:keydelete(Pid, #ev.pid, Evs),
await_finish(NewEvs, [{Pid, Reason}|Fails]);
false ->
- i("unknown process ~p died: "
- "~n ~p", [Pid, Reason]),
+ iprint("unknown process ~p died: "
+ "~n ~p", [Pid, Reason]),
await_finish(Evs, Fails)
end
end.
@@ -412,25 +412,25 @@ await(ExpPid, Name, Announcement, Slogan, OtherPids)
{Announcement, Pid, Slogan, Extra} when (Pid =:= ExpPid) ->
{ok, Extra};
{'DOWN', _, process, Pid, Reason} when (Pid =:= ExpPid) ->
- e("Unexpected DOWN regarding ~w ~p: "
- "~n ~p", [Name, Pid, Reason]),
+ eprint("Unexpected DOWN regarding ~w ~p: "
+ "~n ~p", [Name, Pid, Reason]),
{error, {unexpected_exit, Name}};
{'DOWN', _, process, OtherPid, Reason} ->
case check_down(OtherPid, Reason, OtherPids) of
ok ->
- i("DOWN from unknown process ~p: "
- "~n ~p", [OtherPid, Reason]),
+ iprint("DOWN from unknown process ~p: "
+ "~n ~p", [OtherPid, Reason]),
await(ExpPid, Name, Announcement, Slogan, OtherPids);
{error, _} = ERROR ->
ERROR
end
after infinity -> % For easy debugging, just change to some valid time (5000)
- i("await -> timeout for msg from ~p (~w): "
- "~n Announcement: ~p"
- "~n Slogan: ~p"
- "~nwhen"
- "~n Messages: ~p",
- [ExpPid, Name, Announcement, Slogan, pi(messages)]),
+ iprint("await -> timeout for msg from ~p (~w): "
+ "~n Announcement: ~p"
+ "~n Slogan: ~p"
+ "~nwhen"
+ "~n Messages: ~p",
+ [ExpPid, Name, Announcement, Slogan, pi(messages)]),
await(ExpPid, Name, Announcement, Slogan, OtherPids)
end.
@@ -444,8 +444,8 @@ pi(Pid, Item) ->
check_down(Pid, DownReason, Pids) ->
case lists:keymember(Pid, 1, Pids) of
{value, {_, Name}} ->
- e("Unexpected DOWN regarding ~w ~p: "
- "~n ~p", [Name, Pid, DownReason]),
+ eprint("Unexpected DOWN regarding ~w ~p: "
+ "~n ~p", [Name, Pid, DownReason]),
{error, {unexpected_exit, Name}};
false ->
ok
@@ -458,14 +458,10 @@ f(F, A) ->
lists:flatten(io_lib:format(F, A)).
-%% i(F) ->
-%% i(F, []).
-i(F, A) ->
+iprint(F, A) ->
print("", F, A).
-%% e(F) ->
-%% e(F, []).
-e(F, A) ->
+eprint(F, A) ->
print("<ERROR> ", F, A).
print(Prefix, F, A) ->
diff --git a/erts/emulator/test/socket_test_evaluator.hrl b/erts/emulator/test/socket_test_evaluator.hrl
index 1fb42a33b2..2ebae9c852 100644
--- a/erts/emulator/test/socket_test_evaluator.hrl
+++ b/erts/emulator/test/socket_test_evaluator.hrl
@@ -21,6 +21,10 @@
-ifndef(socket_test_evaluator).
-define(socket_test_evaluator, true).
+-record(ev, {name :: string(),
+ pid :: pid(),
+ mref :: reference()}).
+
-define(SEV, socket_test_evaluator).
-define(SEV_START(N, S, IS), ?SEV:start(N, S, IS)).
@@ -44,14 +48,20 @@
-define(SEV_AWAIT_TERMINATION(P), ?SEV:await_termination(P)).
-define(SEV_AWAIT_TERMINATION(P, R), ?SEV:await_termination(P, R)).
--record(ev, {name :: string(),
- pid :: pid(),
- mref :: reference()}).
+-define(SEV_IPRINT(F, A), ?SEV:iprint(F, A)).
+-define(SEV_IPRINT(F), ?SEV_IPRINT(F, [])).
+-define(SEV_EPRINT(F, A), ?SEV:eprint(F, A)).
+-define(SEV_EPRINT(F), ?SEV_EPRINT(F, [])).
--define(FINISH_NORMAL, #{desc => "finish",
- cmd => fun(_) ->
- {ok, normal}
- end}).
+-define(SEV_SLEEP(T), #{desc => "sleep",
+ cmd => fun(_) ->
+ ?SLEEP(T),
+ ok
+ end}).
+-define(SEV_FINISH_NORMAL, #{desc => "finish",
+ cmd => fun(_) ->
+ {ok, normal}
+ end}).
-endif. % -ifdef(socket_test_evaluator).
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-18 22:05:21 +0000