megaco_test_msg_v2_lib.erl

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

    validate(fun() -> chk_INTEGER(V1, V2, {range, 0, 99}) end, 'Message'),
    validate(fun() -> chk_MId(MID1, MID2) end, 'Message'),
    chk_Message_messageBody(Body1, Body2),
    ok;
chk_Message(M1, M2) ->
    wrong_type('Message', M1, M2).


is_Message_messageBody({Tag, Val}) ->
    is_Message_messageBody_tag(Tag) andalso 
	is_Message_messageBody_val(Tag, Val);
is_Message_messageBody(_) ->
    false.

is_Message_messageBody_tag(Tag) ->
    Tags = [messageError, transactions],
    lists:member(Tag, Tags).
    
is_Message_messageBody_val(messageError, Val) ->
    is_ErrorDescriptor(Val);
is_Message_messageBody_val(transactions, Val) ->
    is_Message_messageBody_transactions(Val).

is_Message_messageBody_transactions([]) ->
    true;
is_Message_messageBody_transactions([H|T]) ->
    is_Transaction(H) andalso is_Message_messageBody_transactions(T);
is_Message_messageBody_transactions(_) ->
    false.

chk_Message_messageBody(B, B) ->
    chk_type(fun is_Message_messageBody/1, 'Message_messageBody', B);
chk_Message_messageBody({Tag, Val1} = B1, {Tag, Val2} = B2) ->
    case (is_Message_messageBody_tag(Tag) andalso 
	  is_Message_messageBody_val(Tag, Val1) andalso 
	  is_Message_messageBody_val(Tag, Val2)) of
	true ->
	    chk_Message_messageBody_val(Tag, Val1, Val2);
	false ->
	    wrong_type('Message_messageBody', B1, B2)
    end;
chk_Message_messageBody({Tag1, Val1} = B1, {Tag2, Val2} = B2) ->
    case ((is_Message_messageBody_tag(Tag1) andalso 
	   is_Message_messageBody_val(Tag1, Val1)) andalso 
	  (is_Message_messageBody_tag(Tag2) andalso 
	   is_Message_messageBody_val(Tag2, Val2))) of
	true ->
	    not_equal('Message_messageBody', B1, B2);
	false ->
	    wrong_type('Message_messageBody', B1, B2)
    end;
chk_Message_messageBody(B1, B2) ->
    wrong_type('Message_messageBody', B1, B2).

chk_Message_messageBody_val(messageError, Val1, Val2) ->
    validate(fun() -> chk_ErrorDescriptor(Val1, Val2) end, 
	     'Message_messageBody');
chk_Message_messageBody_val(transactions, Val1, Val2) ->
    chk_Message_messageBody_transactions(Val1, Val2).

chk_Message_messageBody_transactions([], []) ->
    ok;
chk_Message_messageBody_transactions([] = T1, T2) ->
    not_equal('Message_messageBody_transactions', T1, T2);
chk_Message_messageBody_transactions(T1, [] = T2) ->
    not_equal('Message_messageBody_transactions', T1, T2);
chk_Message_messageBody_transactions([H|T1], [H|T2]) ->
    case is_Transaction(H) of
	true ->
	    chk_Message_messageBody_transactions(T1, T2);
	false ->
	    wrong_type('Message_messageBody_transactions_val', H)
    end;
chk_Message_messageBody_transactions([H1|T1], [H2|T2]) ->
    validate(fun() -> chk_Transaction(H1, H2) end, 
	     'Message_messageBody_transactions_val'),
    chk_Message_messageBody_transactions(T1, T2);
chk_Message_messageBody_transactions(T1, T2) ->
    wrong_type('Message_messageBody_transactions', T1, T2).
 

%% -- MId --

is_opt_MId(M) ->
    is_OPTIONAL(fun is_MId/1, M).

is_MId({Tag, Val}) ->
    is_MId_tag(Tag) andalso is_MId_val(Tag, Val);
is_MId(_) ->
    false.

is_MId_tag(Tag) ->
    Tags = [ip4Address, ip6Address, domainName, deviceName, mtpAddress], 
    lists:member(Tag, Tags).

is_MId_val(ip4Address, Val) -> is_IP4Address(Val);
is_MId_val(ip6Address, Val) -> is_IP6Address(Val);
is_MId_val(domainName, Val) -> is_DomainName(Val);
is_MId_val(deviceName, Val) -> is_PathName(Val);
is_MId_val(mtpAddress, Val) -> is_OCTET_STRING(Val, {range, 2, 4}).

chk_opt_MId(M1, M2) ->
    chk_OPTIONAL('MId', M1, M2, fun is_MId/1, fun chk_MId/2).

chk_MId(M, M) ->
    chk_type(fun is_MId/1, 'MId', M);
chk_MId({Tag, Val1} = M1, {Tag, Val2} = M2) ->
    case (is_MId_tag(Tag) andalso
	  is_MId_val(Tag, Val1) andalso
	  is_MId_val(Tag, Val2)) of
	true ->
	    chk_MId_val(Tag, Val1, Val2);
	false ->
	    wrong_type('MId', M1, M2)
    end;
chk_MId({Tag1, Val1} = M1, {Tag2, Val2} = M2) ->
    case ((is_MId_tag(Tag1) andalso
	   is_MId_val(Tag1, Val1)) andalso
	  (is_MId_tag(Tag2) andalso
	   is_MId_val(Tag2, Val2))) of
	true ->
	    not_equal('MId', M1, M2);
	false ->
	    wrong_type('MId', M1, M2)
    end;
chk_MId(M1, M2) ->
    wrong_type('MId', M1, M2).

chk_MId_val(ip4Address, M1, M2) -> chk_IP4Address(M1, M2);
chk_MId_val(ip6Address, M1, M2) -> chk_IP6Address(M1, M2);
chk_MId_val(domainName, M1, M2) -> chk_DomainName(M1, M2);
chk_MId_val(deviceName, M1, M2) -> chk_PathName(M1,   M2);
chk_MId_val(mtpAddress, M1, M2) -> chk_OCTET_STRING(M1, M2, {range, 2, 4}).


%% -- DomainName --

is_DomainName(#'DomainName'{name = N, portNumber = PN}) ->
    is_IA5String(N) andalso is_opt_INTEGER(PN, {range, 0, 65535});
is_DomainName(_) ->
    false.

chk_DomainName(N, N) ->
    ok;
chk_DomainName(N1, N2) ->
    not_equal('DomainName', N1, N2).


%% -- IP4Address --

is_IP4Address(#'IP4Address'{address = A, portNumber = PN}) ->
    is_OCTET_STRING(A, {exact, 4}) andalso 
	is_opt_INTEGER(PN, {range, 0, 65535});
is_IP4Address(_) ->
    false.

chk_IP4Address(A, A) ->
    ok;
chk_IP4Address(A1, A2) ->
    not_equal('IP4Address', A1, A2).


%% -- IP6Address --

is_IP6Address(#'IP6Address'{address = A, portNumber = PN}) ->
    is_OCTET_STRING(A, {exact, 16}) andalso 
	is_opt_INTEGER(PN, {range, 0, 65535});
is_IP6Address(_) ->
    false.

chk_IP6Address(A, A) ->
    ok;
chk_IP6Address(A1, A2) ->
    not_equal('IP6Address', A1, A2).


%% -- PathName --

is_PathName(N) -> is_IA5String(N, {range, 1, 64}).
    
chk_PathName(N, N) ->
    ok;
chk_PathName(N1, N2) ->
    not_equal('PathName', N1, N2).


%% -- Transaction --

is_Transaction({Tag, Val}) ->
    is_Transaction_tag(Tag) andalso is_Transaction_val(Tag, Val);
is_Transaction(_) ->
    false.

is_Transaction_tag(Tag) ->
    Tags = [transactionRequest,
	    transactionPending,
	    transactionReply,
	    transactionResponseAck],
    lists:member(Tag, Tags).

is_Transaction_val(transactionRequest, V)     -> is_TransactionRequest(V);
is_Transaction_val(transactionPending, V)     -> is_TransactionPending(V);
is_Transaction_val(transactionReply, V)       -> is_TransactionReply(V);
is_Transaction_val(transactionResponseAck, V) -> is_TransactionResponseAck(V).
    

chk_Transaction({Tag, Val} = Trans, {Tag, Val}) ->
    case (is_Transaction_tag(Tag) andalso is_Transaction_val(Tag, Val)) of
	true ->
	    ok;
	false ->
	    wrong_type('Transaction', Trans, Trans)
    end;
chk_Transaction({Tag, Val1} = Trans1, {Tag, Val2} = Trans2) ->
    case (is_Transaction_tag(Tag) and
	  is_Transaction_val(Tag, Val1) and
	  is_Transaction_val(Tag, Val2)) of
	true ->
	    chk_Transaction_val(Tag, Val1, Val2);
	false ->
	    wrong_type('Transaction', Trans1, Trans2)
    end;
chk_Transaction({Tag1, Val1} = Trans1, {Tag2, Val2} = Trans2) ->
    case ((is_Transaction_tag(Tag1) andalso 
	   is_Transaction_val(Tag1, Val1)) andalso
	  (is_Transaction_tag(Tag2) andalso 
	   is_Transaction_val(Tag2, Val2))) of
	true ->
	    not_equal('Transaction', Trans1, Trans2);
	false ->
	    wrong_type('Transaction', Trans1, Trans2)
    end;
chk_Transaction(Trans1, Trans2) ->
    wrong_type('Transaction', Trans1, Trans2).

chk_Transaction_val(transactionRequest, T1, T2) ->
    chk_TransactionRequest(T1, T2);
chk_Transaction_val(transactionPending, T1, T2) ->
    chk_TransactionPending(T1, T2);
chk_Transaction_val(transactionReply, T1, T2) ->
    chk_TransactionReply(T1,T2);
chk_Transaction_val(transactionResponseAck, T1, T2) ->
    chk_TransactionResponseAck(T1, T2).
 

%% -- TransactionId --

is_opt_TransactionId(TID) -> 
    is_OPTIONAL(fun is_TransactionId/1, TID).

is_TransactionId(TID) -> is_INTEGER(TID, {range, 0, 4294967295}).

chk_opt_TransactionId(TID1, TID2) ->
    chk_OPTIONAL('TransactionId', TID1, TID2, 
		 fun is_TransactionId/1, fun chk_TransactionId/2).

chk_TransactionId(TID, TID) ->
    chk_type(fun is_TransactionId/1, 'TransactionId', TID);
chk_TransactionId(TID1, TID2) ->
    case (is_TransactionId(TID1) andalso is_TransactionId(TID2)) of
	true ->
	    not_equal('TransactionId', TID1, TID2);
	false ->
	    wrong_type('TransactionId', TID1, TID2)
    end.


%% -- TransactionRequest --

is_TransactionRequest(#'TransactionRequest'{transactionId = TID,
					    actions       = Acts}) ->
    is_TransactionId(TID) andalso is_TransactionRequest_actions(Acts);
is_TransactionRequest(_) ->
    false.

chk_TransactionRequest(T, T) ->
    chk_type(fun is_TransactionRequest/1, 'TransactionRequest', T);
chk_TransactionRequest(#'TransactionRequest'{transactionId = TID1,
					     actions       = Acts1}, 
		       #'TransactionRequest'{transactionId = TID2,
					     actions       = Acts2}) ->
    validate(fun() -> chk_TransactionId(TID1, TID2) end, 'TransactionRequest'),
    chk_TransactionRequest_actions(Acts1, Acts2),
    ok;
chk_TransactionRequest(T1, T2) ->
    wrong_type('TransactionRequest', T1, T2).

is_TransactionRequest_actions([]) ->
    true;
is_TransactionRequest_actions([H|T]) ->
    is_ActionRequest(H) andalso is_TransactionRequest_actions(T);
is_TransactionRequest_actions(_) ->
    false.

chk_TransactionRequest_actions([], []) ->
    ok;
chk_TransactionRequest_actions([] = Acts1, Acts2) ->
    not_equal('TransactionRequest_actions', Acts1, Acts2);
chk_TransactionRequest_actions(Acts1, [] = Acts2) ->
    not_equal('TransactionRequest_actions', Acts1, Acts2);
chk_TransactionRequest_actions([H|T1], [H|T2]) ->
    case is_ActionRequest(H) of
	true ->
	    chk_TransactionRequest_actions(T1, T2);
	false ->
	    wrong_type('TransactionRequest_actions_val', H)
    end;
chk_TransactionRequest_actions([H1|T1], [H2|T2]) ->
    validate(fun() -> chk_ActionRequest(H1, H2) end, 
	     'TransactionRequest_actions_val'),
    chk_TransactionRequest_actions(T1, T2);
chk_TransactionRequest_actions(Acts1, Acts2) ->
    wrong_type('TransactionRequest_actions', Acts1, Acts2).


%% -- TransactionPending --

is_TransactionPending(#'TransactionPending'{transactionId = TID}) ->
    is_TransactionId(TID);
is_TransactionPending(_) ->
    false.

chk_TransactionPending(T, T) ->
    chk_type(fun is_TransactionPending/1, 'TransactionPending', T);
chk_TransactionPending(#'TransactionPending'{transactionId = TID1}, 
		       #'TransactionPending'{transactionId = TID2}) ->
    validate(fun() -> chk_TransactionId(TID1, TID2) end, 'TransactionPending'),
    ok;
chk_TransactionPending(T1, T2) ->
    wrong_type('TransactionPending', T1, T2).

    
%% -- TransactionReply --

is_TransactionReply(#'TransactionReply'{transactionId     = TID,
					immAckRequired    = IAR,
					transactionResult = TR}) ->
    is_TransactionId(TID) andalso 
	is_opt_NULL(IAR) andalso 
	is_TransactionReply_transactionResult(TR);
is_TransactionReply(_) ->
    false.

chk_TransactionReply(T, T) ->
    chk_type(fun is_TransactionReply/1, 'TransactionReply', T);
chk_TransactionReply(#'TransactionReply'{transactionId     = TID1,
					 immAckRequired    = IAR1,
					 transactionResult = TR1},
		     #'TransactionReply'{transactionId     = TID2,
					 immAckRequired    = IAR2,
					 transactionResult = TR2}) ->
    validate(fun() -> chk_TransactionId(TID1, TID2) end, 'TransactionReply'),
    validate(fun() -> chk_opt_NULL(IAR1, IAR2) end, 'TransactionReply'),
    chk_TransactionReply_transactionResult(TR1, TR2),
    ok;
chk_TransactionReply(T1, T2) ->
    wrong_type('TransactionReply', T1, T2).
	
is_TransactionReply_transactionResult({Tag, Val}) ->
    is_TransactionReply_transactionResult_tag(Tag) andalso
	is_TransactionReply_transactionResult_val(Tag, Val);
is_TransactionReply_transactionResult(_) ->
    false.

is_TransactionReply_transactionResult_tag(T) ->
    lists:member(T, [transactionError, actionReplies]).

is_TransactionReply_transactionResult_val(transactionError, V) ->
    is_ErrorDescriptor(V);
is_TransactionReply_transactionResult_val(actionReplies, V) ->
    is_TransactionReply_actionReplies(V).

chk_TransactionReply_transactionResult(Res, Res) ->
    chk_type(fun is_TransactionReply_transactionResult/1, 
	     'TransactionReply_transactionResult', Res);
chk_TransactionReply_transactionResult({Tag, Val1} = Res1, 
				       {Tag, Val2} = Res2) ->
    case (is_TransactionReply_transactionResult_tag(Tag) and
	  is_TransactionReply_transactionResult_val(Tag, Val1) and
	  is_TransactionReply_transactionResult_val(Tag, Val2)) of
	true ->
	    chk_TransactionReply_transactionResult_val(Tag, Val1, Val2);
	false ->
	    wrong_type('TransactionReply_transactionResult', Res1, Res2)
    end;
chk_TransactionReply_transactionResult({Tag1, Val1} = Res1, 
				       {Tag2, Val2} = Res2) ->
    case ((is_TransactionReply_transactionResult_tag(Tag1) and
	   is_TransactionReply_transactionResult_val(Tag1, Val1)) and
	  (is_TransactionReply_transactionResult_tag(Tag2) and
	   is_TransactionReply_transactionResult_val(Tag2, Val2))) of
	true ->