%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 1998-2013. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%% http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%
%% %CopyrightEnd%
%%
-module(ose_SUITE).
%-compile(export_all).
-export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1,
init_per_group/2,end_per_group/2,init_per_testcase/2,
end_per_testcase/2]).
-export([
basic/1,stress/1,multi_msg_numbers/1,multi_mailboxes/1,
hunt/1,multi_hunt/1,dehunt/1,multi_dehunt/1,
attach/1,multi_attach/1,detach/1,multi_detach/1,
open_errors/1,close_errors/1,get_id_errors/1,get_name_errors/1,
hunt_errors/1,dehunt_errors/1,attach_errors/1,detach_errors/1,
send_errors/1,send_w_s_errors/1,listen_errors/1
]).
-define(INTERFACE,ose).
init_per_testcase(_Func, Config) ->
Config.
end_per_testcase(_Func, _Config) ->
ok.
suite() -> [{timeout,{30,seconds}}].
all() ->
[
basic,stress,multi_msg_numbers,multi_mailboxes,
hunt,multi_hunt,dehunt,multi_dehunt,
attach,multi_attach,detach,multi_detach,
open_errors,close_errors,get_id_errors,get_name_errors,
hunt_errors,dehunt_errors,attach_errors,detach_errors,
send_errors,send_w_s_errors,listen_errors
].
groups() ->
[].
init_per_suite(Config) ->
case os:type() of
{ose,_} ->
Config;
_Else ->
{skip,"Only run on OSE"}
end.
end_per_suite(_Config) ->
ok.
init_per_group(_GroupName, Config) ->
Config.
end_per_group(_GroupName, Config) ->
Config.
basic(_Config) ->
[P1,P2] = multi_open(2,[42]),
P1Id = ?INTERFACE:get_id(P1),
P2Id = ?INTERFACE:get_id(P2),
ok = ?INTERFACE:send(P2,P1Id,42,<<"ping">>),
receive
{message,P1,V1} ->
{P2Id,P1Id,42,<<"ping">>} = V1,
?INTERFACE:send(P1,P2Id,42,<<"pong">>);
Else1 ->
ct:fail({got_wrong_message,Else1})
end,
receive
{message,P2,V2} ->
{P1Id,P2Id,42,<<"pong">>} = V2;
Else2 ->
ct:fail({got_wrong_message,Else2})
end,
?INTERFACE:close(P1),
?INTERFACE:close(P2).
%% Send 1000 messages and see if we can cope and that msg order is preserved
stress(_Config) ->
Iterations = 1000,
[P1,P2] = multi_open(2,[42]),
P1Id = ?INTERFACE:get_id(P1),
P2Id = ?INTERFACE:get_id(P2),
spawn(fun() ->
n(fun(N) ->
Msg = [<<"ping">>|integer_to_list(N)],
?INTERFACE:send(P2,P1Id,42,Msg)
end,Iterations)
end),
timer:sleep(100),
n(fun(N) ->
receive
{message,P1,Value} ->
Int = integer_to_binary(N),
{P2Id,P1Id,42,<<"ping",Int/binary>>} = Value,
ok;
Else ->
ct:fail({got_wrong_message,Else})
end
end,Iterations),
?INTERFACE:close(P1),
?INTERFACE:close(P2).
%% Listen to 1000 different message numbers and send some random messages
multi_msg_numbers(_Config) ->
Iterations = 100,
[P1,P2] = multi_open(2,lists:seq(2000,3000)),
P1Id = ?INTERFACE:get_id(P1),
n(fun(_) ->
Num = random:uniform(1000)+2000,
?INTERFACE:send(P2,P1Id,Num,<<"ping",(integer_to_binary(Num))/binary>>)
end,Iterations),
n(fun(_) ->
receive
{message,P1,{_,_,Id,<<"ping",Num/binary>>}} when Id > 2000;
Id =< 3000 ->
Id = binary_to_integer(Num),
ok;
Else ->
ct:fail({got_wrong_message,Else})
end
end,Iterations),
?INTERFACE:close(P1),
?INTERFACE:close(P2).
%% Create 100 mailboxes and send messages to them
multi_mailboxes(_Config) ->
Mailboxes = 100,
[P1|MBs] = multi_open(Mailboxes,[42]),
[?INTERFACE:send(P1,?INTERFACE:get_id(P),42,[<<"ping">>,?INTERFACE:get_name(P,?INTERFACE:get_id(P))]) || P <- MBs],
[receive
{message,P,Value} ->
Name = ?INTERFACE:get_name(P,?INTERFACE:get_id(P)),
{_,_,42,<<"ping",Name/binary>>} = Value,
ok
end || P <- MBs],
[?INTERFACE:close(P) || P <- [P1|MBs]],
ok.
hunt(_Config) ->
[P1,P2] = multi_open(2,[]),
Ref = ?INTERFACE:hunt(P1,"p2"),
receive
{mailbox_up,P1,Ref,Pid} ->
Pid = ?INTERFACE:get_id(P2),
?INTERFACE:close(P1),
?INTERFACE:close(P2);
Else ->
ct:fail({got_wrong_message,Else,Ref})
end.
multi_hunt(_Config) ->
Iterations = 100,
P = ?INTERFACE:open("p"),
Refs = [?INTERFACE:hunt(P,"p"++integer_to_list(N))|| N <- lists:seq(1,Iterations)],
Pids = [begin
Prt = ?INTERFACE:open("p"++integer_to_list(N)),
Pid = ?INTERFACE:get_id(Prt),
?INTERFACE:close(Prt),
Pid
end || N <- lists:seq(1,Iterations)],
[receive
{mailbox_up,P,Ref,Pid} ->
ok
after 10 ->
ct:fail({did_not_get,Pid,Ref})
end || {Pid,Ref} <- lists:zip(Pids,Refs)],
?INTERFACE:close(P).
dehunt(_Config) ->
[P1] = multi_open(1,[]),
Ref = ?INTERFACE:hunt(P1,"p2"),
receive
_Else -> ct:fail({got,_Else})
after 1000 ->
ok
end,
P2 = ?INTERFACE:open("p2"),
% Make sure any messages are sent
receive after 10 -> ok end,
ok = ?INTERFACE:dehunt(P1,Ref),
% Make sure no messages are received
receive
_Else2 -> ct:fail({got,_Else2})
after 1000 ->
?INTERFACE:close(P1),
?INTERFACE:close(P2)
end.
%%%
%%% This testcase basically:
%%% spawn 10 processes that in parallel
%%% adds some hunts for different OSE processes
%%% maybe create hunted OSE process
%%% dehunt half of the hunts
%%% create more hunts
%%% if not created create hunted OSE process
%%% veryify that all expected hunt messages are received
%%% verify that all processes exited correctly
%%%
%%% This complex test is done to make sure that the internal handling
%%% of dehunt works as expected.
%%%
multi_dehunt(_Config) ->
[P1] = multi_open(1,[]),
Scenario =
fun(Iterations) ->
Hunted = "p"++integer_to_list(Iterations),
%% Start a couple of hunts
Refs = [?INTERFACE:hunt(P1,Hunted) || _ <- lists:seq(1,Iterations)],
%% We alternate if the process is opened before or after the dehunt
P2O = if Iterations rem 2 == 0 ->
?INTERFACE:open(Hunted);
true ->
undefined
end,
%% Remove half of them
{RemRefs,_} = lists:mapfoldl(fun(Ref,Acc) when Acc rem 2 == 0 ->
ok = ?INTERFACE:dehunt(P1,Ref),
{[],Acc+1};
(Ref,Acc) ->
{Ref,Acc+1}
end,0,Refs),
%% Add some new ones
NewRefs = [?INTERFACE:hunt(P1,Hunted)
|| _ <- lists:seq(1,Iterations div 4)]
++ lists:flatten(RemRefs),
P2 = if P2O == undefined ->
?INTERFACE:open(Hunted);
true ->
P2O
end,
P2Id = ?INTERFACE:get_id(P2),
%% Receive all the expected ones
lists:foreach(fun(Ref) ->
receive
{mailbox_up,P1,Ref,P2Id} ->
ok
after 1000 ->
io:format("Flush: ~p~n",[flush()]),
io:format("~p~n",[{Iterations,{did_not_get, Ref}}]),
ok = Ref
end
end,NewRefs),
%% Check that no other have arrived
receive
_Else ->
io:format("Flush: ~p~n",[flush()]),
io:format("~p~n",[{Iterations,{got, _Else}}]),
ok = _Else
after 100 ->
ok
end,
?INTERFACE:close(P2)
end,
Self = self(),
n(fun(N) ->
spawn(fun() -> Self !
Scenario(N*25)
end),
ok
end,10),
n(fun(_N) ->
receive ok -> ok
after 60000 -> ct:fail(failed)
end
end,10),
?INTERFACE:close(P1).
attach(_Config) ->
[P1,P2] = multi_open(2,[]),
P2Id = ?INTERFACE:get_id(P2),
Ref = ?INTERFACE:attach(P1,P2Id),
?INTERFACE:close(P2),
receive
{mailbox_down,P1,Ref,P2Id} ->
?INTERFACE:close(P1);
_Else ->
ct:fail({got,_Else, {P1,Ref,P2Id}})
after 1000 ->
ct:fail({did_not_get,P1,Ref,P2Id})
end.
multi_attach(_Config) ->
Iterations = 100,
[P1|Pids] = multi_open(Iterations,[]),
Refs = [{?INTERFACE:get_id(Pid),?INTERFACE:attach(P1,?INTERFACE:get_id(Pid))} || Pid <- Pids],
[?INTERFACE:close(Pid) || Pid <- Pids],
[receive
{mailbox_down,P1,Ref,Pid} ->
ok
after 10000 ->
ct:fail({did_not_get,Pid,Ref})
end || {Pid,Ref} <- Refs],
?INTERFACE:close(P1).
detach(_Config) ->
[P1,P2] = multi_open(2,[]),
P2Id = ?INTERFACE:get_id(P2),
Ref = ?INTERFACE:attach(P1,P2Id),
receive
_Else -> ct:fail({got,_Else})
after 100 ->
ok
end,
?INTERFACE:close(P2),
% Make sure any messages are sent
receive after 10 -> ok end,
?INTERFACE:detach(P1,Ref),
% Make sure no messages are received
receive
_Else2 -> ct:fail({got,_Else2})
after 1000 ->
?INTERFACE:close(P1)
end.
%%%
%%% This testcase basically:
%%% spawn 10 processes that in parallel
%%% adds some attach for different OSE processes
%%% maybe close OSE process
%%% dehunt half of the hunts
%%% create more hunts
%%% if not closed close attached OSE process
%%% veryify that all expected attach messages are received
%%% verify that all processes exited correctly
%%%
%%% This complex test is done to make sure that the internal handling
%%% of dehunt works as expected.
%%%
multi_detach(_Config) ->
[P1] = multi_open(1,[]),
Scenario =
fun(Iterations) ->
Attached = ?INTERFACE:open("p"++integer_to_list(Iterations)),
AttachedId = ?INTERFACE:get_id(Attached),
%% Start a couple of attachs
Refs = [?INTERFACE:attach(P1,AttachedId) || _ <- lists:seq(1,Iterations)],
%% We alternate if the process is closed before or after the detach
P2O = if Iterations rem 2 == 0 ->
?INTERFACE:close(Attached);
true ->
undefined
end,
%% Remove half of them
{RemRefs,_} = lists:mapfoldl(fun(Ref,Acc) when Acc rem 2 == 0 ->
ok = ?INTERFACE:detach(P1,Ref),
{[],Acc+1};
(Ref,Acc) ->
{Ref,Acc+1}
end,0,Refs),
%% Add some new ones
NewRefs = [?INTERFACE:attach(P1,AttachedId)
|| _ <- lists:seq(1,Iterations div 4)]
++ lists:flatten(RemRefs),
if P2O == undefined ->
?INTERFACE:close(Attached);
true ->
P2O
end,
%% Receive all the expected ones
lists:foreach(fun(Ref) ->
receive
{mailbox_down,P1,Ref,AttachedId} ->
ok
after 1000 ->
io:format("Flush: ~p~n",[flush()]),
io:format("~p~n",[{Iterations,{did_not_get, Ref}}]),
ok = Ref
end
end,NewRefs),
%% Check that no other have arrived
receive
_Else ->
io:format("Flush: ~p~n",[flush()]),
io:format("~p~n",[{Iterations,{got, _Else}}]),
ok = _Else
after 100 ->
ok
end
end,
Self = self(),
n(fun(N) ->
spawn(fun() -> Self !
Scenario(N*5)
end),
ok
end,10),
n(fun(_N) ->
receive ok -> ok
after 60000 -> ct:fail(failed)
end
end,10),
?INTERFACE:close(P1).
open_errors(_Config) ->
{'EXIT',{badarg,[{?INTERFACE,open,[inval],_}|_]}} =
(catch ?INTERFACE:open(inval)),
{'EXIT',{badarg,[{?INTERFACE,open,[["p"|1]],_}|_]}} =
(catch ?INTERFACE:open(["p"|1])),
{'EXIT',{badarg,[{?INTERFACE,open,[["p",1234]],_}|_]}} =
(catch ?INTERFACE:open(["p",1234])),
ok.
close_errors(_Config) ->
{'EXIT',{badarg,[{?INTERFACE,close,[inval],_}|_]}} =
(catch ?INTERFACE:close(inval)),
P1 = ?INTERFACE:open("p1"),
ok = ?INTERFACE:close(P1),
ok = ?INTERFACE:close(P1).
get_id_errors(_Config) ->
{'EXIT',{badarg,[{?INTERFACE,get_id,[inval],_}|_]}} =
(catch ?INTERFACE:get_id(inval)),
P1 = ?INTERFACE:open("p1"),
ok = ?INTERFACE:close(P1),
{'EXIT',{badarg,[{?INTERFACE,get_id,[P1],_}|_]}} =
(catch ?INTERFACE:get_id(P1)),
ok.
get_name_errors(_Config) ->
P1 = ?INTERFACE:open("p1"),
{'EXIT',{badarg,[{?INTERFACE,get_name,[P1,inval],_}|_]}} =
(catch ?INTERFACE:get_name(P1,inval)),
undefined = ?INTERFACE:get_name(P1,1234),
P2 = ?INTERFACE:open("p2"),
P2Id = ?INTERFACE:get_id(P2),
ok = ?INTERFACE:close(P1),
{'EXIT',{badarg,[{?INTERFACE,get_name,[P1,P2Id],_}|_]}} =
(catch ?INTERFACE:get_name(P1,P2Id)),
?INTERFACE:close(P2),
P3 = ?INTERFACE:open([255]),
<<255>> = ?INTERFACE:get_name(P3, ?INTERFACE:get_id(P3)),
?INTERFACE:close(P3),
ok.
hunt_errors(_Config) ->
{'EXIT',{badarg,[{?INTERFACE,hunt,[inval,"hello"],_}|_]}} =
(catch ?INTERFACE:hunt(inval,"hello")),
P1 = ?INTERFACE:open("p1"),
{'EXIT',{badarg,[{?INTERFACE,hunt,[P1,["hello",12345]],_}|_]}} =
(catch ?INTERFACE:hunt(P1,["hello",12345])),
P2 = ?INTERFACE:open(<<255>>),
P2Pid = ?INTERFACE:get_id(P2),
Ref = ?INTERFACE:hunt(P1,[255]),
receive
{mailbox_up,P1,Ref,P2Pid} ->
ok;
Else ->
ct:fail({got,Else,{mailbox_up,P1,Ref,P2Pid}})
after 150 ->
ct:fail({did_not_get,{mailbox_up,P1,Ref,P2Pid}})
end,
ok = ?INTERFACE:close(P1),
ok = ?INTERFACE:close(P2),
{'EXIT',{badarg,[{?INTERFACE,hunt,[P1,["hello"]],_}|_]}} =
(catch ?INTERFACE:hunt(P1,["hello"])),
ok.
dehunt_errors(_Config) ->
P1 = ?INTERFACE:open("p1"),
Ref = ?INTERFACE:hunt(P1,"p2"),
{'EXIT',{badarg,[{?INTERFACE,dehunt,[inval,Ref],_}|_]}} =
(catch ?INTERFACE:dehunt(inval,Ref)),
{'EXIT',{badarg,[{?INTERFACE,dehunt,[P1,inval],_}|_]}} =
(catch ?INTERFACE:dehunt(P1,inval)),
ok = ?INTERFACE:dehunt(P1,Ref),
ok = ?INTERFACE:dehunt(P1,Ref),
ok = ?INTERFACE:close(P1),
{'EXIT',{badarg,[{?INTERFACE,dehunt,[P1,Ref],_}|_]}} =
(catch ?INTERFACE:dehunt(P1,Ref)),
case ?INTERFACE of
ose -> ok;
_ ->
P2 = ?INTERFACE:open("p2"),
ok = ?INTERFACE:close(P2)
end,
receive
Else -> ct:fail({got,Else})
after 100 ->
ok
end.
attach_errors(_Config) ->
P1 = ?INTERFACE:open("p1"),
P2 = ?INTERFACE:open("p2"),
P2Id = ?INTERFACE:get_id(P2),
{'EXIT',{badarg,[{?INTERFACE,attach,[inval,P2Id],_}|_]}} =
(catch ?INTERFACE:attach(inval,P2Id)),
{'EXIT',{badarg,[{?INTERFACE,attach,[P1,[12345]],_}|_]}} =
(catch ?INTERFACE:attach(P1,[12345])),
ok = ?INTERFACE:close(P1),
ok = ?INTERFACE:close(P2),
{'EXIT',{badarg,[{?INTERFACE,attach,[P1,P2Id],_}|_]}} =
(catch ?INTERFACE:attach(P1,P2Id)),
ok.
detach_errors(_Config) ->
P1 = ?INTERFACE:open("p1"),
P2 = ?INTERFACE:open("p2"),
P2Id = ?INTERFACE:get_id(P2),
Ref = ?INTERFACE:attach(P1,P2Id),
{'EXIT',{badarg,[{?INTERFACE,detach,[inval,Ref],_}|_]}} =
(catch ?INTERFACE:detach(inval,Ref)),
{'EXIT',{badarg,[{?INTERFACE,detach,[P1,inval],_}|_]}} =
(catch ?INTERFACE:detach(P1,inval)),
ok = ?INTERFACE:detach(P1,Ref),
ok = ?INTERFACE:detach(P1,Ref),
case ?INTERFACE of
ose -> ok;
_ ->
ok = ?INTERFACE:close(P1)
end,
ok = ?INTERFACE:close(P2),
ok = ?INTERFACE:close(P1),
{'EXIT',{badarg,[{?INTERFACE,detach,[P1,Ref],_}|_]}} =
(catch ?INTERFACE:detach(P1,Ref)),
receive
Else -> ct:fail({got,Else})
after 100 ->
ok
end.
send_errors(_Config) ->
P1 = ?INTERFACE:open("p1"),
P2 = ?INTERFACE:open("p2"),
P2Id = ?INTERFACE:get_id(P2),
{'EXIT',{badarg,[{?INTERFACE,send,[inval,P2Id,42,"hello"],_}|_]}} =
(catch ?INTERFACE:send(inval,P2Id,42,"hello")),
{'EXIT',{badarg,[{?INTERFACE,send,[P1,inval,42,"hello"],_}|_]}} =
(catch ?INTERFACE:send(P1,inval,42,"hello")),
{'EXIT',{badarg,[{?INTERFACE,send,[P1,P2Id,inval,"hello"],_}|_]}} =
(catch ?INTERFACE:send(P1,P2Id,inval,"hello")),
{'EXIT',{badarg,[{?INTERFACE,send,[P1,P2Id,42,inval],_}|_]}} =
(catch ?INTERFACE:send(P1,P2Id,42,inval)),
ok = ?INTERFACE:close(P2),
ok = ?INTERFACE:send(P1,P2Id,42,"hello"),
ok = ?INTERFACE:close(P1),
{'EXIT',{badarg,[{?INTERFACE,send,[P1,P2Id,42,"hello"],_}|_]}} =
(catch ?INTERFACE:send(P1,P2Id,42,"hello")),
receive
Else -> ct:fail({got,Else})
after 100 ->
ok
end.
send_w_s_errors(_Config) ->
P1 = ?INTERFACE:open("p1"),
P1Id = ?INTERFACE:get_id(P1),
P2 = ?INTERFACE:open("p2"),
P2Id = ?INTERFACE:get_id(P2),
P3 = ?INTERFACE:open("p3"),
P3Id = ?INTERFACE:get_id(P3),
{'EXIT',{badarg,[{?INTERFACE,send,[inval,P2Id,P1Id,42,"hello"],_}|_]}} =
(catch ?INTERFACE:send(inval,P2Id,P1Id,42,"hello")),
{'EXIT',{badarg,[{?INTERFACE,send,[P2,-1,P1Id,42,"hello"],_}|_]}} =
(catch ?INTERFACE:send(P2,-1,P1Id,42,"hello")),
{'EXIT',{badarg,[{?INTERFACE,send,[P2,P2Id,1 bsl 32,42,"hello"],_}|_]}} =
(catch ?INTERFACE:send(P2,P2Id,1 bsl 32,42,"hello")),
{'EXIT',{badarg,[{?INTERFACE,send,[P2,P2Id,P1Id,inval,"hello"],_}|_]}} =
(catch ?INTERFACE:send(P2,P2Id,P1Id,inval,"hello")),
{'EXIT',{badarg,[{?INTERFACE,send,[P2,P2Id,P1Id,42,inval],_}|_]}} =
(catch ?INTERFACE:send(P2,P2Id,P1Id,42,inval)),
ok = ?INTERFACE:close(P3),
ok = ?INTERFACE:send(P2,P3Id,P1Id,42,"hello"),
ok = ?INTERFACE:close(P1),
ok = ?INTERFACE:send(P2,P2Id,P1Id,42,"hello"),
ok = ?INTERFACE:close(P2),
{'EXIT',{badarg,[{?INTERFACE,send,[P1,P2Id,P1Id,42,"hello"],_}|_]}} =
(catch ?INTERFACE:send(P1,P2Id,P1Id,42,"hello")),
receive
Else -> ct:fail({got,Else})
after 100 ->
ok
end.
listen_errors(_Config) ->
P1 = ?INTERFACE:open("p1"),
P1Id = ?INTERFACE:get_id(P1),
{'EXIT',{badarg,[{?INTERFACE,listen,[inval,[42]],_}|_]}} =
(catch ?INTERFACE:listen(inval,[42])),
{'EXIT',{badarg,[{?INTERFACE,listen,[P1,inval],_}|_]}} =
(catch ?INTERFACE:listen(P1,inval)),
{'EXIT',{badarg,[{?INTERFACE,listen,[P1,[1 bsl 33]],_}|_]}} =
(catch ?INTERFACE:listen(P1,[1 bsl 33])),
ok = ?INTERFACE:listen(P1,[42,42,42,42,42,42,42,42,42,42,42,42,42]),
case ?INTERFACE of
ose -> ok;
_ ->
?INTERFACE:send(P1,P1Id,42,"hello"),
timer:sleep(50),
?INTERFACE:listen(P1,[]),
?INTERFACE:send(P1,P1Id,42,"hello2"),
receive
{message,P1,42,"hello"} -> ok
end,
receive
Else -> ct:fail({got,Else})
after 100 ->
ok
end
end,
ok = ?INTERFACE:close(P1),
{'EXIT',{badarg,[{?INTERFACE,listen,[P1,[42]],_}|_]}} =
(catch ?INTERFACE:listen(P1,[42])),
ok.
%%
%% Internal functions
%%
multi_open(N,ListenNums) ->
multi_open(N,ListenNums,[]).
multi_open(0,_,Acc) ->
Acc;
multi_open(N,ListenNums,Acc) ->
P = ?INTERFACE:open("p"++integer_to_list(N)),
ok = ?INTERFACE:listen(P,ListenNums),
multi_open(N-1,ListenNums,[P|Acc]).
n(_F,0) ->
ok;
n(F,N) ->
ok = F(N),
n(F,N-1).
flush() ->
receive
Msg ->
[Msg|flush()]
after 0 ->
[]
end.
