1 files changed, 131 insertions, 0 deletions
diff --git a/lib/diameter/test/diameter_sync_SUITE.erl b/lib/diameter/test/diameter_sync_SUITE.erl
new file mode 100644
index 0000000000..1b1fec8281
--- /dev/null
+++ b/lib/diameter/test/diameter_sync_SUITE.erl
@@ -0,0 +1,131 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2010-2011. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%
+%% Tests of the server implemented by diameter_sync.erl.
+%%
+
+-module(diameter_sync_SUITE).
+
+-export([suite/0,
+         all/0,
+         init_per_suite/1,
+         end_per_suite/1]).
+
+%% testcases
+-export([scramble/1,
+         call/1,
+         cast/1,
+         timeout/1,
+         flush/1]).
+
+-define(sync, diameter_sync).
+-define(util, diameter_util).
+
+-define(TIMEOUT, infinity).
+
+%% ===========================================================================
+
+suite() ->
+    [{timetrap, {seconds, 10}}].
+
+all() ->
+    [scramble | tc()].
+
+tc() ->
+    [call,
+     cast,
+     timeout,
+     flush].
+
+init_per_suite(Config) ->
+    ok = diameter:start(),
+    Config.
+
+end_per_suite(_Config) ->
+    ok = diameter:stop().
+
+%% ===========================================================================
+
+scramble(Config) ->
+    [] = ?util:run(?util:scramble([{?MODULE, [F, Config]} || F <- tc()])).
+
+call(_) ->
+    Ref = make_ref(),
+    Q = {q, Ref},
+    F = fun() -> Ref end,
+    Ref = ?sync:call(Q, F, infinity, ?TIMEOUT),
+    Ref = ?sync:call(Q, F, 0, infinity),
+    Ref = call(Q, F),
+    Ref = call(Q, {fun(_) -> Ref end, x}),
+    timeout = call(Q, fun() -> exit(unexpected) end),
+    {_,_,_} = call(Q, {erlang, now, []}),
+    {_,_,_} = call(Q, [fun erlang:now/0]).
+
+cast(_) ->
+    Ref = make_ref(),
+    Q = {q, Ref},
+    false = ?sync:carp(Q),
+    [] = ?sync:pids(Q),
+    %% Queue a request that blocks until we send it Ref and another
+    %% that exits with Ref.
+    ok = cast(Q, fun() -> receive Ref -> ok end end),
+    ok = cast(Q, fun() -> exit(Ref) end),
+    [_,Pid] = ?sync:pids(Q),
+    %% Ensure some expected truths ...
+    2 = ?sync:pending(Q),
+    true = 2 =< ?sync:pending(),
+    true = lists:member(Q, ?sync:queues()),
+    %% ... and that the max number of requests is respected.
+    rejected = ?sync:call(Q, {erlang, now, []}, 1, ?TIMEOUT),
+    rejected = ?sync:cast(Q, {erlang, now, []}, 1, ?TIMEOUT),
+    %% Monitor on the identifiable request and see that exits when we
+    %% let the blocking request finish.
+    MRef = erlang:monitor(process, Pid),
+    {value, P} = ?sync:carp(Q),
+    P ! Ref,
+    Ref = receive
+              {'DOWN', MRef, process, _, Reason} ->
+                  Reason
+          after ?TIMEOUT ->
+                  false
+          end.
+
+timeout(_) ->
+    Q = make_ref(),
+    ok = ?sync:cast(Q, {timer, sleep, [2000]}, infinity, 2000),
+    timeout = ?sync:call(Q, fun() -> ok end, infinity, 1000).
+
+flush(_) ->
+    Q = make_ref(),
+    F = {timer, sleep, [2000]},
+    ok = cast(Q, F),
+    ok = cast(Q, F),
+    1 = ?sync:flush(Q).
+
+%% ===========================================================================
+
+call(Q, Req) ->
+    sync(call, Q, Req).
+
+cast(Q, Req) ->
+    sync(cast, Q, Req).
+
+sync(F, Q, Req) ->
+    ?sync:F(Q, Req, infinity, infinity).