← Back to branch summary

~rdoering/ubuntu/karmic/erlang/fix-535090

« back to all changes in this revision

Viewing changes to lib/megaco/test/megaco_segment_test.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-02-15 16:42:52 UTC
  • mfrom: (3.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090215164252-q5x4rcf8a5pbesb1
Tags: 1:12.b.5-dfsg-2
Upload to unstable after lenny is released.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/megaco/test/megaco_segment_test.erl
1782
1782
             {megaco_update_conn_info, protocol_version, ?VERSION}, 
1783
1783
             {megaco_update_conn_info, segment_send,     1}, 
1784
1784
             {megaco_update_conn_info, max_pdu_size,     128}, 
1785
 
             {sleep, 1000},
 
1785
             {sleep, 500},
1786
1786
             {megaco_callback, handle_trans_request, NotifyReqVerify},
1787
1787
             {megaco_callback, handle_trans_ack,     AckVerify, 5000},
1788
1788
             megaco_stop_user,
3401
3401
    d("[MG] start the simulation"),
3402
3402
    {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq),
3403
3403
 
 
3404
    %% Await MGC ready for segments
 
3405
    d("await MGC trigger event"),
 
3406
    MgcPid = 
 
3407
        receive
 
3408
            {ready_for_segments, mgc, Pid1} ->
 
3409
                d("received MGC trigger event"),
 
3410
                Pid1
 
3411
        after 5000 ->
 
3412
                d("timeout waiting for MGC trigger event: ~p", 
 
3413
                  [megaco_test_lib:flush()]),
 
3414
                ?ERROR(timeout_MGC_trigger_event)
 
3415
        end,
 
3416
 
 
3417
    %% Await MG ready for segments
 
3418
    d("await MG trigger event"),
 
3419
    MgPid = 
 
3420
        receive
 
3421
            {ready_for_segments, mg, Pid2} ->
 
3422
                d("received MG trigger event"),
 
3423
                Pid2
 
3424
        after 5000 ->
 
3425
                d("timeout waiting for MG trigger event: ~p", 
 
3426
                  [megaco_test_lib:flush()]),
 
3427
                ?ERROR(timeout_MG_trigger_event)
 
3428
        end,
 
3429
 
 
3430
    %% Instruct the MG to continue
 
3431
    d("send continue to MG"),
 
3432
    MgPid ! {continue_with_segments, self()}, 
 
3433
 
 
3434
    sleep(500),
 
3435
 
 
3436
    %% Instruct the MGC to continue
 
3437
    d("send continue to MGC"),
 
3438
    MgcPid ! {continue_with_segments, self()}, 
 
3439
 
3404
3440
    d("await the generator reply(s)"),
3405
3441
    await_completion([MgcId, MgId]),
3406
3442
 
3490
3526
    SegmentRep7 = ssmmsr1_mgc_segment_reply_msg(Mid, TransId, 7, false),
3491
3527
    SegmentRep8 = ssmmsr1_mgc_segment_reply_msg(Mid, TransId, 8, true),
3492
3528
    TransAck    = ssmmsr1_mgc_trans_ack_msg(Mid, TransId),
 
3529
    ReadyForSegments = ssmmsr1_mgc_ready_for_segments_fun(), 
3493
3530
    EvSeq = [{debug,  true},
3494
3531
             {decode, DecodeFun},
3495
3532
             {encode, EncodeFun},
3497
3534
             {expect_accept, any},
3498
3535
             {expect_receive, "service-change-request",  {ScrVerifyFun, 5000}},
3499
3536
             {send, "service-change-reply",              ServiceChangeRep},
3500
 
             {expect_nothing, 1000}, 
 
3537
             %% {expect_nothing, 1000}, 
 
3538
             {trigger, "segment send sync trigger", ReadyForSegments}, 
3501
3539
             {send, "notify request",                    NotifyReq},
3502
3540
             {expect_receive, "notify reply: segment 1", {NrVerifyFun1, 1000}},
3503
3541
             {expect_receive, "notify reply: segment 2", {NrVerifyFun2, 1000}},
3528
3566
            ],
3529
3567
    EvSeq.
3530
3568
 
 
3569
ssmmsr1_mgc_ready_for_segments_fun() ->
 
3570
    TC = self(),
 
3571
    fun() ->
 
3572
            io:format("ssmmsr1_mgc_ready_for_segments_fun -> entry~n", []),
 
3573
            TC ! {ready_for_segments, mgc, self()},
 
3574
            receive
 
3575
                {continue_with_segments, TC} ->
 
3576
                    io:format("ssmmsr1_mgc_ready_for_segments_fun -> "
 
3577
                              "received continue~n", []),
 
3578
                    ok
 
3579
            end
 
3580
    end.
 
3581
                
3531
3582
ssmmsr1_mgc_encode_msg_fun(Mod, Conf) ->
3532
3583
    fun(M) ->
3533
3584
            Mod:encode_message(Conf, M)
3803
3854
    Tids = [Tid1, Tid2, Tid3, Tid4, Tid5, Tid6, Tid7, Tid8], 
3804
3855
    NotifyReqVerify = ssmmsr1_mg_verify_notify_request_fun(Tids),
3805
3856
    AckVerify = ssmmsr1_mg_verify_ack_fun(), 
 
3857
    ReadyForSegments = ssmmsr1_mg_ready_for_segments_fun(), 
3806
3858
    EvSeq = [
3807
3859
             {debug, true},
3808
3860
             {megaco_trace, disable},
3819
3871
             {megaco_callback, handle_connect,     ConnectVerify},
3820
3872
             {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify},
3821
3873
             {megaco_update_conn_info, protocol_version, ?VERSION}, 
3822
 
             {megaco_update_conn_info, reply_timer,      12000}, 
 
3874
             {megaco_update_conn_info, reply_timer,      20000}, 
3823
3875
             {megaco_update_conn_info, segment_send,     3}, 
3824
3876
             {megaco_update_conn_info, max_pdu_size,     128}, 
3825
 
             {sleep, 1000},
 
3877
             %% {sleep, 1000},
 
3878
             {trigger, ReadyForSegments}, 
3826
3879
             {megaco_callback, handle_trans_request, NotifyReqVerify},
3827
3880
             {megaco_callback, handle_trans_ack,     AckVerify, 15000},
3828
3881
             megaco_stop_user,
3832
3885
    EvSeq.
3833
3886
 
3834
3887
 
 
3888
ssmmsr1_mg_ready_for_segments_fun() ->
 
3889
    TC = self(),
 
3890
    fun() ->
 
3891
            io:format("ssmmsr1_mg_ready_for_segments_fun -> entry~n", []),
 
3892
            TC ! {ready_for_segments, mg, self()},
 
3893
            receive
 
3894
                {continue_with_segments, TC} ->
 
3895
                    io:format("ssmmsr1_mg_ready_for_segments_fun -> "
 
3896
                              "received continue~n", []),
 
3897
                    ok
 
3898
            end
 
3899
    end.
 
3900
                
3835
3901
ssmmsr1_mg_verify_handle_connect_fun() ->
3836
3902
    fun(Ev) -> ssmmsr1_mg_verify_handle_connect(Ev) end.
3837
3903
 
4101
4167
    d("[MG] start the simulation"),
4102
4168
    {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq),
4103
4169
 
 
4170
    %% Await MGC ready for segments
 
4171
    d("await MGC trigger event"),
 
4172
    MgcPid = 
 
4173
        receive
 
4174
            {ready_for_segments, mgc, Pid1} ->
 
4175
                d("received MGC trigger event"),
 
4176
                Pid1
 
4177
        after 5000 ->
 
4178
                d("timeout waiting for MGC trigger event: ~p", 
 
4179
                  [megaco_test_lib:flush()]),
 
4180
                ?ERROR(timeout_MGC_trigger_event)
 
4181
        end,
 
4182
 
 
4183
    %% Await MG ready for segments
 
4184
    d("await MG trigger event"),
 
4185
    MgPid = 
 
4186
        receive
 
4187
            {ready_for_segments, mg, Pid2} ->
 
4188
                d("received MG trigger event"),
 
4189
                Pid2
 
4190
        after 5000 ->
 
4191
                d("timeout waiting for MG trigger event: ~p", 
 
4192
                  [megaco_test_lib:flush()]),
 
4193
                ?ERROR(timeout_MG_trigger_event)
 
4194
        end,
 
4195
 
 
4196
    %% Instruct the MG to continue
 
4197
    d("send continue to MG"),
 
4198
    MgPid ! {continue_with_segments, self()}, 
 
4199
 
 
4200
    sleep(500),
 
4201
 
 
4202
    %% Instruct the MGC to continue
 
4203
    d("send continue to MGC"),
 
4204
    MgcPid ! {continue_with_segments, self()}, 
 
4205
 
4104
4206
    d("await the generator reply(s)"),
4105
4207
    await_completion([MgcId, MgId]),
4106
4208
 
4163
4265
    NrVerifyFun2 = 
4164
4266
        ssmmsr2_mgc_verify_notify_reply_segment_msg_fun(2, false, TransId, 
4165
4267
                                                        TermId2, CtxId2),
4166
 
    %% NrVerifyFun3 = 
4167
 
    %%  ssmmsr2_mgc_verify_notify_reply_segment_msg_fun(3, false, TransId, 
4168
 
    %%                                                TermId3, CtxId3),
4169
 
    %% NrVerifyFun4 = 
4170
 
    %%  ssmmsr2_mgc_verify_notify_reply_segment_msg_fun(4, false, TransId, 
4171
 
    %%                                                TermId4, CtxId4),
4172
 
    %% NrVerifyFun5 = 
4173
 
    %%  ssmmsr2_mgc_verify_notify_reply_segment_msg_fun(5, false, TransId, 
4174
 
    %%                                                TermId5, CtxId5),
4175
 
    %% NrVerifyFun6 = 
4176
 
    %%  ssmmsr2_mgc_verify_notify_reply_segment_msg_fun(6, false, TransId, 
4177
 
    %%                                                TermId6, CtxId6),
4178
 
    %% NrVerifyFun7 = 
4179
 
    %%  ssmmsr2_mgc_verify_notify_reply_segment_msg_fun(7, false, TransId, 
4180
 
    %%                                                TermId7, CtxId7),
4181
 
    %% NrVerifyFun8 = 
4182
 
    %%  ssmmsr2_mgc_verify_notify_reply_segment_msg_fun(8, true, TransId, 
4183
 
    %%                                                TermId8, CtxId8),
4184
4268
    SegmentRep1 = ssmmsr2_mgc_segment_reply_msg(Mid, TransId, 1, false),
4185
 
    %% SegmentRep2 = ssmmsr2_mgc_segment_reply_msg(Mid, TransId, 2, false),
4186
 
    %% SegmentRep3 = ssmmsr2_mgc_segment_reply_msg(Mid, TransId, 3, false),
4187
 
    %% SegmentRep4 = ssmmsr2_mgc_segment_reply_msg(Mid, TransId, 4, false),
4188
 
    %% SegmentRep5 = ssmmsr2_mgc_segment_reply_msg(Mid, TransId, 5, false),
4189
 
    %% SegmentRep6 = ssmmsr2_mgc_segment_reply_msg(Mid, TransId, 6, false),
4190
 
    %% SegmentRep7 = ssmmsr2_mgc_segment_reply_msg(Mid, TransId, 7, false),
4191
 
    %% SegmentRep8 = ssmmsr2_mgc_segment_reply_msg(Mid, TransId, 8, true),
4192
 
    %% TransAck    = ssmmsr2_mgc_trans_ack_msg(Mid, TransId),
 
4269
    ReadyForSegments = ssmmsr2_mgc_ready_for_segments_fun(), 
4193
4270
    EvSeq = [{debug,  true},
4194
4271
             {decode, DecodeFun},
4195
4272
             {encode, EncodeFun},
4197
4274
             {expect_accept, any},
4198
4275
             {expect_receive, "service-change-request",  {ScrVerifyFun, 5000}},
4199
4276
             {send, "service-change-reply",              ServiceChangeRep},
4200
 
             {expect_nothing, 1000}, 
 
4277
             %% {expect_nothing, 1000}, 
 
4278
             {trigger, "segment send sync trigger", ReadyForSegments}, 
4201
4279
             {send, "notify request",                    NotifyReq},
4202
4280
             {expect_receive, "notify reply: segment 1", {NrVerifyFun1, 1000}},
4203
4281
             {send, "segment reply 1",               SegmentRep1},
4204
4282
             {expect_receive, "notify reply: segment 2", {NrVerifyFun2, 1000}},
4205
 
             %% {expect_nothing, 1000},
4206
4283
             {expect_closed,  20000},
4207
4284
             disconnect
4208
4285
            ],
4209
4286
    EvSeq.
4210
4287
 
 
4288
ssmmsr2_mgc_ready_for_segments_fun() ->
 
4289
    TC = self(),
 
4290
    fun() ->
 
4291
            io:format("ssmmsr2_mgc_ready_for_segments_fun -> entry~n", []),
 
4292
            TC ! {ready_for_segments, mgc, self()},
 
4293
            receive
 
4294
                {continue_with_segments, TC} ->
 
4295
                    io:format("ssmmsr2_mgc_ready_for_segments_fun -> "
 
4296
                              "received continue~n", []),
 
4297
                    ok
 
4298
            end
 
4299
    end.
 
4300
                
4211
4301
ssmmsr2_mgc_encode_msg_fun(Mod, Conf) ->
4212
4302
    fun(M) ->
4213
4303
            Mod:encode_message(Conf, M)
4483
4573
    Tids = [Tid1, Tid2, Tid3, Tid4, Tid5, Tid6, Tid7, Tid8], 
4484
4574
    NotifyReqVerify = ssmmsr2_mg_verify_notify_request_fun(Tids),
4485
4575
    AckVerify = ssmmsr2_mg_verify_ack_fun(), 
 
4576
    ReadyForSegments = ssmmsr2_mg_ready_for_segments_fun(), 
4486
4577
    EvSeq = [
4487
4578
             {debug, true},
4488
4579
             {megaco_trace, disable},
4502
4593
             {megaco_update_conn_info, reply_timer,      12000}, 
4503
4594
             {megaco_update_conn_info, segment_send,     1}, 
4504
4595
             {megaco_update_conn_info, max_pdu_size,     128}, 
4505
 
             {sleep, 1000},
 
4596
             %% {sleep, 1000},
 
4597
             {trigger, ReadyForSegments}, 
4506
4598
             {megaco_callback, handle_trans_request, NotifyReqVerify},
4507
4599
             {megaco_callback, handle_trans_ack,     AckVerify, 15000},
4508
4600
             megaco_stop_user,
4512
4604
    EvSeq.
4513
4605
 
4514
4606
 
 
4607
ssmmsr2_mg_ready_for_segments_fun() ->
 
4608
    TC = self(),
 
4609
    fun() ->
 
4610
            io:format("ssmmsr2_mg_ready_for_segments_fun -> entry~n", []),
 
4611
            TC ! {ready_for_segments, mg, self()},
 
4612
            receive
 
4613
                {continue_with_segments, TC} ->
 
4614
                    io:format("ssmmsr2_mg_ready_for_segments_fun -> "
 
4615
                              "received continue~n", []),
 
4616
                    ok
 
4617
            end
 
4618
    end.
 
4619
                
4515
4620
ssmmsr2_mg_verify_handle_connect_fun() ->
4516
4621
    fun(Ev) -> ssmmsr2_mg_verify_handle_connect(Ev) end.
4517
4622
 
4852
4957
             {listen, 2944},
4853
4958
             {expect_accept, any},
4854
4959
             {expect_receive, "service-change-request", {ScrVerifyFun, 5000}},
 
4960
             {sleep, 500},
 
4961
 
4855
4962
             {send, "service-change-reply",             ServiceChangeRep},
4856
4963
             {expect_receive, "notify-request(1)",      {NrVerifyFun, 4000}},
 
4964
             {sleep, 500},
 
4965
 
4857
4966
             {send, "notify reply - segment 1",         NotifyRep1},
4858
4967
             {expect_receive, "segment reply 1",        {SrVerifyFun1, 2000}},
 
4968
             {sleep, 500},
 
4969
 
4859
4970
             {send, "notify reply - segment 2",         NotifyRep2},
4860
4971
             {expect_receive, "segment reply 2",        {SrVerifyFun2, 2000}},
 
4972
             {sleep, 500},
 
4973
 
4861
4974
             {send, "notify reply - segment 3 (last)",  NotifyRep3},
4862
4975
             {expect_receive, "segment reply 3 (last)", {SrVerifyFun3, 2000}},
4863
4976
             {expect_receive, "ack",                    {AckVerifyFun, 4000}},
5334
5447
             
5335
5448
rsmp_mg_verify_notify_reply(
5336
5449
  {handle_trans_reply, _CH, ?VERSION, {ok, {SN, Last, [AR]}}, _}, SN, Tid) 
5337
 
  when ((SN == 3) and (Last == true)) or 
5338
 
       ((SN =/= 3) and (Last == false)) ->
 
5450
  when ((SN =:= 3) andalso (Last =:= true)) orelse 
 
5451
       ((SN =/= 3) andalso (Last =:= false)) ->
5339
5452
    (catch rsmp_mg_do_verify_notify_reply(Tid, AR));
 
5453
rsmp_mg_verify_notify_reply(
 
5454
  {handle_trans_reply, _CH, Version, {ok, {SN1, Last, ARs}}, _}, SN2, Tid) ->
 
5455
    io:format("rsmp_mg_verify_notify_reply -> unknown reply"
 
5456
              "~n   Version: ~p"
 
5457
              "~n   SN1:     ~p"
 
5458
              "~n   Last:    ~p"
 
5459
              "~n   ARs:     ~p"
 
5460
              "~n   SN2:     ~p"
 
5461
              "~n   Tid:     ~p"
 
5462
              "~n", [Version, SN1, Last, ARs, SN2, Tid]),
 
5463
    Crap = {unexpected_segment_data, [SN1, Last, ARs, SN2, Tid]}, 
 
5464
    {error, Crap, ok};
5340
5465
rsmp_mg_verify_notify_reply(Crap, SN, Tid) ->
5341
5466
    io:format("rsmp_mg_verify_notify_reply -> unknown reply"
5342
5467
              "~n   SN:   ~p"
7599
7724
            ?ERROR({failed, Reply})
7600
7725
    end.
7601
7726
 
7602
 
await_completion(Ids, Timeout) ->
7603
 
    case megaco_test_generator_lib:await_completion(Ids, Timeout) of
7604
 
        {ok, Reply} ->
7605
 
            d("OK => Reply: ~n~p", [Reply]),
7606
 
            ok;
7607
 
        {error, {OK, ERROR}} ->
7608
 
            d("ERROR => "
7609
 
              "~n   OK:    ~p"
7610
 
              "~n   ERROR: ~p", [OK, ERROR]),
7611
 
            ?ERROR({failed, ERROR});
7612
 
        {error, Reply} ->
7613
 
            d("ERROR => Reply: ~n~p", [Reply]),
7614
 
            ?ERROR({failed, Reply})
7615
 
    end.
 
7727
%% await_completion(Ids, Timeout) ->
 
7728
%%     case megaco_test_generator_lib:await_completion(Ids, Timeout) of
 
7729
%%      {ok, Reply} ->
 
7730
%%          d("OK => Reply: ~n~p", [Reply]),
 
7731
%%          ok;
 
7732
%%      {error, {OK, ERROR}} ->
 
7733
%%          d("ERROR => "
 
7734
%%            "~n   OK:    ~p"
 
7735
%%            "~n   ERROR: ~p", [OK, ERROR]),
 
7736
%%          ?ERROR({failed, ERROR});
 
7737
%%      {error, Reply} ->
 
7738
%%          d("ERROR => Reply: ~n~p", [Reply]),
 
7739
%%          ?ERROR({failed, Reply})
 
7740
%%     end.
7616
7741
 
7617
7742
 
7618
7743
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%