megaco_sdp_test.erl

来自「OTP是开放电信平台的简称」· ERL 代码 · 共 974 行 · 第 1/3 页

exec([], []) ->
    ok;
exec([], Acc) ->
    {error, lists:reverse(Acc)};
exec([Instr|Instructions], Acc) ->
    case exec_instruction(Instr) of
	ok ->
	    exec(Instructions, Acc);
	Error ->
	    exec(Instructions, [Error|Acc])
    end.
    

exec_instruction({Desc, Cmd, Data, Verify}) ->
    io:format("~n"
	      "*** Test ~s ***"
	      "~n", [Desc]),
    Res = (catch Cmd(Data)), 
    case (catch Verify(Res)) of
	ok ->
	    ok;
	error ->
	    {error, {instruction_failed, {Desc, Data, Res}}};
	{error, Expected} ->
	    {error, {instruction_failed, {Desc, Data, Res, Expected}}};
	Else ->
	    {error, {verification_error, {Desc, Data, Res, Else}}}
    end.


%% ===============================================================
%% 
%% Utility functions to generate PropertyParm records
%% 

cre_PropertyParm_p(Num) when is_list(Num) ->
    cre_PropertyParm("p", Num).

cre_sdp_p(PN) ->
    #megaco_sdp_p{phone_number = PN}.

cre_PropertyParm_e(Email) when is_list(Email) ->
    cre_PropertyParm("e", Email).

cre_sdp_e(E) ->
    #megaco_sdp_e{email = E}.

cre_PropertyParm_u(URI) when is_list(URI) ->
    cre_PropertyParm("u", URI).

cre_sdp_u(U) ->
    #megaco_sdp_u{uri = U}.

cre_PropertyParm_i(SessionDescr) when is_list(SessionDescr) ->
    cre_PropertyParm("i", SessionDescr).

cre_sdp_i(SD) ->
    #megaco_sdp_i{session_descriptor = SD}.

cre_PropertyParm_s(Name) when is_list(Name) ->
    cre_PropertyParm("s", Name).

cre_sdp_s(N) ->
    #megaco_sdp_s{name = N}.

cre_PropertyParm_k(prompt, _) ->
    cre_PropertyParm("k", "prompt");
cre_PropertyParm_k(clear, EncryptionKey) when is_list(EncryptionKey) ->
    cre_PropertyParm("k", "clear:" ++ EncryptionKey);
cre_PropertyParm_k(base64, EncryptionKey) when is_list(EncryptionKey) ->
    cre_PropertyParm("k", "base64:" ++ EncryptionKey);
cre_PropertyParm_k(uri, EncryptionKey) when is_list(EncryptionKey) ->
    cre_PropertyParm("k", "uri:" ++ EncryptionKey);
cre_PropertyParm_k(Method, EncryptionKey) 
  when is_list(Method) and is_list(EncryptionKey) ->
    cre_PropertyParm("k", Method ++ ":" ++ EncryptionKey).

cre_sdp_k(M) ->
    #megaco_sdp_k{method = M}.
cre_sdp_k(M, EK) ->
    #megaco_sdp_k{method = M, encryption_key = EK}.

cre_PropertyParm_z([H | T]) when is_list(H) ->
    F = fun(Elem, Str) -> Str ++ " " ++ Elem end, 
    cre_PropertyParm("z", lists:foldl(F, H, T)).

cre_sdp_z(LOA) ->
    #megaco_sdp_z{list_of_adjustments = LOA}.

cre_PropertyParm_r(Repeat, Duration, ListOfOffsets) 
  when is_list(Repeat) and is_list(Duration) and is_list(ListOfOffsets) ->
    F = fun(Elem, Str) -> Str ++ " " ++ Elem end, 
    Val = Repeat ++ " " ++ Duration ++  lists:foldl(F, [], ListOfOffsets),
    cre_PropertyParm("r", Val).

cre_sdp_r(Repeat, Duration, ListOfOffsets) ->
    #megaco_sdp_r{repeat_interval = Repeat, 
		  active_duration = Duration, 
		  list_of_offsets = ListOfOffsets}.

cre_PropertyParm_t(Start, Stop) 
  when is_list(Start) and is_list(Stop) ->
    cre_PropertyParm("t", Start ++ " " ++ Stop);
cre_PropertyParm_t(Start, Stop) ->
    cre_PropertyParm_t(i2s(Start), i2s(Stop)).

cre_sdp_t(Start, Stop) ->
    #megaco_sdp_t{start = Start, stop = Stop}.

cre_PropertyParm_b(Modifier, Bandwidth) 
  when is_list(Modifier) and is_integer(Bandwidth) ->
    cre_PropertyParm_b(Modifier, i2s(Bandwidth));
cre_PropertyParm_b(Modifier, Bandwidth) 
  when is_list(Modifier) and is_list(Bandwidth) ->
    cre_PropertyParm("b", Modifier ++ ":" ++ Bandwidth).

cre_sdp_b(Mod, BW) ->
    #megaco_sdp_b{modifier = Mod, bandwidth = BW}.

%% cre_PropertyParm_fmtp(Format, Param) 
%%   when is_list(Format) and is_list(Param) ->
%%     cre_PropertyParm_a("fmtp", Format ++ " " ++ Param).

%% cre_sdp_a_fmtp(Fmt, Parm) ->
%%     #megaco_sdp_a_fmtp{format = Fmt, param = Parm}.

cre_PropertyParm_quality(Quality) when is_integer(Quality) ->
    cre_PropertyParm_quality(i2s(Quality));
cre_PropertyParm_quality(Quality) when is_list(Quality) ->
    cre_PropertyParm_a("quality", Quality).

cre_sdp_a_quality(Qa) ->
    #megaco_sdp_a_quality{quality = Qa}.

cre_PropertyParm_ptime(PacketTime) when is_integer(PacketTime) ->
    cre_PropertyParm_ptime(i2s(PacketTime));
cre_PropertyParm_ptime(PacketTime) when is_list(PacketTime) ->
    cre_PropertyParm_a("ptime", PacketTime).

cre_sdp_a_ptime(PT) ->
    #megaco_sdp_a_ptime{packet_time = PT}.

cre_PropertyParm_rtpmap(Payload, EncName, ClockRate) ->
    cre_PropertyParm_rtpmap(Payload, EncName, ClockRate, []).

cre_PropertyParm_rtpmap(Payload, EncName, ClockRate, EncPar)
  when is_integer(Payload) and
       is_list(EncName) and
       is_integer(ClockRate) and
       is_list(EncPar) ->
    F = fun(Elem, Str) -> Str ++ "/" ++ Elem end, 
    Val = 
	integer_to_list(Payload) ++ " " ++
	EncName ++ "/" ++ integer_to_list(ClockRate) ++ 
	lists:foldl(F, [], EncPar),
    cre_PropertyParm_a("rtpmap", Val).

cre_sdp_a_rtpmap(Payload, EncName, ClockRate) ->
    #megaco_sdp_a_rtpmap{payload_type  = Payload, 
			 encoding_name = EncName,
			 clock_rate    = ClockRate}.
cre_sdp_a_rtpmap(Payload, EncName, ClockRate, EncParms) ->
    #megaco_sdp_a_rtpmap{payload_type   = Payload, 
			 encoding_name  = EncName,
			 clock_rate     = ClockRate,
			 encoding_parms = EncParms}.

cre_PropertyParm_a(Attr, AttrValue) 
  when is_list(Attr) and is_list(AttrValue) ->
    cre_PropertyParm("a", Attr ++ ":" ++ AttrValue).

cre_PropertyParm_a(Attr) when is_list(Attr) ->
    cre_PropertyParm("a", Attr).

cre_sdp_a(Attr) ->
    #megaco_sdp_a{attribute = Attr}.

cre_sdp_a(Attr, Val) ->
    #megaco_sdp_a{attribute = Attr,
		  value     = Val}.

cre_PropertyParm_o(User, SID, Version, AddrType, Addr) ->
    cre_PropertyParm_o(User, SID, Version, in, AddrType, Addr).

cre_PropertyParm_o(User, SID, Version, NetType, AddrType, Addr) 
  when is_list(User) and
       is_integer(SID) and
       is_integer(Version) and
       is_list(NetType) or (NetType == in) and
       is_list(AddrType) or ((AddrType == ip4) or (AddrType == ip6)) and
       is_list(Addr) ->
    NT = case NetType of
	     in -> "IN";
	     _  -> NetType
	 end,
    AT = case AddrType of
	     ip4 -> "IP4";
	     ip6 -> "IP6";
	     _   -> AddrType
	 end,
    Val = 
	User         ++ " " ++
	i2s(SID)     ++ " " ++
	i2s(Version) ++ " " ++
	NT           ++ " " ++
	AT           ++ " " ++
	Addr, 
    cre_PropertyParm("o", Val).

cre_sdp_o(Name, SID, V, AddrType, Addr) ->
    cre_sdp_o(Name, SID, V, in, AddrType, Addr).
cre_sdp_o(Name, SID, V, NetType, AddrType, Addr) ->
    #megaco_sdp_o{user_name    = Name,
		  session_id   = SID,
		  version      = V,
		  network_type = NetType,
		  address_type = AddrType, 
		  address      = Addr}.

cre_PropertyParm_m(Media, Port, Transport, FmtList) 
  when is_atom(Media) ->
    cre_PropertyParm_m(atom_to_list(Media), 
		       Port, Transport, FmtList);
cre_PropertyParm_m(Media, Port0, Transport, FmtList) 
  when is_list(Media) and is_list(Transport) and is_list(FmtList) ->
    Port = i2s(Port0),
    Val = 
	Media ++ " " ++ Port ++ " " ++ Transport ++ " " ++ val(FmtList),
    cre_PropertyParm("m", Val).

cre_PropertyParm_m(Media, Port, NumPorts, Transport, FmtList) 
  when is_atom(Media) ->
    cre_PropertyParm_m(atom_to_list(Media), 
		       Port, NumPorts, Transport, FmtList);
cre_PropertyParm_m(Media, Port0, NumPorts0, Transport, FmtList) 
  when is_list(Media) and is_list(Transport) and is_list(FmtList) ->
    Port     = i2s(Port0),
    NumPorts = i2s(NumPorts0),
    Val = 
	Media ++ " " ++ Port ++ "/" ++ NumPorts ++ " " ++ Transport ++ 
	" " ++ val(FmtList),
    cre_PropertyParm("m", Val).

cre_sdp_m(Media, Port, Transport, FmtList) ->
    #megaco_sdp_m{media     = Media,
		  port      = Port,
		  transport = Transport,
		  fmt_list  = FmtList}.

cre_sdp_m(Media, Port, NumPorts, Transport, FmtList) ->
    #megaco_sdp_m{media     = Media,
		  port      = Port,
		  num_ports = NumPorts, 
		  transport = Transport,
		  fmt_list  = FmtList}.


cre_PropertyParm_c(ip4, ConnAddr) ->
    cre_PropertyParm_c("IP4", ConnAddr);
cre_PropertyParm_c(ip6, ConnAddr) ->
    cre_PropertyParm_c("IP6", ConnAddr);
cre_PropertyParm_c(AddrType, ConnAddr) 
  when is_list(AddrType) and is_list(ConnAddr) ->
    Val = "IN " ++ AddrType ++ " " ++ ConnAddr, 
    cre_PropertyParm("c", Val).

cre_PropertyParm_c(ip4, Base, TTL) ->
    cre_PropertyParm_c("IP4", Base, i2s(TTL));
cre_PropertyParm_c(AddrType, Base, TTL) 
  when is_list(AddrType) and 
       is_list(Base)     and 
       is_list(TTL) ->
    Val = "IN " ++ AddrType ++ " " ++ Base ++ "/" ++ TTL, 
    cre_PropertyParm("c", Val).

cre_PropertyParm_c(ip4, Base, TTL, NumOf) ->
    cre_PropertyParm_c("IP4", Base, i2s(TTL), i2s(NumOf));
cre_PropertyParm_c(AddrType, Base, TTL, NumOf) 
  when is_list(AddrType) and 
       is_list(Base)     and 
       is_list(TTL)      and 
       is_list(NumOf) ->
    Val = 
	"IN " ++ AddrType ++ " " ++ Base ++ "/" ++ TTL ++ "/" ++ NumOf,
    cre_PropertyParm("c", Val).


cre_sdp_c(AddrType, ConnAddr) ->
    cre_sdp_c(in, AddrType, ConnAddr).

cre_sdp_c(NetType, AddrType, ConnAddr) ->
    #megaco_sdp_c{network_type    = NetType,
		  address_type    = AddrType, 
		  connection_addr = ConnAddr}.


cre_PropertyParm_v(Version) when is_integer(Version) ->
    cre_PropertyParm_v(integer_to_list(Version));
cre_PropertyParm_v(Version) when is_list(Version) ->
    cre_PropertyParm("v", Version).

cre_sdp_v(Version) ->
    #megaco_sdp_v{version = Version}.
	

cre_PropertyParm(Name, Val) when is_list(Name) and is_list(Val) ->
    #'PropertyParm'{name = Name, value = [Val]}.


val(Vals) ->
    val(Vals, " ").
val([Head|Tail], Sep) ->
    lists:foldl(fun(E, S) -> S ++ Sep ++ E end, Head, Tail).

i2s(I) when is_integer(I) ->
    integer_to_list(I);
i2s(S) when is_list(S) ->
    S.


%% error(Reason) ->
%%     throw({error, Reason}).