1%% 2%% %CopyrightBegin% 3%% 4%% Copyright Ericsson AB 2003-2020. All Rights Reserved. 5%% 6%% Licensed under the Apache License, Version 2.0 (the "License"); 7%% you may not use this file except in compliance with the License. 8%% You may obtain a copy of the License at 9%% 10%% http://www.apache.org/licenses/LICENSE-2.0 11%% 12%% Unless required by applicable law or agreed to in writing, software 13%% distributed under the License is distributed on an "AS IS" BASIS, 14%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15%% See the License for the specific language governing permissions and 16%% limitations under the License. 17%% 18%% %CopyrightEnd% 19%% 20 21%% 22%%---------------------------------------------------------------------- 23%% Purpose: Verify that the transaction sender works with acks. 24%% 25%% Test: ts:run(megaco, megaco_trans_SUITE, [batch]). 26%% 27%%---------------------------------------------------------------------- 28-module(megaco_trans_SUITE). 29 30-export([ 31 suite/0, all/0, groups/0, 32 init_per_suite/1, end_per_suite/1, 33 init_per_group/2, end_per_group/2, 34 init_per_testcase/2, end_per_testcase/2, 35 36 single_ack/1, 37 multi_ack_timeout/1, 38 multi_ack_maxcount/1, 39 40 single_trans_req/1, 41 multi_trans_req_timeout/1, 42 multi_trans_req_maxcount1/1, 43 multi_trans_req_maxcount2/1, 44 multi_trans_req_maxsize1/1, 45 multi_trans_req_maxsize2/1, 46 47 single_trans_req_and_ack/1, 48 multi_trans_req_and_ack_timeout/1, 49 multi_trans_req_and_ack_ackmaxcount/1, 50 multi_trans_req_and_ack_reqmaxcount/1, 51 multi_trans_req_and_ack_maxsize1/1, 52 multi_trans_req_and_ack_maxsize2/1, 53 54 single_trans_req_and_pending/1, 55 multi_trans_req_and_pending/1, 56 multi_trans_req_and_ack_and_pending/1, 57 multi_ack_and_pending/1, 58 59 multi_trans_req_and_reply/1, 60 multi_trans_req_and_ack_and_reply/1, 61 multi_ack_and_reply/1, 62 63 otp_7192_1/1, 64 otp_7192_2/1, 65 otp_7192_3/1 66 67 ]). 68 69-include_lib("megaco/include/megaco.hrl"). 70-include_lib("megaco/include/megaco_message_v1.hrl"). 71-include("megaco_test_lib.hrl"). 72 73-define(VERSION, 1). 74-define(TEST_VERBOSITY, debug). 75-define(MGC_VERBOSITY, debug). 76-define(MG_VERBOSITY, debug). 77 78-define(LOAD_COUNTER_START, 10). 79-define(A4444, ["11111111", "00000000", "00000000"]). 80-define(A4445, ["11111111", "00000000", "11111111"]). 81-define(A5555, ["11111111", "11111111", "00000000"]). 82-define(A5556, ["11111111", "11111111", "11111111"]). 83 84-define(MG, megaco_test_mg). 85-define(MGC, megaco_test_mgc). 86 87-define(MGC_START(Pid, Mid, ET, Verb), ?MGC:start(Pid, Mid, ET, Verb)). 88-define(MGC_STOP(Pid), ?MGC:stop(Pid)). 89-define(MGC_GET_STATS(Pid, No), ?MGC:get_stats(Pid, No)). 90-define(MGC_RESET_STATS(Pid), ?MGC:reset_stats(Pid)). 91-define(MGC_REQ_DISC(Pid,To), ?MGC:request_discard(Pid,To)). 92-define(MGC_REQ_PEND(Pid,To), ?MGC:request_pending(Pid,To)). 93-define(MGC_REQ_HAND(Pid), ?MGC:request_handle(Pid)). 94-define(MGC_REQ_HANDS(Pid), ?MGC:request_handle_sloppy(Pid)). 95-define(MGC_UPDATE_UI(Pid,Tag,Val), ?MGC:update_user_info(Pid,Tag,Val)). 96-define(MGC_UPDATE_CI(Pid,Tag,Val), ?MGC:update_conn_info(Pid,Tag,Val)). 97-define(MGC_USER_INFO(Pid,Tag), ?MGC:user_info(Pid,Tag)). 98-define(MGC_CONN_INFO(Pid,Tag), ?MGC:conn_info(Pid,Tag)). 99-define(MGC_ACK_INFO(Pid,To), ?MGC:ack_info(Pid,To)). 100-define(MGC_REQ_INFO(Pid,To), ?MGC:req_info(Pid,To)). 101 102-define(MG_START(Pid, Mid, Enc, Transp, Conf, Verb), 103 ?MG:start(Pid, Mid, Enc, Transp, Conf, Verb)). 104-define(MG_STOP(Pid), ?MG:stop(Pid)). 105-define(MG_GET_STATS(Pid), ?MG:get_stats(Pid)). 106-define(MG_RESET_STATS(Pid), ?MG:reset_stats(Pid)). 107-define(MG_SERV_CHANGE(Pid), ?MG:service_change(Pid)). 108-define(MG_NOTIF_RAR(Pid), ?MG:notify_request_and_reply(Pid)). 109-define(MG_NOTIF_REQ(Pid), ?MG:notify_request(Pid)). 110-define(MG_NOTIF_AR(Pid), ?MG:await_notify_reply(Pid)). 111-define(MG_CANCEL(Pid,R), ?MG:cancel_request(Pid,R)). 112-define(MG_APPLY_LOAD(Pid,CntStart), ?MG:apply_load(Pid,CntStart)). 113-define(MG_UPDATE_UI(Pid,Tag,Val), ?MG:update_user_info(Pid,Tag,Val)). 114-define(MG_UPDATE_CI(Pid,Tag,Val), ?MG:update_conn_info(Pid,Tag,Val)). 115-define(MG_USER_INFO(Pid,Tag), ?MG:user_info(Pid,Tag)). 116-define(MG_CONN_INFO(Pid,Tag), ?MG:conn_info(Pid,Tag)). 117-define(MG_GRP_REQ(Pid,N), ?MG:group_requests(Pid,N)). 118-define(MG_ACK_INFO(Pid,To), ?MG:ack_info(Pid,To)). 119-define(MG_REP_INFO(Pid,To), ?MG:rep_info(Pid,To)). 120 121 122%%====================================================================== 123%% Common Test interface functions 124%%====================================================================== 125 126suite() -> 127 [{ct_hooks, [ts_install_cth]}]. 128 129all() -> 130 [ 131 {group, ack}, 132 {group, trans_req}, 133 {group, trans_req_and_ack}, 134 {group, pending}, 135 {group, reply}, 136 {group, tickets} 137 ]. 138 139groups() -> 140 [ 141 {ack, [], ack_cases()}, 142 {trans_req, [], trans_req_cases()}, 143 {trans_req_and_ack, [], trans_req_and_ack_cases()}, 144 {pending, [], pending_cases()}, 145 {reply, [], reply_cases()}, 146 {tickets, [], tickets_cases()}, 147 {otp_7192, [], otp_7192_cases()} 148 ]. 149 150ack_cases() -> 151 [ 152 single_ack, 153 multi_ack_timeout, 154 multi_ack_maxcount 155 ]. 156 157trans_req_cases() -> 158 [ 159 single_trans_req, 160 multi_trans_req_timeout, 161 multi_trans_req_maxcount1, 162 multi_trans_req_maxcount2, 163 multi_trans_req_maxsize1, 164 multi_trans_req_maxsize2 165 ]. 166 167trans_req_and_ack_cases() -> 168 [ 169 single_trans_req_and_ack, 170 multi_trans_req_and_ack_timeout, 171 multi_trans_req_and_ack_ackmaxcount, 172 multi_trans_req_and_ack_reqmaxcount, 173 multi_trans_req_and_ack_maxsize1, 174 multi_trans_req_and_ack_maxsize2 175 ]. 176 177pending_cases() -> 178 [ 179 single_trans_req_and_pending, 180 multi_trans_req_and_pending, 181 multi_trans_req_and_ack_and_pending, 182 multi_ack_and_pending 183 ]. 184 185reply_cases() -> 186 [ 187 multi_trans_req_and_reply, 188 multi_trans_req_and_ack_and_reply, 189 multi_ack_and_reply 190 ]. 191 192tickets_cases() -> 193 [ 194 {group, otp_7192} 195 ]. 196 197otp_7192_cases() -> 198 [ 199 otp_7192_1, 200 otp_7192_2, 201 otp_7192_3 202 ]. 203 204 205 206 207%% 208%% ----- 209%% 210 211init_per_suite(suite) -> 212 []; 213init_per_suite(doc) -> 214 []; 215init_per_suite(Config0) when is_list(Config0) -> 216 217 ?ANNOUNCE_SUITE_INIT(), 218 219 p("init_per_suite -> entry with" 220 "~n Config: ~p" 221 "~n Nodes: ~p", [Config0, erlang:nodes()]), 222 223 case ?LIB:init_per_suite(Config0) of 224 {skip, _} = SKIP -> 225 SKIP; 226 227 Config1 when is_list(Config1) -> 228 229 %% We need a (local) monitor on this node also 230 megaco_test_sys_monitor:start(), 231 232 p("init_per_suite -> end when" 233 "~n Config: ~p" 234 "~n Nodes: ~p", [Config1, erlang:nodes()]), 235 236 Config1 237 end. 238 239end_per_suite(suite) -> []; 240end_per_suite(doc) -> []; 241end_per_suite(Config0) when is_list(Config0) -> 242 243 p("end_per_suite -> entry with" 244 "~n Config: ~p" 245 "~n Nodes: ~p", [Config0, erlang:nodes()]), 246 247 megaco_test_sys_monitor:stop(), 248 Config1 = ?LIB:end_per_suite(Config0), 249 250 p("end_per_suite -> end when" 251 "~n Nodes: ~p", [erlang:nodes()]), 252 253 Config1. 254 255 256%% 257%% ----- 258%% 259 260init_per_group(Group, Config) -> 261 ?ANNOUNCE_GROUP_INIT(Group), 262 Config. 263 264end_per_group(_GroupName, Config) -> 265 Config. 266 267 268 269%% 270%% ----- 271%% 272 273init_per_testcase(multi_ack_maxcount = Case, Config) -> 274 C = lists:keydelete(tc_timeout, 1, Config), 275 init_per_testcase2(Case, [{tc_timeout,timer:minutes(10)}|C]); 276init_per_testcase(Case, Config) -> 277 process_flag(trap_exit, true), 278 init_per_testcase2(Case, Config). 279 280init_per_testcase2(Case, Config) -> 281 process_flag(trap_exit, true), 282 283 p("init_per_suite -> entry with" 284 "~n Config: ~p" 285 "~n Nodes: ~p", [Config, erlang:nodes()]), 286 287 megaco_test_global_sys_monitor:reset_events(), 288 megaco_test_lib:init_per_testcase(Case, Config). 289 290end_per_testcase(Case, Config) -> 291 process_flag(trap_exit, false), 292 293 p("end_per_suite -> entry with" 294 "~n Config: ~p" 295 "~n Nodes: ~p", [Config, erlang:nodes()]), 296 297 p("system events during test: " 298 "~n ~p", [megaco_test_global_sys_monitor:events()]), 299 300 megaco_test_lib:end_per_testcase(Case, Config). 301 302 303 304%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 305 306single_ack(suite) -> 307 []; 308single_ack(doc) -> 309 []; 310single_ack(Config) when is_list(Config) -> 311 Pre = fun() -> 312 MgcNode = make_node_name(mgc), 313 MgNode = make_node_name(mg), 314 d("start nodes: " 315 "~n MGC Node: ~p" 316 "~n MG Node: ~p", 317 [MgcNode, MgNode]), 318 Nodes = [MgcNode, MgNode], 319 ok = ?START_NODES(Nodes), 320 Nodes 321 end, 322 Case = fun do_single_ack/1, 323 Post = fun(Nodes) -> 324 d("stop nodes"), 325 ?STOP_NODES(lists:reverse(Nodes)) 326 end, 327 try_tc(rsingle_ack, Pre, Case, Post). 328 329do_single_ack([MgcNode, MgNode]) -> 330 %% Start the MGC and MGs 331 i("[MGC] start"), 332 ET = [{text,tcp}, {text,udp}, {binary,tcp}, {binary,udp}], 333 {ok, Mgc} = 334 ?MGC_START(MgcNode, {deviceName, "ctrl"}, ET, ?MGC_VERBOSITY), 335 336 i("[MG] start"), 337 %% MgConf0 = [{MgNode, "mg", text, tcp, ?MG_VERBOSITY}], 338 MgMid = {deviceName, "mg"}, 339 MgConfig = [{auto_ack, true}, {trans_timer, 5000}, {trans_ack, true}], 340 {ok, Mg} = ?MG_START(MgNode, MgMid, text, tcp, MgConfig, ?MG_VERBOSITY), 341 342 d("MG user info: ~p", [?MG_USER_INFO(Mg, all)]), 343 344 i("[MG] connect to the MGC (service change)"), 345 ServChRes = ?MG_SERV_CHANGE(Mg), 346 d("service change result: ~p", [ServChRes]), 347 348 d("MG conn info: ~p", [?MG_CONN_INFO(Mg, all)]), 349 350 d("ensure the megaco stack calls the handle_trans_ack callback"), 351 ?MGC_REQ_HANDS(Mgc), 352 353 d("tell the MGC to send the ack's to us"), 354 ?MGC_ACK_INFO(Mgc, self()), 355 356 d("send the notify"), 357 ?MG_GRP_REQ(Mg, 1), 358 359 d("send the notify"), 360 ?MG_NOTIF_REQ(Mg), 361 362 d("await the ack"), 363 await_ack(Mgc, 1, infinity, ok), 364 365 %% Tell MG to stop 366 i("[MG] stop"), 367 ?MG_STOP(Mg), 368 369 %% Tell Mgc to stop 370 i("[MGC] stop"), 371 ?MGC_STOP(Mgc), 372 373 i("done", []), 374 ok. 375 376 377%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 378 379multi_ack_timeout(suite) -> 380 []; 381multi_ack_timeout(doc) -> 382 []; 383multi_ack_timeout(Config) when is_list(Config) -> 384 Pre = fun() -> 385 %% <CONDITIONAL-SKIP> 386 Skippable = [win32, {unix, [darwin, linux, sunos]}], 387 Condition = fun() -> ?OS_BASED_SKIP(Skippable) end, 388 ?NON_PC_TC_MAYBE_SKIP(Config, Condition), 389 %% </CONDITIONAL-SKIP> 390 391 MgcNode = make_node_name(mgc), 392 MgNode = make_node_name(mg), 393 d("start nodes: " 394 "~n MGC Node: ~p" 395 "~n MG Node: ~p", 396 [MgcNode, MgNode]), 397 Nodes = [MgcNode, MgNode], 398 ok = ?START_NODES(Nodes), 399 Nodes 400 end, 401 Case = fun do_multi_ack_timeout/1, 402 Post = fun(Nodes) -> 403 d("stop nodes"), 404 ?STOP_NODES(lists:reverse(Nodes)) 405 end, 406 try_tc(multi_ack_timeout, Pre, Case, Post). 407 408do_multi_ack_timeout([MgcNode, MgNode]) -> 409 410 MaxCount = 20, 411 412 %% Start the MGC and MGs 413 i("[MGC] start"), 414 ET = [{text,tcp}, {text,udp}, {binary,tcp}, {binary,udp}], 415 {ok, Mgc} = 416 ?MGC_START(MgcNode, {deviceName, "ctrl"}, ET, ?MGC_VERBOSITY), 417 418 i("[MG] start"), 419 %% MgConf0 = [{MgNode, "mg", text, tcp, ?MG_VERBOSITY}], 420 MgMid = {deviceName, "mg"}, 421 MgConfig = [{auto_ack, true}, 422 {trans_ack, true}, 423 {trans_timer, 10000}, 424 {trans_ack_maxcount, MaxCount + 10}], 425 {ok, Mg} = ?MG_START(MgNode, MgMid, text, tcp, MgConfig, ?MG_VERBOSITY), 426 427 d("MG user info: ~p", [?MG_USER_INFO(Mg, all)]), 428 429 i("[MG] connect the MGC (service change)"), 430 ServChRes = ?MG_SERV_CHANGE(Mg), 431 d("service change result: ~p", [ServChRes]), 432 433 i("wait some time"), 434 sleep(1000), 435 436 d("MG conn info: ~p", [?MG_CONN_INFO(Mg, all)]), 437 438 {ok, _OldAction} = ?MGC_REQ_HANDS(Mgc), 439 440 d("tell the MGC to send the ack's to us"), 441 ?MGC_ACK_INFO(Mgc, self()), 442 443 d("set group size to ~p", [MaxCount]), 444 ?MG_GRP_REQ(Mg, MaxCount), 445 446 d("[MG] send a group of requests (and await the replies)"), 447 ?MG_NOTIF_RAR(Mg), 448 449 d("await the ack(s)"), 450 await_ack(Mgc, MaxCount, 60000, ok), 451 452 i("wait some time before closing down"), 453 sleep(5000), 454 455 %% Tell MG to stop 456 i("[MG] stop"), 457 ?MG_STOP(Mg), 458 459 %% Tell Mgc to stop 460 i("[MGC] stop"), 461 ?MGC_STOP(Mgc), 462 463 i("done"), 464 ok. 465 466 467 468%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 469 470multi_ack_maxcount(suite) -> 471 []; 472multi_ack_maxcount(doc) -> 473 []; 474multi_ack_maxcount(Config) when is_list(Config) -> 475 Pre = fun() -> 476 MgcNode = make_node_name(mgc), 477 MgNode = make_node_name(mg), 478 d("start nodes: " 479 "~n MGC Node: ~p" 480 "~n MG Node: ~p", 481 [MgcNode, MgNode]), 482 Nodes = [MgcNode, MgNode], 483 ok = ?START_NODES(Nodes), 484 Nodes 485 end, 486 Case = fun do_multi_ack_maxcount/1, 487 Post = fun(Nodes) -> 488 d("stop nodes"), 489 ?STOP_NODES(lists:reverse(Nodes)) 490 end, 491 try_tc(multi_ack_maxcount, Pre, Case, Post). 492 493do_multi_ack_maxcount([MgcNode, MgNode]) -> 494 MaxCount = 10, 495 496 %% Start the MGC and MGs 497 i("[MGC] start"), 498 ET = [{text,tcp}, {text,udp}, {binary,tcp}, {binary,udp}], 499 {ok, Mgc} = 500 ?MGC_START(MgcNode, {deviceName, "ctrl"}, ET, ?MGC_VERBOSITY), 501 502 i("[MG] start"), 503 %% MgConf0 = [{MgNode, "mg", text, tcp, ?MG_VERBOSITY}], 504 MgMid = {deviceName, "mg"}, 505 MgConfig = [%% {auto_ack, true}, 506 %% {trans_timer, 120000}, 507 %% {trans_ack_maxcount, MaxCount} 508 ], 509 {ok, Mg} = ?MG_START(MgNode, MgMid, text, tcp, MgConfig, ?MG_VERBOSITY), 510 511 d("MG user info: ~p", [?MG_USER_INFO(Mg, all)]), 512 513 i("[MG] connect the MGC (service change)"), 514 ServChRes = ?MG_SERV_CHANGE(Mg), 515 d("service change result: ~p", [ServChRes]), 516 517 i("wait some time"), 518 sleep(1000), 519 520 d("MG conn info: ~p", [?MG_CONN_INFO(Mg, all)]), 521 522 ?MG_UPDATE_CI(Mg,auto_ack,true), 523 ?MG_UPDATE_CI(Mg,trans_timer,120000), 524 ?MG_UPDATE_CI(Mg,trans_ack_maxcount,MaxCount), 525 ?MG_UPDATE_CI(Mg,trans_ack,true), 526 527 d("MG conn info: ~p", [?MG_CONN_INFO(Mg, all)]), 528 529 {ok, _OldAction} = ?MGC_REQ_HANDS(Mgc), 530 531 d("tell the MGC to send the ack's to us"), 532 ?MGC_ACK_INFO(Mgc, self()), 533 534 d("set group size to ~p", [MaxCount]), 535 ?MG_GRP_REQ(Mg, MaxCount), 536 537 d("[MG] send a group of requests (and await the replies)"), 538 ?MG_NOTIF_RAR(Mg), 539 540 d("await the ack"), 541 await_ack(Mgc, MaxCount, 60000, ok), 542 543 i("wait some time before closing down"), 544 sleep(5000), 545 546 %% Tell MG to stop 547 i("[MG] stop"), 548 ?MG_STOP(Mg), 549 550 %% Tell Mgc to stop 551 i("[MGC] stop"), 552 ?MGC_STOP(Mgc), 553 554 i("done"), 555 ok. 556 557 558 559%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 560 561single_trans_req(suite) -> 562 []; 563single_trans_req(doc) -> 564 []; 565single_trans_req(Config) when is_list(Config) -> 566 Pre = fun() -> 567 MgcNode = make_node_name(mgc), 568 MgNode = make_node_name(mg), 569 d("start nodes: " 570 "~n MGC Node: ~p" 571 "~n MG Node: ~p", 572 [MgcNode, MgNode]), 573 Nodes = [MgcNode, MgNode], 574 ok = ?START_NODES(Nodes), 575 Nodes 576 end, 577 Case = fun do_single_trans_req/1, 578 Post = fun(Nodes) -> 579 d("stop nodes"), 580 ?STOP_NODES(lists:reverse(Nodes)) 581 end, 582 try_tc(single_trans_req, Pre, Case, Post). 583 584do_single_trans_req([MgcNode, MgNode]) -> 585 586 d("[MGC] start the simulator "), 587 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 588 589 d("[MGC] create the event sequence"), 590 MgcEvSeq = str_mgc_event_sequence(text, tcp), 591 592 i("wait some time before starting the MGC simulation"), 593 sleep(1000), 594 595 d("[MGC] start the simulation"), 596 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 597 598 %% i("wait some time before starting the MG simulator"), 599 %% sleep(1000), 600 601 i("await MGC ready announcement"), 602 receive 603 announce_mgc -> 604 i("received MGC ready announcement"), 605 ok 606 end, 607 608 d("[MG] start the simulator (generator)"), 609 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 610 611 d("[MG] create the event sequence"), 612 MgEvSeq = str_mg_event_sequence(text, tcp), 613 614 i("wait some time before starting the MG simulation"), 615 sleep(1000), 616 617 d("[MG] start the simulation"), 618 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 619 620 d("await the generator reply(s)"), 621 await_completion([MgcId, MgId]), 622 623 %% Tell Mgc to stop 624 i("[MGC] stop generator"), 625 megaco_test_megaco_generator:stop(Mgc), 626 627 %% Tell Mg to stop 628 i("[MG] stop generator"), 629 megaco_test_megaco_generator:stop(Mg), 630 631 i("done", []), 632 ok. 633 634 635%% 636%% MGC generator stuff 637%% 638-ifdef(megaco_hipe_special). 639-define(str_mgc_connect_verify_fun(), 640 {?MODULE, str_mgc_verify_handle_connect, []}). 641-define(str_mgc_service_change_req_verify_fun(Mid), 642 {?MODULE, str_mgc_verify_service_change_req, [Mid]}). 643-define(str_mgc_notify_req_verify_fun(), 644 {?MODULE, str_mgc_verify_notify_request, []}). 645-define(str_mgc_disco_verify_fun(), 646 {?MODULE, str_mgc_verify_handle_disconnect, []}). 647-else. 648-define(str_mgc_connect_verify_fun(), 649 fun str_mgc_verify_handle_connect/1). 650-define(str_mgc_service_change_req_verify_fun(Mid), 651 str_mgc_verify_service_change_req_fun(Mid)). 652-define(str_mgc_notify_req_verify_fun(), 653 str_mgc_verify_notify_request_fun()). 654-define(str_mgc_disco_verify_fun(), 655 fun str_mgc_verify_handle_disconnect/1). 656-endif. 657 658str_mgc_event_sequence(text, tcp) -> 659 CTRL = self(), 660 Mid = {deviceName,"ctrl"}, 661 RI = [ 662 {port, 2944}, 663 {encoding_module, megaco_pretty_text_encoder}, 664 {encoding_config, []}, 665 {transport_module, megaco_tcp} 666 ], 667 ConnectVerify = ?str_mgc_connect_verify_fun(), 668 ServiceChangeReqVerify = ?str_mgc_service_change_req_verify_fun(Mid), 669 NotifyReqVerify = ?str_mgc_notify_req_verify_fun(), 670 DiscoVerify = ?str_mgc_disco_verify_fun(), 671 EvSeq = [ 672 {debug, false}, 673 {megaco_trace, disable}, 674 megaco_start, 675 {megaco_start_user, Mid, RI, []}, 676 start_transport, 677 listen, 678 679 %% ANNOUNCE READY 680 {trigger, fun() -> CTRL ! announce_mgc end}, 681 682 {megaco_callback, handle_connect, ConnectVerify}, 683 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 684 {megaco_callback, handle_trans_request, NotifyReqVerify}, 685 {megaco_callback, handle_disconnect, DiscoVerify}, 686 {sleep, 1000}, 687 megaco_stop_user, 688 megaco_stop 689 ], 690 EvSeq. 691 692 693str_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 694 io:format("str_mgc_verify_handle_connect -> ok" 695 "~n CH: ~p~n", [CH]), 696 {ok, CH, ok}; 697str_mgc_verify_handle_connect(Else) -> 698 io:format("str_mgc_verify_handle_connect -> unknown" 699 "~n Else: ~p~n", [Else]), 700 {error, Else, ok}. 701 702 703str_mgc_verify_service_change_req_fun(Mid) -> 704 fun(Ev) -> 705 str_mgc_verify_service_change_req(Ev, Mid) 706 end. 707 708str_mgc_verify_service_change_req( 709 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 710 io:format("str_mgc_verify_service_change_req -> ok" 711 "~n AR: ~p~n", [AR]), 712 case AR of 713 #'ActionRequest'{commandRequests = [CR]} -> 714 case CR of 715 #'CommandRequest'{command = Cmd} -> 716 case Cmd of 717 {serviceChangeReq, 718 #'ServiceChangeRequest'{terminationID = [Tid], 719 serviceChangeParms = Parms}} -> 720 case Tid of 721 #megaco_term_id{contains_wildcards = false, 722 id = ["root"]} -> 723 case Parms of 724 #'ServiceChangeParm'{ 725 serviceChangeMethod = restart, 726 serviceChangeReason = [[$9,$0,$1|_]]} -> 727 Reply = 728 {discard_ack, 729 [str_mgc_service_change_reply_ar(Mid, 1)]}, 730 {ok, AR, Reply}; 731 _ -> 732 Err = {invalid_SCP, Parms}, 733 ED = str_err_desc(Parms), 734 ErrReply = {discard_ack, 735 ED}, 736 {error, Err, ErrReply} 737 end; 738 _ -> 739 Err = {invalid_termination_id, Tid}, 740 ED = str_err_desc(Tid), 741 ErrReply = {discard_ack, ED}, 742 {error, Err, ErrReply} 743 end; 744 _ -> 745 Err = {invalid_command, Cmd}, 746 ED = str_err_desc(Cmd), 747 ErrReply = {discard_ack, ED}, 748 {error, Err, ErrReply} 749 end; 750 _ -> 751 Err = {invalid_command_request, CR}, 752 ED = str_err_desc(CR), 753 ErrReply = {discard_ack, ED}, 754 {error, Err, ErrReply} 755 end; 756 _ -> 757 Err = {invalid_action_request, AR}, 758 ED = str_err_desc(AR), 759 ErrReply = {discard_ack, ED}, 760 {error, Err, ErrReply} 761 end; 762str_mgc_verify_service_change_req(Else, _Mid) -> 763 io:format("str_mgc_verify_service_change_req -> unknown" 764 "~n Else: ~p~n", [Else]), 765 ED = str_err_desc(Else), 766 ErrReply = {discard_ack, ED}, 767 {error, Else, ErrReply}. 768 769 770str_mgc_verify_notify_request_fun() -> 771 fun(Ev) -> 772 str_mgc_verify_notify_request(Ev) 773 end. 774 775str_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 776 io:format("str_mgc_verify_notify_request:fun -> ok" 777 "~n AR: ~p~n", [AR]), 778 case AR of 779 #'ActionRequest'{contextId = Cid, 780 commandRequests = [CR]} -> 781 #'CommandRequest'{command = Cmd} = CR, 782 {notifyReq, NR} = Cmd, 783 #'NotifyRequest'{terminationID = [Tid], 784 observedEventsDescriptor = OED, 785 errorDescriptor = asn1_NOVALUE} = NR, 786 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 787 #'ObservedEvent'{eventName = "al/of"} = OE, 788 Reply = {discard_ack, [str_mgc_notify_reply_ar(Cid, Tid)]}, 789 {ok, AR, Reply}; 790 _ -> 791 ED = str_err_desc(AR), 792 ErrReply = {discard_ack, ED}, 793 {error, AR, ErrReply} 794 end; 795str_mgc_verify_notify_request(Else) -> 796 io:format("str_mgc_verify_notify_request:fun -> unknown" 797 "~n Else: ~p~n", [Else]), 798 ED = str_err_desc(Else), 799 ErrReply = {discard_ack, ED}, 800 {error, Else, ErrReply}. 801 802 803str_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 804 io:format("str_mgc_verify_handle_disconnect -> ok" 805 "~n CH: ~p" 806 "~n R: ~p" 807 "~n", [CH, R]), 808 {ok, CH, ok}; 809str_mgc_verify_handle_disconnect(Else) -> 810 io:format("str_mgc_verify_handle_disconnect -> unknown" 811 "~n Else: ~p~n", [Else]), 812 {error, Else, ok}. 813 814 815str_mgc_service_change_reply_ar(Mid, Cid) -> 816 SCRP = cre_serviceChangeResParm(Mid), 817 SCRes = cre_serviceChangeResult(SCRP), 818 Root = #megaco_term_id{id = ["root"]}, 819 SCR = cre_serviceChangeReply([Root], SCRes), 820 CR = cre_cmdReply(SCR), 821 cre_actionReply(Cid, [CR]). 822 823%% str_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 824%% AR = str_mgc_service_change_reply_ar(Mid, Cid), 825%% TRes = cre_transResult([AR]), 826%% TR = cre_transReply(TransId, TRes), 827%% Trans = cre_transaction(TR), 828%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 829%% cre_megacoMessage(Mess). 830 831str_mgc_notify_reply_ar(Cid, TermId) -> 832 NR = cre_notifyReply([TermId]), 833 CR = cre_cmdReply(NR), 834 cre_actionReply(Cid, [CR]). 835 836%% str_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 837%% AR = str_mgc_notify_reply_ar(Cid, TermId), 838%% TRes = cre_transResult([AR]), 839%% TR = cre_transReply(TransId, TRes), 840%% Trans = cre_transaction(TR), 841%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 842%% cre_megacoMessage(Mess). 843 844 845%% 846%% MG generator stuff 847%% 848-ifdef(megaco_hipe_special). 849-define(str_mg_connect_verify_fun(), 850 {?MODULE, str_mg_verify_handle_connect, []}). 851-define(str_mg_service_change_reply_verify_fun(), 852 {?MODULE, str_mg_verify_service_change_reply, []}). 853-define(str_mg_notify_reply_verify_fun(), 854 {?MODULE, str_mg_verify_notify_reply, []}). 855-else. 856-define(str_mg_connect_verify_fun(), 857 fun str_mg_verify_handle_connect/1). 858-define(str_mg_service_change_reply_verify_fun(), 859 fun str_mg_verify_service_change_reply/1). 860-define(str_mg_notify_reply_verify_fun(), 861 fun str_mg_verify_notify_reply/1). 862-endif. 863 864str_mg_event_sequence(text, tcp) -> 865 Mid = {deviceName,"mg"}, 866 RI = [ 867 {port, 2944}, 868 {encoding_module, megaco_pretty_text_encoder}, 869 {encoding_config, []}, 870 {transport_module, megaco_tcp} 871 ], 872 ServiceChangeReq = [str_mg_service_change_request_ar(Mid, 1)], 873 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 874 NotifyReq = [str_mg_notify_request_ar(1, Tid, 1)], 875 ConnectVerify = ?str_mg_connect_verify_fun(), 876 ServiceChangeReplyVerify = ?str_mg_service_change_reply_verify_fun(), 877 NotifyReplyVerify = ?str_mg_notify_reply_verify_fun(), 878 EvSeq = [ 879 {debug, true}, 880 megaco_start, 881 {megaco_start_user, Mid, RI, []}, 882 start_transport, 883 {megaco_trace, max}, 884 {megaco_system_info, users}, 885 {megaco_system_info, connections}, 886 connect, 887 {megaco_callback, handle_connect, ConnectVerify}, 888 megaco_connect, 889 {megaco_cast, ServiceChangeReq, []}, 890 {megaco_callback, handle_connect, ConnectVerify}, 891 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 892 {sleep, 1000}, 893 {megaco_cast, NotifyReq, []}, 894 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 895 {sleep, 1000}, 896 megaco_stop_user, 897 megaco_stop, 898 {sleep, 1000} 899 ], 900 EvSeq. 901 902str_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 903 io:format("str_mg_verify_handle_connect -> ok" 904 "~n CH: ~p~n", [CH]), 905 {ok, CH, ok}; 906str_mg_verify_handle_connect(Else) -> 907 io:format("str_mg_verify_handle_connect -> unknown" 908 "~n Else: ~p~n", [Else]), 909 {error, Else, ok}. 910 911str_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 912 {ok, [AR]}, _}) -> 913 io:format("str_mg_verify_service_change_reply -> ok" 914 "~n AR: ~p~n", [AR]), 915 case AR of 916 #'ActionReply'{commandReply = [SCR]} -> 917 case SCR of 918 {serviceChangeReply, 919 #'ServiceChangeReply'{terminationID = [Tid], 920 serviceChangeResult = Res}} -> 921 case Tid of 922 #megaco_term_id{contains_wildcards = false, 923 id = ["root"]} -> 924 case Res of 925 {serviceChangeResParms, 926 #'ServiceChangeResParm'{ 927 serviceChangeMgcId = _RemoteMid}} -> 928 {ok, AR, ok}; 929 {Tag, Val} -> 930 Err = {invalid_service_change_result, 931 Tag, Val}, 932 {error, Err, ok} 933 end; 934 _ -> 935 Err = {invalid_termination_id, Tid}, 936 {error, Err, ok} 937 end; 938 {Tag, Val} -> 939 Err = {invalid_command_reply, Tag, Val}, 940 {error, Err, ok} 941 end; 942 _ -> 943 Err = {invalid_action_reply, AR}, 944 {error, Err, ok} 945 end; 946str_mg_verify_service_change_reply(Else) -> 947 io:format("str_mg_verify_service_change_reply -> unknown" 948 "~n Else: ~p~n", [Else]), 949 {error, Else, ok}. 950 951str_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 952 {ok, [AR]}, _}) -> 953 io:format("str_mg_verify_notify_reply -> ok" 954 "~n AR: ~p~n", [AR]), 955 {ok, AR, ok}; 956str_mg_verify_notify_reply(Else) -> 957 io:format("str_mg_verify_notify_reply -> unknown" 958 "~n Else: ~p~n", [Else]), 959 {error, Else, ok}. 960 961str_mg_service_change_request_ar(_Mid, Cid) -> 962 Prof = cre_serviceChangeProf("resgw", 1), 963 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 964 Root = #megaco_term_id{id = ["root"]}, 965 SCR = cre_serviceChangeReq([Root], SCP), 966 CMD = cre_command(SCR), 967 CR = cre_cmdReq(CMD), 968 cre_actionReq(Cid, [CR]). 969 970%% str_mg_service_change_request_msg(Mid, TransId, Cid) -> 971%% AR = str_mg_service_change_request_ar(Mid, Cid), 972%% TR = cre_transReq(TransId, [AR]), 973%% Trans = cre_transaction(TR), 974%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 975%% cre_megacoMessage(Mess). 976 977str_mg_notify_request_ar(Rid, Tid, Cid) -> 978 TT = cre_timeNotation("19990729", "22000000"), 979 Ev = cre_obsEvent("al/of", TT), 980 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 981 NR = cre_notifyReq([Tid], EvsDesc), 982 CMD = cre_command(NR), 983 CR = cre_cmdReq(CMD), 984 cre_actionReq(Cid, [CR]). 985 986%% str_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 987%% AR = str_mg_notify_request_ar(Rid, TermId, Cid), 988%% TR = cre_transReq(TransId, [AR]), 989%% Trans = cre_transaction(TR), 990%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 991%% cre_megacoMessage(Mess). 992 993 994%% 995%% Common functions for the single_trans_req test case 996%% 997 998str_err_desc(T) -> 999 EC = ?megaco_internal_gateway_error, 1000 ET = lists:flatten(io_lib:format("~w",[T])), 1001 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 1002 1003 1004%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 1005 1006multi_trans_req_timeout(suite) -> 1007 []; 1008multi_trans_req_timeout(doc) -> 1009 []; 1010multi_trans_req_timeout(Config) when is_list(Config) -> 1011 Pre = fun() -> 1012 MgcNode = make_node_name(mgc), 1013 MgNode = make_node_name(mg), 1014 d("start nodes: " 1015 "~n MGC Node: ~p" 1016 "~n MG Node: ~p", 1017 [MgcNode, MgNode]), 1018 Nodes = [MgcNode, MgNode], 1019 ok = ?START_NODES(Nodes), 1020 Nodes 1021 end, 1022 Case = fun do_multi_trans_req_timeout/1, 1023 Post = fun(Nodes) -> 1024 d("stop nodes"), 1025 ?STOP_NODES(lists:reverse(Nodes)) 1026 end, 1027 try_tc(request_and_no_reply, Pre, Case, Post). 1028 1029do_multi_trans_req_timeout([MgcNode, MgNode]) -> 1030 1031 d("[MGC] start the simulator "), 1032 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 1033 1034 d("[MGC] create the event sequence"), 1035 MgcEvSeq = mtrt_mgc_event_sequence(text, tcp), 1036 1037 i("wait some time before starting the MGC simulation"), 1038 sleep(1000), 1039 1040 d("[MGC] start the simulation"), 1041 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 1042 1043 %% i("wait some time before starting the MG simulator"), 1044 %% sleep(1000), 1045 1046 i("await MGC ready announcement"), 1047 receive 1048 announce_mgc -> 1049 i("received MGC ready announcement"), 1050 ok 1051 end, 1052 1053 d("[MG] start the simulator (generator)"), 1054 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 1055 1056 d("[MG] create the event sequence"), 1057 MgEvSeq = mtrt_mg_event_sequence(text, tcp), 1058 1059 i("wait some time before starting the MG simulation"), 1060 sleep(1000), 1061 1062 d("[MG] start the simulation"), 1063 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 1064 1065 d("await the generator reply(s)"), 1066 await_completion([MgcId, MgId]), 1067 1068 %% Tell Mgc to stop 1069 i("[MGC] stop generator"), 1070 megaco_test_megaco_generator:stop(Mgc), 1071 1072 %% Tell Mg to stop 1073 i("[MG] stop generator"), 1074 megaco_test_megaco_generator:stop(Mg), 1075 1076 i("done", []), 1077 ok. 1078 1079 1080%% 1081%% MGC generator stuff 1082%% 1083-ifdef(megaco_hipe_special). 1084-define(mtrt_mgc_verify_handle_connect_fun(), 1085 {?MODULE, mtrt_mgc_verify_handle_connect, []}). 1086-define(mtrt_mgc_verify_service_change_req_fun(Mid), 1087 {?MODULE, mtrt_mgc_verify_service_change_req, [Mid]}). 1088-define(mtrt_mgc_verify_notify_req_fun(), 1089 {?MODULE, mtrt_mgc_verify_notify_request, []}). 1090-define(mtrt_mgc_verify_handle_disconnect_fun(), 1091 {?MODULE, mtrt_mgc_verify_handle_disconnect, []}). 1092-else. 1093-define(mtrt_mgc_verify_handle_connect_fun(), 1094 fun mtrt_mgc_verify_handle_connect/1). 1095-define(mtrt_mgc_verify_service_change_req_fun(Mid), 1096 mtrt_mgc_verify_service_change_req_fun(Mid)). 1097-define(mtrt_mgc_verify_notify_req_fun(), 1098 mtrt_mgc_verify_notify_request_fun()). 1099-define(mtrt_mgc_verify_handle_disconnect_fun(), 1100 fun mtrt_mgc_verify_handle_disconnect/1). 1101-endif. 1102 1103mtrt_mgc_event_sequence(text, tcp) -> 1104 CTRL = self(), 1105 Mid = {deviceName,"ctrl"}, 1106 RI = [ 1107 {port, 2944}, 1108 {encoding_module, megaco_pretty_text_encoder}, 1109 {encoding_config, []}, 1110 {transport_module, megaco_tcp} 1111 ], 1112 ConnectVerify = ?mtrt_mgc_verify_handle_connect_fun(), 1113 ServiceChangeReqVerify = ?mtrt_mgc_verify_service_change_req_fun(Mid), 1114 NotifyReqVerify = ?mtrt_mgc_verify_notify_req_fun(), 1115 DiscoVerify = ?mtrt_mgc_verify_handle_disconnect_fun(), 1116 EvSeq = [ 1117 {debug, true}, 1118 {megaco_trace, disable}, 1119 megaco_start, 1120 {megaco_start_user, Mid, RI, []}, 1121 start_transport, 1122 listen, 1123 1124 %% ANNOUNCE READY 1125 {trigger, fun() -> CTRL ! announce_mgc end}, 1126 1127 {megaco_callback, handle_connect, ConnectVerify}, 1128 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 1129 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1130 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1131 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1132 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1133 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1134 {megaco_callback, handle_disconnect, DiscoVerify}, 1135 {sleep, 1000}, 1136 megaco_stop_user, 1137 megaco_stop 1138 ], 1139 EvSeq. 1140 1141 1142mtrt_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 1143 io:format("mtrt_mgc_verify_handle_connect -> ok" 1144 "~n CH: ~p~n", [CH]), 1145 {ok, CH, ok}; 1146mtrt_mgc_verify_handle_connect(Else) -> 1147 io:format("mtrt_mgc_verify_handle_connect -> unknown" 1148 "~n Else: ~p~n", [Else]), 1149 {error, Else, ok}. 1150 1151mtrt_mgc_verify_service_change_req_fun(Mid) -> 1152 fun(Ev) -> 1153 mtrt_mgc_verify_service_change_req(Ev, Mid) 1154 end. 1155 1156mtrt_mgc_verify_service_change_req( 1157 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 1158 io:format("mtrt_mgc_verify_service_change_req -> ok" 1159 "~n AR: ~p~n", [AR]), 1160 case AR of 1161 #'ActionRequest'{commandRequests = [CR]} -> 1162 case CR of 1163 #'CommandRequest'{command = Cmd} -> 1164 case Cmd of 1165 {serviceChangeReq, 1166 #'ServiceChangeRequest'{terminationID = [Tid], 1167 serviceChangeParms = Parms}} -> 1168 case Tid of 1169 #megaco_term_id{contains_wildcards = false, 1170 id = ["root"]} -> 1171 case Parms of 1172 #'ServiceChangeParm'{ 1173 serviceChangeMethod = restart, 1174 serviceChangeReason = [[$9,$0,$1|_]]} -> 1175 Reply = 1176 {discard_ack, 1177 [mtrt_mgc_service_change_reply_ar(Mid, 1)]}, 1178 {ok, AR, Reply}; 1179 _ -> 1180 Err = {invalid_SCP, Parms}, 1181 ED = mtrt_err_desc(Parms), 1182 ErrReply = {discard_ack, 1183 ED}, 1184 {error, Err, ErrReply} 1185 end; 1186 _ -> 1187 Err = {invalid_termination_id, Tid}, 1188 ED = mtrt_err_desc(Tid), 1189 ErrReply = {discard_ack, ED}, 1190 {error, Err, ErrReply} 1191 end; 1192 _ -> 1193 Err = {invalid_command, Cmd}, 1194 ED = mtrt_err_desc(Cmd), 1195 ErrReply = {discard_ack, ED}, 1196 {error, Err, ErrReply} 1197 end; 1198 _ -> 1199 Err = {invalid_command_request, CR}, 1200 ED = mtrt_err_desc(CR), 1201 ErrReply = {discard_ack, ED}, 1202 {error, Err, ErrReply} 1203 end; 1204 _ -> 1205 Err = {invalid_action_request, AR}, 1206 ED = mtrt_err_desc(AR), 1207 ErrReply = {discard_ack, ED}, 1208 {error, Err, ErrReply} 1209 end; 1210mtrt_mgc_verify_service_change_req(Else, _Mid) -> 1211 io:format("mtrt_mgc_verify_service_change_req -> unknown" 1212 "~n Else: ~p~n", [Else]), 1213 ED = mtrt_err_desc(Else), 1214 ErrReply = {discard_ack, ED}, 1215 {error, Else, ErrReply}. 1216 1217mtrt_mgc_verify_notify_request_fun() -> 1218 fun(Ev) -> 1219 mtrt_mgc_verify_notify_request(Ev) 1220 end. 1221 1222mtrt_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 1223 io:format("mtrt_mgc_verify_notify_request:fun -> ok" 1224 "~n AR: ~p~n", [AR]), 1225 case AR of 1226 #'ActionRequest'{contextId = Cid, 1227 commandRequests = [CR]} -> 1228 #'CommandRequest'{command = Cmd} = CR, 1229 {notifyReq, NR} = Cmd, 1230 #'NotifyRequest'{terminationID = [Tid], 1231 observedEventsDescriptor = OED, 1232 errorDescriptor = asn1_NOVALUE} = NR, 1233 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 1234 #'ObservedEvent'{eventName = "al/of"} = OE, 1235 Reply = {discard_ack, [mtrt_mgc_notify_reply_ar(Cid, Tid)]}, 1236 {ok, AR, Reply}; 1237 _ -> 1238 ED = mtrt_err_desc(AR), 1239 ErrReply = {discard_ack, ED}, 1240 {error, AR, ErrReply} 1241 end; 1242mtrt_mgc_verify_notify_request(Else) -> 1243 io:format("mtrt_mgc_verify_notify_request:fun -> unknown" 1244 "~n Else: ~p~n", [Else]), 1245 ED = mtrt_err_desc(Else), 1246 ErrReply = {discard_ack, ED}, 1247 {error, Else, ErrReply}. 1248 1249mtrt_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 1250 io:format("mtrt_mgc_verify_handle_disconnect -> ok" 1251 "~n CH: ~p" 1252 "~n R: ~p" 1253 "~n", [CH, R]), 1254 {ok, CH, ok}; 1255mtrt_mgc_verify_handle_disconnect(Else) -> 1256 io:format("mtrt_mgc_verify_handle_disconnect -> unknown" 1257 "~n Else: ~p~n", [Else]), 1258 {error, Else, ok}. 1259 1260 1261mtrt_mgc_service_change_reply_ar(Mid, Cid) -> 1262 SCRP = cre_serviceChangeResParm(Mid), 1263 SCRes = cre_serviceChangeResult(SCRP), 1264 Root = #megaco_term_id{id = ["root"]}, 1265 SCR = cre_serviceChangeReply([Root], SCRes), 1266 CR = cre_cmdReply(SCR), 1267 cre_actionReply(Cid, [CR]). 1268 1269%% mtrt_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 1270%% AR = mtrt_mgc_service_change_reply_ar(Mid, Cid), 1271%% TRes = cre_transResult([AR]), 1272%% TR = cre_transReply(TransId, TRes), 1273%% Trans = cre_transaction(TR), 1274%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1275%% cre_megacoMessage(Mess). 1276 1277mtrt_mgc_notify_reply_ar(Cid, TermId) -> 1278 NR = cre_notifyReply([TermId]), 1279 CR = cre_cmdReply(NR), 1280 cre_actionReply(Cid, [CR]). 1281 1282%% mtrt_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 1283%% AR = mtrt_mgc_notify_reply_ar(Cid, TermId), 1284%% TRes = cre_transResult([AR]), 1285%% TR = cre_transReply(TransId, TRes), 1286%% Trans = cre_transaction(TR), 1287%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1288%% cre_megacoMessage(Mess). 1289 1290 1291%% 1292%% MG generator stuff 1293%% 1294-ifdef(megaco_hipe_special). 1295-define(mtrt_mg_verify_handle_connect_fun(), 1296 {?MODULE, mtrt_mg_verify_handle_connect, []}). 1297-define(mtrt_mg_verify_service_change_reply_fun(), 1298 {?MODULE, mtrt_mg_verify_service_change_reply, []}). 1299-define(mtrt_mg_verify_notify_reply_fun(), 1300 {?MODULE, mtrt_mg_verify_notify_reply, []}). 1301-else. 1302-define(mtrt_mg_verify_handle_connect_fun(), 1303 fun mtrt_mg_verify_handle_connect/1). 1304-define(mtrt_mg_verify_service_change_reply_fun(), 1305 fun mtrt_mg_verify_service_change_reply/1). 1306-define(mtrt_mg_verify_notify_reply_fun(), 1307 fun mtrt_mg_verify_notify_reply/1). 1308-endif. 1309 1310mtrt_mg_event_sequence(text, tcp) -> 1311 Mid = {deviceName,"mg"}, 1312 RI = [ 1313 {port, 2944}, 1314 {encoding_module, megaco_pretty_text_encoder}, 1315 {encoding_config, []}, 1316 {transport_module, megaco_tcp} 1317 ], 1318 ServiceChangeReq = [mtrt_mg_service_change_request_ar(Mid, 1)], 1319 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 1320 NotifyReq = [mtrt_mg_notify_request_ar(1, Tid, 1)], 1321 ConnectVerify = ?mtrt_mg_verify_handle_connect_fun(), 1322 ServiceChangeReplyVerify = ?mtrt_mg_verify_service_change_reply_fun(), 1323 NotifyReplyVerify = ?mtrt_mg_verify_notify_reply_fun(), 1324 EvSeq = [ 1325 {debug, true}, 1326 megaco_start, 1327 {megaco_start_user, Mid, RI, []}, 1328 start_transport, 1329 {megaco_trace, disable}, 1330 {megaco_system_info, users}, 1331 {megaco_system_info, connections}, 1332 connect, 1333 {megaco_callback, handle_connect, ConnectVerify}, 1334 megaco_connect, 1335 {megaco_cast, ServiceChangeReq, []}, 1336 {megaco_callback, handle_connect, ConnectVerify}, 1337 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 1338 {sleep, 1000}, 1339 {megaco_system_info, users}, 1340 {megaco_system_info, connections}, 1341 {sleep, 1000}, 1342 {megaco_update_conn_info, trans_timer, 5000}, 1343 {megaco_update_conn_info, trans_req, true}, 1344 {megaco_conn_info, all}, 1345 {megaco_cast, NotifyReq, []}, 1346 {megaco_cast, NotifyReq, []}, 1347 {megaco_cast, NotifyReq, []}, 1348 {megaco_cast, NotifyReq, []}, 1349 {megaco_cast, NotifyReq, []}, 1350 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1351 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1352 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1353 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1354 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1355 {sleep, 1000}, 1356 megaco_stop_user, 1357 megaco_stop, 1358 {sleep, 1000} 1359 ], 1360 EvSeq. 1361 1362mtrt_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 1363 io:format("mtrt_mg_verify_handle_connect -> ok" 1364 "~n CH: ~p~n", [CH]), 1365 {ok, CH, ok}; 1366mtrt_mg_verify_handle_connect(Else) -> 1367 io:format("mtrt_mg_verify_handle_connect -> unknown" 1368 "~n Else: ~p~n", [Else]), 1369 {error, Else, ok}. 1370 1371mtrt_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 1372 {ok, [AR]}, _}) -> 1373 io:format("mtrt_mg_verify_service_change_reply -> ok" 1374 "~n AR: ~p~n", [AR]), 1375 case AR of 1376 #'ActionReply'{commandReply = [SCR]} -> 1377 case SCR of 1378 {serviceChangeReply, 1379 #'ServiceChangeReply'{terminationID = [Tid], 1380 serviceChangeResult = Res}} -> 1381 case Tid of 1382 #megaco_term_id{contains_wildcards = false, 1383 id = ["root"]} -> 1384 case Res of 1385 {serviceChangeResParms, 1386 #'ServiceChangeResParm'{ 1387 serviceChangeMgcId = _RemoteMid}} -> 1388 {ok, AR, ok}; 1389 {Tag, Val} -> 1390 Err = {invalid_service_change_result, 1391 Tag, Val}, 1392 {error, Err, ok} 1393 end; 1394 _ -> 1395 Err = {invalid_termination_id, Tid}, 1396 {error, Err, ok} 1397 end; 1398 {Tag, Val} -> 1399 Err = {invalid_command_reply, Tag, Val}, 1400 {error, Err, ok} 1401 end; 1402 _ -> 1403 Err = {invalid_action_reply, AR}, 1404 {error, Err, ok} 1405 end; 1406mtrt_mg_verify_service_change_reply(Else) -> 1407 io:format("mtrt_mg_verify_service_change_reply -> unknown" 1408 "~n Else: ~p~n", [Else]), 1409 {error, Else, ok}. 1410 1411mtrt_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 1412 {ok, [AR]}, _}) -> 1413 io:format("mtrt_mg_verify_service_change_reply -> ok" 1414 "~n AR: ~p~n", [AR]), 1415 {ok, AR, ok}; 1416mtrt_mg_verify_notify_reply(Else) -> 1417 io:format("mtrt_mg_verify_service_change_reply -> unknown" 1418 "~n Else: ~p~n", [Else]), 1419 {error, Else, ok}. 1420 1421mtrt_mg_service_change_request_ar(_Mid, Cid) -> 1422 Prof = cre_serviceChangeProf("resgw", 1), 1423 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 1424 Root = #megaco_term_id{id = ["root"]}, 1425 SCR = cre_serviceChangeReq([Root], SCP), 1426 CMD = cre_command(SCR), 1427 CR = cre_cmdReq(CMD), 1428 cre_actionReq(Cid, [CR]). 1429 1430%% mtrt_mg_service_change_request_msg(Mid, TransId, Cid) -> 1431%% AR = mtrt_mg_service_change_request_ar(Mid, Cid), 1432%% TR = cre_transReq(TransId, [AR]), 1433%% Trans = cre_transaction(TR), 1434%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1435%% cre_megacoMessage(Mess). 1436 1437mtrt_mg_notify_request_ar(Rid, Tid, Cid) -> 1438 TT = cre_timeNotation("19990729", "22000000"), 1439 Ev = cre_obsEvent("al/of", TT), 1440 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 1441 NR = cre_notifyReq([Tid], EvsDesc), 1442 CMD = cre_command(NR), 1443 CR = cre_cmdReq(CMD), 1444 cre_actionReq(Cid, [CR]). 1445 1446%% mtrt_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 1447%% AR = mtrt_mg_notify_request_ar(Rid, TermId, Cid), 1448%% TR = cre_transReq(TransId, [AR]), 1449%% Trans = cre_transaction(TR), 1450%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1451%% cre_megacoMessage(Mess). 1452 1453 1454%% 1455%% Common functions for the multi_trans_req_timeout test case 1456%% 1457 1458mtrt_err_desc(T) -> 1459 EC = ?megaco_internal_gateway_error, 1460 ET = lists:flatten(io_lib:format("~w",[T])), 1461 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 1462 1463 1464%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 1465 1466multi_trans_req_maxcount1(suite) -> 1467 []; 1468multi_trans_req_maxcount1(doc) -> 1469 "Test that a message is sent when req_maxcount is reached"; 1470multi_trans_req_maxcount1(Config) when is_list(Config) -> 1471 Pre = fun() -> 1472 MgcNode = make_node_name(mgc), 1473 MgNode = make_node_name(mg), 1474 d("start nodes: " 1475 "~n MGC Node: ~p" 1476 "~n MG Node: ~p", 1477 [MgcNode, MgNode]), 1478 Nodes = [MgcNode, MgNode], 1479 ok = ?START_NODES(Nodes), 1480 Nodes 1481 end, 1482 Case = fun do_multi_trans_req_maxcount1/1, 1483 Post = fun(Nodes) -> 1484 d("stop nodes"), 1485 ?STOP_NODES(lists:reverse(Nodes)) 1486 end, 1487 try_tc(multi_trans_req_maxcount1, Pre, Case, Post). 1488 1489do_multi_trans_req_maxcount1([MgcNode, MgNode]) -> 1490 d("[MGC] start the simulator "), 1491 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 1492 1493 d("[MGC] create the event sequence"), 1494 MgcEvSeq = mtrmc1_mgc_event_sequence(text, tcp), 1495 1496 i("wait some time before starting the MGC simulation"), 1497 sleep(1000), 1498 1499 d("[MGC] start the simulation"), 1500 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 1501 1502 %% i("wait some time before starting the MG simulator"), 1503 %% sleep(1000), 1504 1505 i("await MGC ready announcement"), 1506 receive 1507 announce_mgc -> 1508 i("received MGC ready announcement"), 1509 ok 1510 end, 1511 1512 d("[MG] start the simulator (generator)"), 1513 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 1514 1515 d("[MG] create the event sequence"), 1516 MgEvSeq = mtrmc1_mg_event_sequence(text, tcp), 1517 1518 i("wait some time before starting the MG simulation"), 1519 sleep(1000), 1520 1521 d("[MG] start the simulation"), 1522 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 1523 1524 d("await the generator reply(s)"), 1525 await_completion([MgcId, MgId]), 1526 1527 %% Tell Mgc to stop 1528 i("[MGC] stop generator"), 1529 megaco_test_megaco_generator:stop(Mgc), 1530 1531 %% Tell Mg to stop 1532 i("[MG] stop generator"), 1533 megaco_test_megaco_generator:stop(Mg), 1534 1535 i("done", []), 1536 ok. 1537 1538 1539%% 1540%% MGC generator stuff 1541%% 1542-ifdef(megaco_hipe_special). 1543-define(mtrmc1_mgc_verify_handle_connect_fun(), 1544 {?MODULE, mtrmc1_mgc_verify_handle_connect, []}). 1545-define(mtrmc1_mgc_verify_service_change_req_fun(Mid), 1546 {?MODULE, mtrmc1_mgc_verify_service_change_req, [Mid]}). 1547-define(mtrmc1_mgc_verify_notify_req_fun(), 1548 {?MODULE, mtrmc1_mgc_verify_notify_request, []}). 1549-define(mtrmc1_mgc_verify_handle_disconnect_fun(), 1550 {?MODULE, mtrmc1_mgc_verify_handle_disconnect, []}). 1551-else. 1552-define(mtrmc1_mgc_verify_handle_connect_fun(), 1553 fun mtrmc1_mgc_verify_handle_connect/1). 1554-define(mtrmc1_mgc_verify_service_change_req_fun(Mid), 1555 mtrmc1_mgc_verify_service_change_req_fun(Mid)). 1556-define(mtrmc1_mgc_verify_notify_req_fun(), 1557 mtrmc1_mgc_verify_notify_request_fun()). 1558-define(mtrmc1_mgc_verify_handle_disconnect_fun(), 1559 fun mtrmc1_mgc_verify_handle_disconnect/1). 1560-endif. 1561 1562mtrmc1_mgc_event_sequence(text, tcp) -> 1563 CTRL = self(), 1564 Mid = {deviceName,"ctrl"}, 1565 RI = [ 1566 {port, 2944}, 1567 {encoding_module, megaco_pretty_text_encoder}, 1568 {encoding_config, []}, 1569 {transport_module, megaco_tcp} 1570 ], 1571 ConnectVerify = ?mtrmc1_mgc_verify_handle_connect_fun(), 1572 ServiceChangeReqVerify = ?mtrmc1_mgc_verify_service_change_req_fun(Mid), 1573 NotifyReqVerify = ?mtrmc1_mgc_verify_notify_req_fun(), 1574 DiscoVerify = ?mtrmc1_mgc_verify_handle_disconnect_fun(), 1575 EvSeq = [ 1576 {debug, true}, 1577 {megaco_trace, disable}, 1578 megaco_start, 1579 {megaco_start_user, Mid, RI, []}, 1580 start_transport, 1581 listen, 1582 1583 %% ANNOUNCE READY 1584 {trigger, fun() -> CTRL ! announce_mgc end}, 1585 1586 {megaco_callback, handle_connect, ConnectVerify}, 1587 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 1588 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1589 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1590 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1591 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1592 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1593 {megaco_callback, handle_disconnect, DiscoVerify}, 1594 {sleep, 1000}, 1595 megaco_stop_user, 1596 megaco_stop 1597 ], 1598 EvSeq. 1599 1600 1601mtrmc1_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 1602 io:format("mtrmc1_mgc_verify_handle_connect -> ok" 1603 "~n CH: ~p~n", [CH]), 1604 {ok, CH, ok}; 1605mtrmc1_mgc_verify_handle_connect(Else) -> 1606 io:format("mtrmc1_mgc_verify_handle_connect -> unknown" 1607 "~n Else: ~p~n", [Else]), 1608 {error, Else, ok}. 1609 1610mtrmc1_mgc_verify_service_change_req_fun(Mid) -> 1611 fun(Ev) -> 1612 mtrmc1_mgc_verify_service_change_req(Ev, Mid) 1613 end. 1614 1615mtrmc1_mgc_verify_service_change_req( 1616 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 1617 io:format("mtrmc1_mgc_verify_service_change_req -> ok" 1618 "~n AR: ~p~n", [AR]), 1619 case AR of 1620 #'ActionRequest'{commandRequests = [CR]} -> 1621 case CR of 1622 #'CommandRequest'{command = Cmd} -> 1623 case Cmd of 1624 {serviceChangeReq, 1625 #'ServiceChangeRequest'{terminationID = [Tid], 1626 serviceChangeParms = Parms}} -> 1627 case Tid of 1628 #megaco_term_id{contains_wildcards = false, 1629 id = ["root"]} -> 1630 case Parms of 1631 #'ServiceChangeParm'{ 1632 serviceChangeMethod = restart, 1633 serviceChangeReason = [[$9,$0,$1|_]]} -> 1634 Reply = 1635 {discard_ack, 1636 [mtrmc1_mgc_service_change_reply_ar(Mid, 1)]}, 1637 {ok, AR, Reply}; 1638 _ -> 1639 Err = {invalid_SCP, Parms}, 1640 ED = mtrmc1_err_desc(Parms), 1641 ErrReply = {discard_ack, 1642 ED}, 1643 {error, Err, ErrReply} 1644 end; 1645 _ -> 1646 Err = {invalid_termination_id, Tid}, 1647 ED = mtrmc1_err_desc(Tid), 1648 ErrReply = {discard_ack, ED}, 1649 {error, Err, ErrReply} 1650 end; 1651 _ -> 1652 Err = {invalid_command, Cmd}, 1653 ED = mtrmc1_err_desc(Cmd), 1654 ErrReply = {discard_ack, ED}, 1655 {error, Err, ErrReply} 1656 end; 1657 _ -> 1658 Err = {invalid_command_request, CR}, 1659 ED = mtrmc1_err_desc(CR), 1660 ErrReply = {discard_ack, ED}, 1661 {error, Err, ErrReply} 1662 end; 1663 _ -> 1664 Err = {invalid_action_request, AR}, 1665 ED = mtrmc1_err_desc(AR), 1666 ErrReply = {discard_ack, ED}, 1667 {error, Err, ErrReply} 1668 end; 1669mtrmc1_mgc_verify_service_change_req(Else, _Mid) -> 1670 io:format("mtrmc1_mgc_verify_service_change_req -> unknown" 1671 "~n Else: ~p~n", [Else]), 1672 ED = mtrmc1_err_desc(Else), 1673 ErrReply = {discard_ack, ED}, 1674 {error, Else, ErrReply}. 1675 1676mtrmc1_mgc_verify_notify_request_fun() -> 1677 fun(Ev) -> 1678 mtrmc1_mgc_verify_notify_request(Ev) 1679 end. 1680 1681mtrmc1_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 1682 io:format("mtrmc1_mgc_verify_notify_request:fun -> ok" 1683 "~n AR: ~p~n", [AR]), 1684 case AR of 1685 #'ActionRequest'{contextId = Cid, 1686 commandRequests = [CR]} -> 1687 #'CommandRequest'{command = Cmd} = CR, 1688 {notifyReq, NR} = Cmd, 1689 #'NotifyRequest'{terminationID = [Tid], 1690 observedEventsDescriptor = OED, 1691 errorDescriptor = asn1_NOVALUE} = NR, 1692 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 1693 #'ObservedEvent'{eventName = "al/of"} = OE, 1694 Reply = {discard_ack, [mtrmc1_mgc_notify_reply_ar(Cid, Tid)]}, 1695 {ok, AR, Reply}; 1696 _ -> 1697 ED = mtrmc1_err_desc(AR), 1698 ErrReply = {discard_ack, ED}, 1699 {error, AR, ErrReply} 1700 end; 1701mtrmc1_mgc_verify_notify_request(Else) -> 1702 io:format("mtrmc1_mgc_verify_notify_request:fun -> unknown" 1703 "~n Else: ~p~n", [Else]), 1704 ED = mtrmc1_err_desc(Else), 1705 ErrReply = {discard_ack, ED}, 1706 {error, Else, ErrReply}. 1707 1708mtrmc1_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 1709 io:format("mtrmc1_mgc_verify_handle_disconnect -> ok" 1710 "~n CH: ~p" 1711 "~n R: ~p" 1712 "~n", [CH, R]), 1713 {ok, CH, ok}; 1714mtrmc1_mgc_verify_handle_disconnect(Else) -> 1715 io:format("mtrmc1_mgc_verify_handle_disconnect -> unknown" 1716 "~n Else: ~p~n", [Else]), 1717 {error, Else, ok}. 1718 1719 1720mtrmc1_mgc_service_change_reply_ar(Mid, Cid) -> 1721 SCRP = cre_serviceChangeResParm(Mid), 1722 SCRes = cre_serviceChangeResult(SCRP), 1723 Root = #megaco_term_id{id = ["root"]}, 1724 SCR = cre_serviceChangeReply([Root], SCRes), 1725 CR = cre_cmdReply(SCR), 1726 cre_actionReply(Cid, [CR]). 1727 1728%% mtrmc1_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 1729%% AR = mtrmc1_mgc_service_change_reply_ar(Mid, Cid), 1730%% TRes = cre_transResult([AR]), 1731%% TR = cre_transReply(TransId, TRes), 1732%% Trans = cre_transaction(TR), 1733%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1734%% cre_megacoMessage(Mess). 1735 1736mtrmc1_mgc_notify_reply_ar(Cid, TermId) -> 1737 NR = cre_notifyReply([TermId]), 1738 CR = cre_cmdReply(NR), 1739 cre_actionReply(Cid, [CR]). 1740 1741%% mtrmc1_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 1742%% AR = mtrmc1_mgc_notify_reply_ar(Cid, TermId), 1743%% TRes = cre_transResult([AR]), 1744%% TR = cre_transReply(TransId, TRes), 1745%% Trans = cre_transaction(TR), 1746%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1747%% cre_megacoMessage(Mess). 1748 1749 1750%% 1751%% MG generator stuff 1752%% 1753-ifdef(megaco_hipe_special). 1754-define(mtrmc1_mg_verify_handle_connect_fun(), 1755 {?MODULE, mtrmc1_mg_verify_handle_connect, []}). 1756-define(mtrmc1_mg_verify_service_change_reply_fun(), 1757 {?MODULE, mtrmc1_mg_verify_service_change_reply, []}). 1758-define(mtrmc1_mg_verify_notify_reply_fun(), 1759 {?MODULE, mtrmc1_mg_verify_notify_reply, []}). 1760-else. 1761-define(mtrmc1_mg_verify_handle_connect_fun(), 1762 fun mtrmc1_mg_verify_handle_connect/1). 1763-define(mtrmc1_mg_verify_service_change_reply_fun(), 1764 fun mtrmc1_mg_verify_service_change_reply/1). 1765-define(mtrmc1_mg_verify_notify_reply_fun(), 1766 fun mtrmc1_mg_verify_notify_reply/1). 1767-endif. 1768 1769mtrmc1_mg_event_sequence(text, tcp) -> 1770 Mid = {deviceName,"mg"}, 1771 RI = [ 1772 {port, 2944}, 1773 {encoding_module, megaco_pretty_text_encoder}, 1774 {encoding_config, []}, 1775 {transport_module, megaco_tcp} 1776 ], 1777 ServiceChangeReq = [mtrmc1_mg_service_change_request_ar(Mid, 1)], 1778 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 1779 NotifyReq = [mtrmc1_mg_notify_request_ar(1, Tid, 1)], 1780 ConnectVerify = ?mtrmc1_mg_verify_handle_connect_fun(), 1781 ServiceChangeReplyVerify = ?mtrmc1_mg_verify_service_change_reply_fun(), 1782 NotifyReplyVerify = ?mtrmc1_mg_verify_notify_reply_fun(), 1783 EvSeq = [ 1784 {debug, true}, 1785 megaco_start, 1786 {megaco_start_user, Mid, RI, []}, 1787 start_transport, 1788 {megaco_trace, disable}, 1789 {megaco_system_info, users}, 1790 {megaco_system_info, connections}, 1791 connect, 1792 {megaco_callback, handle_connect, ConnectVerify}, 1793 megaco_connect, 1794 {megaco_cast, ServiceChangeReq, []}, 1795 {megaco_callback, handle_connect, ConnectVerify}, 1796 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 1797 {sleep, 1000}, 1798 {megaco_system_info, users}, 1799 {megaco_system_info, connections}, 1800 {sleep, 1000}, 1801 {megaco_update_conn_info, trans_req_maxcount, 5}, 1802 {megaco_update_conn_info, trans_req_maxsize, 4096}, 1803 {megaco_update_conn_info, trans_timer, 120000}, 1804 {megaco_update_conn_info, trans_req, true}, 1805 {megaco_conn_info, all}, 1806 {megaco_cast, NotifyReq, []}, 1807 {megaco_cast, NotifyReq, []}, 1808 {megaco_cast, NotifyReq, []}, 1809 {megaco_cast, NotifyReq, []}, 1810 {megaco_cast, NotifyReq, []}, 1811 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1812 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1813 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1814 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1815 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1816 {sleep, 1000}, 1817 megaco_stop_user, 1818 megaco_stop, 1819 {sleep, 1000} 1820 ], 1821 EvSeq. 1822 1823mtrmc1_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 1824 io:format("mtrmc1_mg_verify_handle_connect -> ok" 1825 "~n CH: ~p~n", [CH]), 1826 {ok, CH, ok}; 1827mtrmc1_mg_verify_handle_connect(Else) -> 1828 io:format("mtrmc1_mg_verify_handle_connect -> unknown" 1829 "~n Else: ~p~n", [Else]), 1830 {error, Else, ok}. 1831 1832mtrmc1_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 1833 {ok, [AR]}, _}) -> 1834 io:format("mtrmc1_mg_verify_service_change_reply -> ok" 1835 "~n AR: ~p~n", [AR]), 1836 case AR of 1837 #'ActionReply'{commandReply = [SCR]} -> 1838 case SCR of 1839 {serviceChangeReply, 1840 #'ServiceChangeReply'{terminationID = [Tid], 1841 serviceChangeResult = Res}} -> 1842 case Tid of 1843 #megaco_term_id{contains_wildcards = false, 1844 id = ["root"]} -> 1845 case Res of 1846 {serviceChangeResParms, 1847 #'ServiceChangeResParm'{ 1848 serviceChangeMgcId = _RemoteMid}} -> 1849 {ok, AR, ok}; 1850 {Tag, Val} -> 1851 Err = {invalid_service_change_result, 1852 Tag, Val}, 1853 {error, Err, ok} 1854 end; 1855 _ -> 1856 Err = {invalid_termination_id, Tid}, 1857 {error, Err, ok} 1858 end; 1859 {Tag, Val} -> 1860 Err = {invalid_command_reply, Tag, Val}, 1861 {error, Err, ok} 1862 end; 1863 _ -> 1864 Err = {invalid_action_reply, AR}, 1865 {error, Err, ok} 1866 end; 1867mtrmc1_mg_verify_service_change_reply(Else) -> 1868 io:format("mtrmc1_mg_verify_service_change_reply -> unknown" 1869 "~n Else: ~p~n", [Else]), 1870 {error, Else, ok}. 1871 1872mtrmc1_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 1873 {ok, [AR]}, _}) -> 1874 io:format("mtrmc1_mg_verify_service_change_reply -> ok" 1875 "~n AR: ~p~n", [AR]), 1876 {ok, AR, ok}; 1877mtrmc1_mg_verify_notify_reply(Else) -> 1878 io:format("mtrmc1_mg_verify_service_change_reply -> unknown" 1879 "~n Else: ~p~n", [Else]), 1880 {error, Else, ok}. 1881 1882mtrmc1_mg_service_change_request_ar(_Mid, Cid) -> 1883 Prof = cre_serviceChangeProf("resgw", 1), 1884 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 1885 Root = #megaco_term_id{id = ["root"]}, 1886 SCR = cre_serviceChangeReq([Root], SCP), 1887 CMD = cre_command(SCR), 1888 CR = cre_cmdReq(CMD), 1889 cre_actionReq(Cid, [CR]). 1890 1891%% mtrmc1_mg_service_change_request_msg(Mid, TransId, Cid) -> 1892%% AR = mtrmc1_mg_service_change_request_ar(Mid, Cid), 1893%% TR = cre_transReq(TransId, [AR]), 1894%% Trans = cre_transaction(TR), 1895%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1896%% cre_megacoMessage(Mess). 1897 1898mtrmc1_mg_notify_request_ar(Rid, Tid, Cid) -> 1899 TT = cre_timeNotation("19990729", "22000000"), 1900 Ev = cre_obsEvent("al/of", TT), 1901 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 1902 NR = cre_notifyReq([Tid], EvsDesc), 1903 CMD = cre_command(NR), 1904 CR = cre_cmdReq(CMD), 1905 cre_actionReq(Cid, [CR]). 1906 1907%% mtrmc1_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 1908%% AR = mtrmc1_mg_notify_request_ar(Rid, TermId, Cid), 1909%% TR = cre_transReq(TransId, [AR]), 1910%% Trans = cre_transaction(TR), 1911%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1912%% cre_megacoMessage(Mess). 1913 1914 1915%% 1916%% Common functions for the multi_trans_req_timeout test case 1917%% 1918 1919mtrmc1_err_desc(T) -> 1920 EC = ?megaco_internal_gateway_error, 1921 ET = lists:flatten(io_lib:format("~w",[T])), 1922 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 1923 1924 1925%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 1926 1927multi_trans_req_maxcount2(suite) -> 1928 []; 1929multi_trans_req_maxcount2(doc) -> 1930 "Test that the message is sent when req_maxcount is reached " 1931 "with a request bigger then maxsize limit"; 1932multi_trans_req_maxcount2(Config) when is_list(Config) -> 1933 Pre = fun() -> 1934 MgcNode = make_node_name(mgc), 1935 MgNode = make_node_name(mg), 1936 d("start nodes: " 1937 "~n MGC Node: ~p" 1938 "~n MG Node: ~p", 1939 [MgcNode, MgNode]), 1940 Nodes = [MgcNode, MgNode], 1941 ok = ?START_NODES(Nodes), 1942 Nodes 1943 end, 1944 Case = fun do_multi_trans_req_maxcount2/1, 1945 Post = fun(Nodes) -> 1946 d("stop nodes"), 1947 ?STOP_NODES(lists:reverse(Nodes)) 1948 end, 1949 try_tc(multi_trans_req_maxcount2, Pre, Case, Post). 1950 1951do_multi_trans_req_maxcount2([MgcNode, MgNode]) -> 1952 1953 d("[MGC] start the simulator "), 1954 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 1955 1956 d("[MGC] create the event sequence"), 1957 MgcEvSeq = mtrmc2_mgc_event_sequence(text, tcp), 1958 1959 i("wait some time before starting the MGC simulation"), 1960 sleep(1000), 1961 1962 d("[MGC] start the simulation"), 1963 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 1964 1965 %% i("wait some time before starting the MG simulator"), 1966 %% sleep(1000), 1967 1968 i("await MGC ready announcement"), 1969 receive 1970 announce_mgc -> 1971 i("received MGC ready announcement"), 1972 ok 1973 end, 1974 1975 d("[MG] start the simulator (generator)"), 1976 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 1977 1978 d("[MG] create the event sequence"), 1979 MgEvSeq = mtrmc2_mg_event_sequence(text, tcp), 1980 1981 i("wait some time before starting the MG simulation"), 1982 sleep(1000), 1983 1984 d("[MG] start the simulation"), 1985 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 1986 1987 d("await the generator reply(s)"), 1988 await_completion([MgcId, MgId]), 1989 1990 %% Tell Mgc to stop 1991 i("[MGC] stop generator"), 1992 megaco_test_megaco_generator:stop(Mgc), 1993 1994 %% Tell Mg to stop 1995 i("[MG] stop generator"), 1996 megaco_test_megaco_generator:stop(Mg), 1997 1998 i("done", []), 1999 ok. 2000 2001 2002%% 2003%% MGC generator stuff 2004%% 2005-ifdef(megaco_hipe_special). 2006-define(mtrmc2_mgc_verify_handle_connect_fun(), 2007 {?MODULE, mtrmc2_mgc_verify_handle_connect, []}). 2008-define(mtrmc2_mgc_verify_service_change_req_fun(Mid), 2009 {?MODULE, mtrmc2_mgc_verify_service_change_req, [Mid]}). 2010-define(mtrmc2_mgc_verify_notify_req_fun(), 2011 {?MODULE, mtrmc2_mgc_verify_notify_request, []}). 2012-define(mtrmc2_mgc_verify_handle_disconnect_fun(), 2013 {?MODULE, mtrmc2_mgc_verify_handle_disconnect, []}). 2014-else. 2015-define(mtrmc2_mgc_verify_handle_connect_fun(), 2016 fun mtrmc2_mgc_verify_handle_connect/1). 2017-define(mtrmc2_mgc_verify_service_change_req_fun(Mid), 2018 mtrmc2_mgc_verify_service_change_req_fun(Mid)). 2019-define(mtrmc2_mgc_verify_notify_req_fun(), 2020 mtrmc2_mgc_verify_notify_request_fun()). 2021-define(mtrmc2_mgc_verify_handle_disconnect_fun(), 2022 fun mtrmc2_mgc_verify_handle_disconnect/1). 2023-endif. 2024 2025mtrmc2_mgc_event_sequence(text, tcp) -> 2026 CTRL = self(), 2027 Mid = {deviceName,"ctrl"}, 2028 RI = [ 2029 {port, 2944}, 2030 {encoding_module, megaco_pretty_text_encoder}, 2031 {encoding_config, []}, 2032 {transport_module, megaco_tcp} 2033 ], 2034 ConnectVerify = ?mtrmc2_mgc_verify_handle_connect_fun(), 2035 ServiceChangeReqVerify = ?mtrmc2_mgc_verify_service_change_req_fun(Mid), 2036 NotifyReqVerify = ?mtrmc2_mgc_verify_notify_req_fun(), 2037 DiscoVerify = ?mtrmc2_mgc_verify_handle_disconnect_fun(), 2038 EvSeq = [ 2039 {debug, true}, 2040 {megaco_trace, disable}, 2041 megaco_start, 2042 {megaco_start_user, Mid, RI, []}, 2043 start_transport, 2044 listen, 2045 2046 %% ANNOUNCE READY 2047 {trigger, fun() -> CTRL ! announce_mgc end}, 2048 2049 {megaco_callback, handle_connect, ConnectVerify}, 2050 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 2051 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2052 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2053 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2054 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2055 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2056 {megaco_callback, handle_disconnect, DiscoVerify}, 2057 {sleep, 1000}, 2058 megaco_stop_user, 2059 megaco_stop 2060 ], 2061 EvSeq. 2062 2063 2064mtrmc2_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 2065 io:format("mtrmc2_mgc_verify_handle_connect -> ok" 2066 "~n CH: ~p~n", [CH]), 2067 {ok, CH, ok}; 2068mtrmc2_mgc_verify_handle_connect(Else) -> 2069 io:format("mtrmc2_mgc_verify_handle_connect -> unknown" 2070 "~n Else: ~p~n", [Else]), 2071 {error, Else, ok}. 2072 2073mtrmc2_mgc_verify_service_change_req_fun(Mid) -> 2074 fun(Ev) -> 2075 mtrmc2_mgc_verify_service_change_req(Ev, Mid) 2076 end. 2077 2078mtrmc2_mgc_verify_service_change_req( 2079 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 2080 io:format("mtrmc2_mgc_verify_service_change_req -> ok" 2081 "~n AR: ~p~n", [AR]), 2082 case AR of 2083 #'ActionRequest'{commandRequests = [CR]} -> 2084 case CR of 2085 #'CommandRequest'{command = Cmd} -> 2086 case Cmd of 2087 {serviceChangeReq, 2088 #'ServiceChangeRequest'{terminationID = [Tid], 2089 serviceChangeParms = Parms}} -> 2090 case Tid of 2091 #megaco_term_id{contains_wildcards = false, 2092 id = ["root"]} -> 2093 case Parms of 2094 #'ServiceChangeParm'{ 2095 serviceChangeMethod = restart, 2096 serviceChangeReason = [[$9,$0,$1|_]]} -> 2097 Reply = 2098 {discard_ack, 2099 [mtrmc2_mgc_service_change_reply_ar(Mid, 1)]}, 2100 {ok, AR, Reply}; 2101 _ -> 2102 Err = {invalid_SCP, Parms}, 2103 ED = mtrmc2_err_desc(Parms), 2104 ErrReply = {discard_ack, 2105 ED}, 2106 {error, Err, ErrReply} 2107 end; 2108 _ -> 2109 Err = {invalid_termination_id, Tid}, 2110 ED = mtrmc2_err_desc(Tid), 2111 ErrReply = {discard_ack, ED}, 2112 {error, Err, ErrReply} 2113 end; 2114 _ -> 2115 Err = {invalid_command, Cmd}, 2116 ED = mtrmc2_err_desc(Cmd), 2117 ErrReply = {discard_ack, ED}, 2118 {error, Err, ErrReply} 2119 end; 2120 _ -> 2121 Err = {invalid_command_request, CR}, 2122 ED = mtrmc2_err_desc(CR), 2123 ErrReply = {discard_ack, ED}, 2124 {error, Err, ErrReply} 2125 end; 2126 _ -> 2127 Err = {invalid_action_request, AR}, 2128 ED = mtrmc2_err_desc(AR), 2129 ErrReply = {discard_ack, ED}, 2130 {error, Err, ErrReply} 2131 end; 2132mtrmc2_mgc_verify_service_change_req(Else, _Mid) -> 2133 io:format("mtrmc2_mgc_verify_service_change_req -> unknown" 2134 "~n Else: ~p~n", [Else]), 2135 ED = mtrmc2_err_desc(Else), 2136 ErrReply = {discard_ack, ED}, 2137 {error, Else, ErrReply}. 2138 2139mtrmc2_mgc_verify_notify_request_fun() -> 2140 fun(Ev) -> 2141 mtrmc2_mgc_verify_notify_request(Ev) 2142 end. 2143 2144mtrmc2_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 2145 io:format("mtrmc2_mgc_verify_notify_request:fun -> ok" 2146 "~n AR: ~p~n", [AR]), 2147 case AR of 2148 #'ActionRequest'{contextId = Cid, 2149 commandRequests = [CR]} -> 2150 io:format("mtrmc2_mgc_verify_notify_request:fun -> " 2151 "single command",[]), 2152 #'CommandRequest'{command = Cmd} = CR, 2153 {notifyReq, NR} = Cmd, 2154 #'NotifyRequest'{terminationID = [Tid], 2155 observedEventsDescriptor = OED, 2156 errorDescriptor = asn1_NOVALUE} = NR, 2157 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 2158 #'ObservedEvent'{eventName = "al/of"} = OE, 2159 Reply = {discard_ack, 2160 [mtrmc2_mgc_notify_reply_ar1(Cid, Tid)]}, 2161 {ok, AR, Reply}; 2162 #'ActionRequest'{contextId = Cid, 2163 commandRequests = CRs} -> 2164 io:format("mtrmc2_mgc_verify_notify_request:fun -> " 2165 "multi command (~w)",[length(CRs)]), 2166 Tids = [Tid || 2167 #'CommandRequest'{command = 2168 {notifyReq, 2169 #'NotifyRequest'{ 2170 terminationID = [Tid]}}} 2171 <- CRs], 2172 Reply = 2173 {discard_ack, 2174 [mtrmc2_mgc_notify_reply_ar2(Cid, Tids)]}, 2175 {ok, AR, Reply}; 2176 _ -> 2177 ED = mtrmc2_err_desc(AR), 2178 ErrReply = {discard_ack, ED}, 2179 {error, AR, ErrReply} 2180 end; 2181mtrmc2_mgc_verify_notify_request(Else) -> 2182 io:format("mtrmc2_mgc_verify_notify_request:fun -> unknown" 2183 "~n Else: ~p~n", [Else]), 2184 ED = mtrmc2_err_desc(Else), 2185 ErrReply = {discard_ack, ED}, 2186 {error, Else, ErrReply}. 2187 2188mtrmc2_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 2189 io:format("mtrmc2_mgc_verify_handle_disconnect -> ok" 2190 "~n CH: ~p" 2191 "~n R: ~p" 2192 "~n", [CH, R]), 2193 {ok, CH, ok}; 2194mtrmc2_mgc_verify_handle_disconnect(Else) -> 2195 io:format("mtrmc2_mgc_verify_handle_disconnect -> unknown" 2196 "~n Else: ~p~n", [Else]), 2197 {error, Else, ok}. 2198 2199 2200mtrmc2_mgc_service_change_reply_ar(Mid, Cid) -> 2201 SCRP = cre_serviceChangeResParm(Mid), 2202 SCRes = cre_serviceChangeResult(SCRP), 2203 Root = #megaco_term_id{id = ["root"]}, 2204 SCR = cre_serviceChangeReply([Root], SCRes), 2205 CR = cre_cmdReply(SCR), 2206 cre_actionReply(Cid, [CR]). 2207 2208%% mtrmc2_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 2209%% AR = mtrmc2_mgc_service_change_reply_ar(Mid, Cid), 2210%% TRes = cre_transResult([AR]), 2211%% TR = cre_transReply(TransId, TRes), 2212%% Trans = cre_transaction(TR), 2213%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2214%% cre_megacoMessage(Mess). 2215 2216mtrmc2_mgc_notify_reply_ar1(Cid, Tid) -> 2217 NR = cre_notifyReply([Tid]), 2218 CR = cre_cmdReply(NR), 2219 cre_actionReply(Cid, [CR]). 2220 2221mtrmc2_mgc_notify_reply_ar2(Cid, Tids) -> 2222 CRs = [cre_cmdReply(cre_notifyReply([Tid])) || Tid <- Tids], 2223 cre_actionReply(Cid, CRs). 2224 2225%% mtrmc2_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 2226%% AR = mtrmc2_mgc_notify_reply_ar1(Cid, TermId), 2227%% TRes = cre_transResult([AR]), 2228%% TR = cre_transReply(TransId, TRes), 2229%% Trans = cre_transaction(TR), 2230%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2231%% cre_megacoMessage(Mess). 2232 2233 2234%% 2235%% MG generator stuff 2236%% 2237-ifdef(megaco_hipe_special). 2238-define(mtrmc2_mg_verify_handle_connect_fun(), 2239 {?MODULE, mtrmc2_mg_verify_handle_connect, []}). 2240-define(mtrmc2_mg_verify_service_change_reply_fun(), 2241 {?MODULE, mtrmc2_mg_verify_service_change_reply, []}). 2242-define(mtrmc2_mg_verify_notify_reply_fun(), 2243 {?MODULE, mtrmc2_mg_verify_notify_reply, []}). 2244-else. 2245-define(mtrmc2_mg_verify_handle_connect_fun(), 2246 fun mtrmc2_mg_verify_handle_connect/1). 2247-define(mtrmc2_mg_verify_service_change_reply_fun(), 2248 fun mtrmc2_mg_verify_service_change_reply/1). 2249-define(mtrmc2_mg_verify_notify_reply_fun(), 2250 fun mtrmc2_mg_verify_notify_reply/1). 2251-endif. 2252 2253mtrmc2_mg_event_sequence(text, tcp) -> 2254 Mid = {deviceName,"mg"}, 2255 RI = [ 2256 {port, 2944}, 2257 {encoding_module, megaco_pretty_text_encoder}, 2258 {encoding_config, []}, 2259 {transport_module, megaco_tcp} 2260 ], 2261 ServiceChangeReq = [mtrmc2_mg_service_change_request_ar(Mid, 1)], 2262 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 2263 NR1 = fun(N) -> 2264 [mtrmc2_mg_notify_request_ar1(N, Tid, N)] 2265 end, 2266 NR2 = fun(N) -> 2267 [mtrmc2_mg_notify_request_ar2(N, Tid, N)] 2268 end, 2269 ConnectVerify = ?mtrmc2_mg_verify_handle_connect_fun(), 2270 ServiceChangeReplyVerify = ?mtrmc2_mg_verify_service_change_reply_fun(), 2271 NotifyReplyVerify = ?mtrmc2_mg_verify_notify_reply_fun(), 2272 EvSeq = [ 2273 {debug, true}, 2274 megaco_start, 2275 {megaco_start_user, Mid, RI, []}, 2276 start_transport, 2277 {megaco_trace, disable}, 2278 {megaco_system_info, users}, 2279 {megaco_system_info, connections}, 2280 connect, 2281 {megaco_callback, handle_connect, ConnectVerify}, 2282 megaco_connect, 2283 {megaco_cast, ServiceChangeReq, []}, 2284 {megaco_callback, handle_connect, ConnectVerify}, 2285 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 2286 {sleep, 1000}, 2287 {megaco_system_info, users}, 2288 {megaco_system_info, connections}, 2289 {sleep, 1000}, 2290 {megaco_update_conn_info, trans_req_maxcount, 5}, 2291 {megaco_update_conn_info, trans_req_maxsize, 1024}, 2292 {megaco_update_conn_info, trans_timer, 120000}, 2293 {megaco_update_conn_info, trans_req, true}, 2294 {megaco_conn_info, all}, 2295 {megaco_cast, NR1(1), []}, 2296 {megaco_cast, [NR1(2), NR1(3)], []}, 2297 {megaco_cast, NR1(4), []}, 2298 {megaco_cast, NR2(5), []}, 2299 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2300 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2301 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2302 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2303 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2304 {sleep, 1000}, 2305 megaco_stop_user, 2306 megaco_stop, 2307 {sleep, 1000} 2308 ], 2309 EvSeq. 2310 2311mtrmc2_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 2312 io:format("mtrmc2_mg_verify_handle_connect -> ok" 2313 "~n CH: ~p~n", [CH]), 2314 {ok, CH, ok}; 2315mtrmc2_mg_verify_handle_connect(Else) -> 2316 io:format("mtrmc2_mg_verify_handle_connect -> unknown" 2317 "~n Else: ~p~n", [Else]), 2318 {error, Else, ok}. 2319 2320mtrmc2_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 2321 {ok, [AR]}, _}) -> 2322 io:format("mtrmc2_mg_verify_service_change_reply -> ok" 2323 "~n AR: ~p~n", [AR]), 2324 case AR of 2325 #'ActionReply'{commandReply = [SCR]} -> 2326 case SCR of 2327 {serviceChangeReply, 2328 #'ServiceChangeReply'{terminationID = [Tid], 2329 serviceChangeResult = Res}} -> 2330 case Tid of 2331 #megaco_term_id{contains_wildcards = false, 2332 id = ["root"]} -> 2333 case Res of 2334 {serviceChangeResParms, 2335 #'ServiceChangeResParm'{ 2336 serviceChangeMgcId = _RemoteMid}} -> 2337 {ok, AR, ok}; 2338 {Tag, Val} -> 2339 Err = {invalid_service_change_result, 2340 Tag, Val}, 2341 {error, Err, ok} 2342 end; 2343 _ -> 2344 Err = {invalid_termination_id, Tid}, 2345 {error, Err, ok} 2346 end; 2347 {Tag, Val} -> 2348 Err = {invalid_command_reply, Tag, Val}, 2349 {error, Err, ok} 2350 end; 2351 _ -> 2352 Err = {invalid_action_reply, AR}, 2353 {error, Err, ok} 2354 end; 2355mtrmc2_mg_verify_service_change_reply(Else) -> 2356 io:format("mtrmc2_mg_verify_service_change_reply -> unknown" 2357 "~n Else: ~p~n", [Else]), 2358 {error, Else, ok}. 2359 2360mtrmc2_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 2361 {ok, [AR]}, _}) -> 2362 io:format("mtrmc2_mg_verify_notify_reply -> ok" 2363 "~n AR: ~p~n", [AR]), 2364 case AR of 2365 #'ActionReply'{commandReply = [{notifyReply, _NR}]} -> 2366 io:format("mtrmc2_mg_verify_notify_reply -> " 2367 "single notify reply", []), 2368 {ok, AR, ok}; 2369 #'ActionReply'{commandReply = [{notifyReply, _NR}|_] = CR} -> 2370 io:format("mtrmc2_mg_verify_notify_reply -> " 2371 "multi notify reply: (~w)", [length(CR)]), 2372 {ok, AR, ok}; 2373 _ -> 2374 {error, {invalid_action_reply, AR}, ok} 2375 end; 2376mtrmc2_mg_verify_notify_reply(Else) -> 2377 io:format("mtrmc2_mg_verify_notify_reply -> unknown" 2378 "~n Else: ~p~n", [Else]), 2379 {error, Else, ok}. 2380 2381mtrmc2_mg_service_change_request_ar(_Mid, Cid) -> 2382 Prof = cre_serviceChangeProf("resgw", 1), 2383 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 2384 Root = #megaco_term_id{id = ["root"]}, 2385 SCR = cre_serviceChangeReq([Root], SCP), 2386 CMD = cre_command(SCR), 2387 CR = cre_cmdReq(CMD), 2388 cre_actionReq(Cid, [CR]). 2389 2390%% mtrmc2_mg_service_change_request_msg(Mid, TransId, Cid) -> 2391%% AR = mtrmc2_mg_service_change_request_ar(Mid, Cid), 2392%% TR = cre_transReq(TransId, [AR]), 2393%% Trans = cre_transaction(TR), 2394%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2395%% cre_megacoMessage(Mess). 2396 2397mtrmc2_mg_notify_request_ar1(Rid, Tid, Cid) -> 2398 TT = cre_timeNotation("19990729", "22000000"), 2399 Ev = cre_obsEvent("al/of", TT), 2400 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 2401 NR = cre_notifyReq([Tid], EvsDesc), 2402 CMD = cre_command(NR), 2403 CR = cre_cmdReq(CMD), 2404 cre_actionReq(Cid, [CR]). 2405 2406mtrmc2_mg_notify_request_ar2(Rid, Tid, Cid) -> 2407 F = fun(N) -> 2408 T = 22000000 + N, 2409 TS = integer_to_list(T), 2410 TT = cre_timeNotation("19990729", TS), 2411 Ev = cre_obsEvent("al/of", TT), 2412 EvsDesc = cre_obsEvsDesc(Rid+N, [Ev]), 2413 NR = cre_notifyReq([Tid], EvsDesc), 2414 CMD = cre_command(NR), 2415 cre_cmdReq(CMD) 2416 end, 2417 Ns = [0,1,2,3,4,5,6,7,8,9], 2418 CRs = [F(N) || N <- Ns], 2419 cre_actionReq(Cid, CRs). 2420 2421%% mtrmc2_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 2422%% AR = mtrmc2_mg_notify_request_ar1(Rid, TermId, Cid), 2423%% TR = cre_transReq(TransId, [AR]), 2424%% Trans = cre_transaction(TR), 2425%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2426%% cre_megacoMessage(Mess). 2427 2428 2429%% 2430%% Common functions for the multi_trans_req_timeout test case 2431%% 2432 2433mtrmc2_err_desc(T) -> 2434 EC = ?megaco_internal_gateway_error, 2435 ET = lists:flatten(io_lib:format("~w",[T])), 2436 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 2437 2438 2439 2440 2441%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 2442 2443multi_trans_req_maxsize1(suite) -> 2444 []; 2445multi_trans_req_maxsize1(doc) -> 2446 "Test that the message is sent when req_maxsize is reached"; 2447multi_trans_req_maxsize1(Config) when is_list(Config) -> 2448 Pre = fun() -> 2449 put(verbosity, ?TEST_VERBOSITY), 2450 put(sname, "TEST"), 2451 put(tc, multi_trans_req_maxsize1), 2452 i("starting"), 2453 2454 MgcNode = make_node_name(mgc), 2455 MgNode = make_node_name(mg), 2456 d("start nodes: " 2457 "~n MGC Node: ~p" 2458 "~n MG Node: ~p", 2459 [MgcNode, MgNode]), 2460 Nodes = [MgcNode, MgNode], 2461 ok = ?START_NODES(Nodes), 2462 Nodes 2463 end, 2464 Case = fun do_multi_trans_req_maxsize1/1, 2465 Post = fun(Nodes) -> 2466 d("stop nodes"), 2467 ?STOP_NODES(lists:reverse(Nodes)) 2468 end, 2469 try_tc(multi_trans_req_maxsize1, Pre, Case, Post). 2470 2471do_multi_trans_req_maxsize1([MgcNode, MgNode]) -> 2472 2473 d("[MGC] start the simulator "), 2474 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 2475 2476 d("[MGC] create the event sequence"), 2477 MgcEvSeq = mtrms1_mgc_event_sequence(text, tcp), 2478 2479 i("wait some time before starting the MGC simulation"), 2480 sleep(1000), 2481 2482 d("[MGC] start the simulation"), 2483 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 2484 2485 %% i("wait some time before starting the MG simulator"), 2486 %% sleep(1000), 2487 2488 i("await MGC ready announcement"), 2489 receive 2490 announce_mgc -> 2491 i("received MGC ready announcement"), 2492 ok 2493 end, 2494 2495 d("[MG] start the simulator (generator)"), 2496 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 2497 2498 d("[MG] create the event sequence"), 2499 MgEvSeq = mtrms1_mg_event_sequence(text, tcp), 2500 2501 i("wait some time before starting the MG simulation"), 2502 sleep(1000), 2503 2504 d("[MG] start the simulation"), 2505 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 2506 2507 d("await the generator reply(s)"), 2508 await_completion([MgcId, MgId]), 2509 2510 %% Tell Mgc to stop 2511 i("[MGC] stop generator"), 2512 megaco_test_megaco_generator:stop(Mgc), 2513 2514 %% Tell Mg to stop 2515 i("[MG] stop generator"), 2516 megaco_test_megaco_generator:stop(Mg), 2517 2518 i("done", []), 2519 ok. 2520 2521 2522%% 2523%% MGC generator stuff 2524%% 2525-ifdef(megaco_hipe_special). 2526-define(mtrms1_mgc_verify_handle_connect_fun(), 2527 {?MODULE, mtrms1_mgc_verify_handle_connect, []}). 2528-define(mtrms1_mgc_verify_service_change_req_fun(Mid), 2529 {?MODULE, mtrms1_mgc_verify_service_change_req, [Mid]}). 2530-define(mtrms1_mgc_verify_notify_req_fun(), 2531 {?MODULE, mtrms1_mgc_verify_notify_request, []}). 2532-define(mtrms1_mgc_verify_handle_disconnect_fun(), 2533 {?MODULE, mtrms1_mgc_verify_handle_disconnect, []}). 2534-else. 2535-define(mtrms1_mgc_verify_handle_connect_fun(), 2536 fun mtrms1_mgc_verify_handle_connect/1). 2537-define(mtrms1_mgc_verify_service_change_req_fun(Mid), 2538 mtrms1_mgc_verify_service_change_req_fun(Mid)). 2539-define(mtrms1_mgc_verify_notify_req_fun(), 2540 mtrms1_mgc_verify_notify_request_fun()). 2541-define(mtrms1_mgc_verify_handle_disconnect_fun(), 2542 fun mtrms1_mgc_verify_handle_disconnect/1). 2543-endif. 2544 2545mtrms1_mgc_event_sequence(text, tcp) -> 2546 CTRL = self(), 2547 Mid = {deviceName,"ctrl"}, 2548 RI = [ 2549 {port, 2944}, 2550 {encoding_module, megaco_pretty_text_encoder}, 2551 {encoding_config, []}, 2552 {transport_module, megaco_tcp} 2553 ], 2554 ConnectVerify = ?mtrms1_mgc_verify_handle_connect_fun(), 2555 ServiceChangeReqVerify = ?mtrms1_mgc_verify_service_change_req_fun(Mid), 2556 NotifyReqVerify = ?mtrms1_mgc_verify_notify_req_fun(), 2557 DiscoVerify = ?mtrms1_mgc_verify_handle_disconnect_fun(), 2558 EvSeq = [ 2559 {debug, true}, 2560 {megaco_trace, disable}, 2561 megaco_start, 2562 {megaco_start_user, Mid, RI, []}, 2563 start_transport, 2564 listen, 2565 2566 %% ANNOUNCE READY 2567 {trigger, fun() -> CTRL ! announce_mgc end}, 2568 2569 {megaco_callback, handle_connect, ConnectVerify}, 2570 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 2571 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2572 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2573 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2574 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2575 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2576 {megaco_callback, handle_disconnect, DiscoVerify}, 2577 {sleep, 1000}, 2578 megaco_stop_user, 2579 megaco_stop 2580 ], 2581 EvSeq. 2582 2583 2584mtrms1_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 2585 io:format("mtrms1_mgc_verify_handle_connect -> ok" 2586 "~n CH: ~p~n", [CH]), 2587 {ok, CH, ok}; 2588mtrms1_mgc_verify_handle_connect(Else) -> 2589 io:format("mtrms1_mgc_verify_handle_connect -> unknown" 2590 "~n Else: ~p~n", [Else]), 2591 {error, Else, ok}. 2592 2593mtrms1_mgc_verify_service_change_req_fun(Mid) -> 2594 fun(Ev) -> 2595 mtrms1_mgc_verify_service_change_req(Ev, Mid) 2596 end. 2597 2598mtrms1_mgc_verify_service_change_req( 2599 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 2600 io:format("mtrms1_mgc_verify_service_change_req -> ok" 2601 "~n AR: ~p~n", [AR]), 2602 case AR of 2603 #'ActionRequest'{commandRequests = [CR]} -> 2604 case CR of 2605 #'CommandRequest'{command = Cmd} -> 2606 case Cmd of 2607 {serviceChangeReq, 2608 #'ServiceChangeRequest'{terminationID = [Tid], 2609 serviceChangeParms = Parms}} -> 2610 case Tid of 2611 #megaco_term_id{contains_wildcards = false, 2612 id = ["root"]} -> 2613 case Parms of 2614 #'ServiceChangeParm'{ 2615 serviceChangeMethod = restart, 2616 serviceChangeReason = [[$9,$0,$1|_]]} -> 2617 Reply = 2618 {discard_ack, 2619 [mtrms1_mgc_service_change_reply_ar(Mid, 1)]}, 2620 {ok, AR, Reply}; 2621 _ -> 2622 Err = {invalid_SCP, Parms}, 2623 ED = mtrms1_err_desc(Parms), 2624 ErrReply = {discard_ack, 2625 ED}, 2626 {error, Err, ErrReply} 2627 end; 2628 _ -> 2629 Err = {invalid_termination_id, Tid}, 2630 ED = mtrms1_err_desc(Tid), 2631 ErrReply = {discard_ack, ED}, 2632 {error, Err, ErrReply} 2633 end; 2634 _ -> 2635 Err = {invalid_command, Cmd}, 2636 ED = mtrms1_err_desc(Cmd), 2637 ErrReply = {discard_ack, ED}, 2638 {error, Err, ErrReply} 2639 end; 2640 _ -> 2641 Err = {invalid_command_request, CR}, 2642 ED = mtrms1_err_desc(CR), 2643 ErrReply = {discard_ack, ED}, 2644 {error, Err, ErrReply} 2645 end; 2646 _ -> 2647 Err = {invalid_action_request, AR}, 2648 ED = mtrms1_err_desc(AR), 2649 ErrReply = {discard_ack, ED}, 2650 {error, Err, ErrReply} 2651 end; 2652mtrms1_mgc_verify_service_change_req(Else, _Mid) -> 2653 io:format("mtrms1_mgc_verify_service_change_req -> unknown" 2654 "~n Else: ~p~n", [Else]), 2655 ED = mtrms1_err_desc(Else), 2656 ErrReply = {discard_ack, ED}, 2657 {error, Else, ErrReply}. 2658 2659mtrms1_mgc_verify_notify_request_fun() -> 2660 fun(Ev) -> 2661 mtrms1_mgc_verify_notify_request(Ev) 2662 end. 2663 2664mtrms1_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 2665 io:format("mtrms1_mgc_verify_notify_request:fun1 -> ok" 2666 "~n AR: ~p~n", [AR]), 2667 case AR of 2668 #'ActionRequest'{contextId = Cid, 2669 commandRequests = [CR]} -> 2670 #'CommandRequest'{command = Cmd} = CR, 2671 {notifyReq, NR} = Cmd, 2672 #'NotifyRequest'{terminationID = [Tid], 2673 observedEventsDescriptor = OED, 2674 errorDescriptor = asn1_NOVALUE} = NR, 2675 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 2676 #'ObservedEvent'{eventName = "al/of"} = OE, 2677 Reply = {discard_ack, 2678 [mtrms1_mgc_notify_reply_ar1(Cid, Tid)]}, 2679 {ok, AR, Reply}; 2680 _ -> 2681 ED = mtrms1_err_desc(AR), 2682 ErrReply = {discard_ack, ED}, 2683 {error, AR, ErrReply} 2684 end; 2685mtrms1_mgc_verify_notify_request(Else) -> 2686 io:format("mtrms1_mgc_verify_notify_request:fun1 -> unknown" 2687 "~n Else: ~p~n", [Else]), 2688 ED = mtrms1_err_desc(Else), 2689 ErrReply = {discard_ack, ED}, 2690 {error, Else, ErrReply}. 2691 2692mtrms1_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 2693 io:format("mtrms1_mgc_verify_handle_disconnect -> ok" 2694 "~n CH: ~p" 2695 "~n R: ~p" 2696 "~n", [CH, R]), 2697 {ok, CH, ok}; 2698mtrms1_mgc_verify_handle_disconnect(Else) -> 2699 io:format("mtrms1_mgc_verify_handle_disconnect -> unknown" 2700 "~n Else: ~p~n", [Else]), 2701 {error, Else, ok}. 2702 2703 2704mtrms1_mgc_service_change_reply_ar(Mid, Cid) -> 2705 SCRP = cre_serviceChangeResParm(Mid), 2706 SCRes = cre_serviceChangeResult(SCRP), 2707 Root = #megaco_term_id{id = ["root"]}, 2708 SCR = cre_serviceChangeReply([Root], SCRes), 2709 CR = cre_cmdReply(SCR), 2710 cre_actionReply(Cid, [CR]). 2711 2712%% mtrms1_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 2713%% AR = mtrms1_mgc_service_change_reply_ar(Mid, Cid), 2714%% TRes = cre_transResult([AR]), 2715%% TR = cre_transReply(TransId, TRes), 2716%% Trans = cre_transaction(TR), 2717%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2718%% cre_megacoMessage(Mess). 2719 2720mtrms1_mgc_notify_reply_ar1(Cid, Tid) -> 2721 NR = cre_notifyReply([Tid]), 2722 CR = cre_cmdReply(NR), 2723 cre_actionReply(Cid, [CR]). 2724 2725%% mtrms1_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 2726%% AR = mtrms1_mgc_notify_reply_ar1(Cid, TermId), 2727%% TRes = cre_transResult([AR]), 2728%% TR = cre_transReply(TransId, TRes), 2729%% Trans = cre_transaction(TR), 2730%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2731%% cre_megacoMessage(Mess). 2732 2733 2734%% 2735%% MG generator stuff 2736%% 2737-ifdef(megaco_hipe_special). 2738-define(mtrms1_mg_verify_handle_connect_fun(), 2739 {?MODULE, mtrms1_mg_verify_handle_connect, []}). 2740-define(mtrms1_mg_verify_service_change_reply_fun(Mid), 2741 {?MODULE, mtrms1_mg_verify_service_change_reply, [Mid]}). 2742-define(mtrms1_mg_verify_notify_reply_fun(), 2743 {?MODULE, mtrms1_mg_verify_notify_reply, []}). 2744-else. 2745-define(mtrms1_mg_verify_handle_connect_fun(), 2746 fun mtrms1_mg_verify_handle_connect/1). 2747-define(mtrms1_mg_verify_service_change_reply_fun(), 2748 fun mtrms1_mg_verify_service_change_reply/1). 2749-define(mtrms1_mg_verify_notify_reply_fun(), 2750 fun mtrms1_mg_verify_notify_reply/1). 2751-endif. 2752 2753mtrms1_mg_event_sequence(text, tcp) -> 2754 Mid = {deviceName,"mg"}, 2755 RI = [ 2756 {port, 2944}, 2757 {encoding_module, megaco_pretty_text_encoder}, 2758 {encoding_config, []}, 2759 {transport_module, megaco_tcp} 2760 ], 2761 ServiceChangeReq = [mtrms1_mg_service_change_request_ar(Mid, 1)], 2762 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 2763 NR = fun(N) -> 2764 [mtrms1_mg_notify_request_ar1(N, Tid, N)] 2765 end, 2766 ConnectVerify = ?mtrms1_mg_verify_handle_connect_fun(), 2767 ServiceChangeReplyVerify = ?mtrms1_mg_verify_service_change_reply_fun(), 2768 NotifyReplyVerify = ?mtrms1_mg_verify_notify_reply_fun(), 2769 EvSeq = [ 2770 {debug, true}, 2771 megaco_start, 2772 {megaco_start_user, Mid, RI, []}, 2773 start_transport, 2774 {megaco_trace, disable}, 2775 {megaco_system_info, users}, 2776 {megaco_system_info, connections}, 2777 connect, 2778 {megaco_callback, handle_connect, ConnectVerify}, 2779 megaco_connect, 2780 {megaco_cast, ServiceChangeReq, []}, 2781 {megaco_callback, handle_connect, ConnectVerify}, 2782 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 2783 {sleep, 1000}, 2784 {megaco_system_info, users}, 2785 {megaco_system_info, connections}, 2786 {sleep, 1000}, 2787 {megaco_update_conn_info, trans_req_maxcount, 10}, 2788 {megaco_update_conn_info, trans_req_maxsize, 650}, 2789 {megaco_update_conn_info, trans_timer, 120000}, 2790 {megaco_update_conn_info, trans_req, true}, 2791 {megaco_conn_info, all}, 2792 {megaco_cast, NR(1), []}, 2793 {megaco_cast, [NR(2), NR(3)], []}, 2794 {megaco_cast, NR(4), []}, 2795 {megaco_cast, NR(5), []}, 2796 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2797 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2798 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2799 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2800 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2801 {sleep, 1000}, 2802 megaco_stop_user, 2803 megaco_stop, 2804 {sleep, 1000} 2805 ], 2806 EvSeq. 2807 2808mtrms1_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 2809 io:format("mtrms1_mg_verify_handle_connect -> ok" 2810 "~n CH: ~p~n", [CH]), 2811 {ok, CH, ok}; 2812mtrms1_mg_verify_handle_connect(Else) -> 2813 io:format("mtrms1_mg_verify_handle_connect -> unknown" 2814 "~n Else: ~p~n", [Else]), 2815 {error, Else, ok}. 2816 2817mtrms1_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 2818 {ok, [AR]}, _}) -> 2819 io:format("mtrms1_mg_verify_service_change_reply -> ok" 2820 "~n AR: ~p~n", [AR]), 2821 case AR of 2822 #'ActionReply'{commandReply = [SCR]} -> 2823 case SCR of 2824 {serviceChangeReply, 2825 #'ServiceChangeReply'{terminationID = [Tid], 2826 serviceChangeResult = Res}} -> 2827 case Tid of 2828 #megaco_term_id{contains_wildcards = false, 2829 id = ["root"]} -> 2830 case Res of 2831 {serviceChangeResParms, 2832 #'ServiceChangeResParm'{ 2833 serviceChangeMgcId = _RemoteMid}} -> 2834 {ok, AR, ok}; 2835 {Tag, Val} -> 2836 Err = {invalid_service_change_result, 2837 Tag, Val}, 2838 {error, Err, ok} 2839 end; 2840 _ -> 2841 Err = {invalid_termination_id, Tid}, 2842 {error, Err, ok} 2843 end; 2844 {Tag, Val} -> 2845 Err = {invalid_command_reply, Tag, Val}, 2846 {error, Err, ok} 2847 end; 2848 _ -> 2849 Err = {invalid_action_reply, AR}, 2850 {error, Err, ok} 2851 end; 2852mtrms1_mg_verify_service_change_reply(Else) -> 2853 io:format("mtrms1_mg_verify_service_change_reply -> unknown" 2854 "~n Else: ~p~n", [Else]), 2855 {error, Else, ok}. 2856 2857mtrms1_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 2858 {ok, [AR]}, _}) -> 2859 io:format("mtrms1_mg_verify_service_change_reply -> ok" 2860 "~n AR: ~p~n", [AR]), 2861 {ok, AR, ok}; 2862mtrms1_mg_verify_notify_reply(Else) -> 2863 io:format("mtrms1_mg_verify_service_change_reply -> unknown" 2864 "~n Else: ~p~n", [Else]), 2865 {error, Else, ok}. 2866 2867mtrms1_mg_service_change_request_ar(_Mid, Cid) -> 2868 Prof = cre_serviceChangeProf("resgw", 1), 2869 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 2870 Root = #megaco_term_id{id = ["root"]}, 2871 SCR = cre_serviceChangeReq([Root], SCP), 2872 CMD = cre_command(SCR), 2873 CR = cre_cmdReq(CMD), 2874 cre_actionReq(Cid, [CR]). 2875 2876%% mtrms1_mg_service_change_request_msg(Mid, TransId, Cid) -> 2877%% AR = mtrms1_mg_service_change_request_ar(Mid, Cid), 2878%% TR = cre_transReq(TransId, [AR]), 2879%% Trans = cre_transaction(TR), 2880%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2881%% cre_megacoMessage(Mess). 2882 2883mtrms1_mg_notify_request_ar1(Rid, Tid, Cid) -> 2884 TT = cre_timeNotation("19990729", "22000000"), 2885 Ev = cre_obsEvent("al/of", TT), 2886 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 2887 NR = cre_notifyReq([Tid], EvsDesc), 2888 CMD = cre_command(NR), 2889 CR = cre_cmdReq(CMD), 2890 cre_actionReq(Cid, [CR]). 2891 2892%% mtrms1_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 2893%% AR = mtrms1_mg_notify_request_ar1(Rid, TermId, Cid), 2894%% TR = cre_transReq(TransId, [AR]), 2895%% Trans = cre_transaction(TR), 2896%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2897%% cre_megacoMessage(Mess). 2898 2899 2900mtrms1_err_desc(T) -> 2901 cre_ErrDesc(T). 2902 2903 2904 2905 2906%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 2907 2908multi_trans_req_maxsize2(suite) -> 2909 []; 2910multi_trans_req_maxsize2(doc) -> 2911 "Test that the message is sent when req_maxsize is reached, " 2912 "when the 'last' message is bigger then req_maxsize itself"; 2913multi_trans_req_maxsize2(Config) when is_list(Config) -> 2914 Pre = fun() -> 2915 MgcNode = make_node_name(mgc), 2916 MgNode = make_node_name(mg), 2917 d("start nodes: " 2918 "~n MGC Node: ~p" 2919 "~n MG Node: ~p", 2920 [MgcNode, MgNode]), 2921 Nodes = [MgcNode, MgNode], 2922 ok = ?START_NODES(Nodes), 2923 Nodes 2924 end, 2925 Case = fun do_multi_trans_req_maxsize2/1, 2926 Post = fun(Nodes) -> 2927 d("stop nodes"), 2928 ?STOP_NODES(lists:reverse(Nodes)) 2929 end, 2930 try_tc(multi_trans_req_maxsize2, Pre, Case, Post). 2931 2932do_multi_trans_req_maxsize2([MgcNode, MgNode]) -> 2933 2934 d("[MGC] start the simulator "), 2935 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 2936 2937 d("[MGC] create the event sequence"), 2938 MgcEvSeq = mtrms2_mgc_event_sequence(text, tcp), 2939 2940 i("wait some time before starting the MGC simulation"), 2941 sleep(1000), 2942 2943 d("[MGC] start the simulation"), 2944 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 2945 2946 %% i("wait some time before starting the MG simulator"), 2947 %% sleep(1000), 2948 2949 i("await MGC ready announcement"), 2950 receive 2951 announce_mgc -> 2952 i("received MGC ready announcement"), 2953 ok 2954 end, 2955 2956 d("[MG] start the simulator (generator)"), 2957 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 2958 2959 d("[MG] create the event sequence"), 2960 MgEvSeq = mtrms2_mg_event_sequence(text, tcp), 2961 2962 i("wait some time before starting the MG simulation"), 2963 sleep(1000), 2964 2965 d("[MG] start the simulation"), 2966 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 2967 2968 d("await the generator reply(s)"), 2969 await_completion([MgcId, MgId]), 2970 2971 %% Tell Mgc to stop 2972 i("[MGC] stop generator"), 2973 megaco_test_megaco_generator:stop(Mgc), 2974 2975 %% Tell Mg to stop 2976 i("[MG] stop generator"), 2977 megaco_test_megaco_generator:stop(Mg), 2978 2979 i("done", []), 2980 ok. 2981 2982 2983%% 2984%% MGC generator stuff 2985%% 2986-ifdef(megaco_hipe_special). 2987-define(mtrms2_mgc_verify_handle_connect_fun(), 2988 {?MODULE, mtrms2_mgc_verify_handle_connect, []}). 2989-define(mtrms2_mgc_verify_service_change_req_fun(Mid), 2990 {?MODULE, mtrms2_mgc_verify_service_change_req, [Mid]}). 2991-define(mtrms2_mgc_verify_notify_req_fun(), 2992 {?MODULE, mtrms2_mgc_verify_notify_request, []}). 2993-define(mtrms2_mgc_verify_handle_disconnect_fun(), 2994 {?MODULE, mtrms2_mgc_verify_handle_disconnect, []}). 2995-else. 2996-define(mtrms2_mgc_verify_handle_connect_fun(), 2997 fun mtrms2_mgc_verify_handle_connect/1). 2998-define(mtrms2_mgc_verify_service_change_req_fun(Mid), 2999 mtrms2_mgc_verify_service_change_req_fun(Mid)). 3000-define(mtrms2_mgc_verify_notify_req_fun(), 3001 mtrms2_mgc_verify_notify_request_fun()). 3002-define(mtrms2_mgc_verify_handle_disconnect_fun(), 3003 fun mtrms2_mgc_verify_handle_disconnect/1). 3004-endif. 3005 3006mtrms2_mgc_event_sequence(text, tcp) -> 3007 CTRL = self(), 3008 Mid = {deviceName,"ctrl"}, 3009 RI = [ 3010 {port, 2944}, 3011 {encoding_module, megaco_pretty_text_encoder}, 3012 {encoding_config, []}, 3013 {transport_module, megaco_tcp} 3014 ], 3015 ConnectVerify = ?mtrms2_mgc_verify_handle_connect_fun(), 3016 ServiceChangeReqVerify = ?mtrms2_mgc_verify_service_change_req_fun(Mid), 3017 NotifyReqVerify = ?mtrms2_mgc_verify_notify_req_fun(), 3018 DiscoVerify = ?mtrms2_mgc_verify_handle_disconnect_fun(), 3019 EvSeq = [ 3020 {debug, true}, 3021 {megaco_trace, disable}, 3022 megaco_start, 3023 {megaco_start_user, Mid, RI, []}, 3024 start_transport, 3025 listen, 3026 3027 %% ANNOUNCE READY 3028 {trigger, fun() -> CTRL ! announce_mgc end}, 3029 3030 {megaco_callback, handle_connect, ConnectVerify}, 3031 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 3032 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3033 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3034 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3035 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3036 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3037 {megaco_callback, handle_disconnect, DiscoVerify}, 3038 {sleep, 1000}, 3039 megaco_stop_user, 3040 megaco_stop 3041 ], 3042 EvSeq. 3043 3044 3045mtrms2_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 3046 io:format("mtrms2_mgc_verify_handle_connect -> ok" 3047 "~n CH: ~p~n", [CH]), 3048 {ok, CH, ok}; 3049mtrms2_mgc_verify_handle_connect(Else) -> 3050 io:format("mtrms2_mgc_verify_handle_connect -> unknown" 3051 "~n Else: ~p~n", [Else]), 3052 {error, Else, ok}. 3053 3054mtrms2_mgc_verify_service_change_req_fun(Mid) -> 3055 fun(Ev) -> 3056 mtrms2_mgc_verify_service_change_req(Ev, Mid) 3057 end. 3058 3059mtrms2_mgc_verify_service_change_req( 3060 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 3061 io:format("mtrms2_mgc_verify_service_change_req -> ok" 3062 "~n AR: ~p~n", [AR]), 3063 case AR of 3064 #'ActionRequest'{commandRequests = [CR]} -> 3065 case CR of 3066 #'CommandRequest'{command = Cmd} -> 3067 case Cmd of 3068 {serviceChangeReq, 3069 #'ServiceChangeRequest'{terminationID = [Tid], 3070 serviceChangeParms = Parms}} -> 3071 case Tid of 3072 #megaco_term_id{contains_wildcards = false, 3073 id = ["root"]} -> 3074 case Parms of 3075 #'ServiceChangeParm'{ 3076 serviceChangeMethod = restart, 3077 serviceChangeReason = [[$9,$0,$1|_]]} -> 3078 Reply = 3079 {discard_ack, 3080 [mtrms2_mgc_service_change_reply_ar(Mid, 1)]}, 3081 {ok, AR, Reply}; 3082 _ -> 3083 Err = {invalid_SCP, Parms}, 3084 ED = mtrms2_err_desc(Parms), 3085 ErrReply = {discard_ack, 3086 ED}, 3087 {error, Err, ErrReply} 3088 end; 3089 _ -> 3090 Err = {invalid_termination_id, Tid}, 3091 ED = mtrms2_err_desc(Tid), 3092 ErrReply = {discard_ack, ED}, 3093 {error, Err, ErrReply} 3094 end; 3095 _ -> 3096 Err = {invalid_command, Cmd}, 3097 ED = mtrms2_err_desc(Cmd), 3098 ErrReply = {discard_ack, ED}, 3099 {error, Err, ErrReply} 3100 end; 3101 _ -> 3102 Err = {invalid_command_request, CR}, 3103 ED = mtrms2_err_desc(CR), 3104 ErrReply = {discard_ack, ED}, 3105 {error, Err, ErrReply} 3106 end; 3107 _ -> 3108 Err = {invalid_action_request, AR}, 3109 ED = mtrms2_err_desc(AR), 3110 ErrReply = {discard_ack, ED}, 3111 {error, Err, ErrReply} 3112 end; 3113mtrms2_mgc_verify_service_change_req(Else, _Mid) -> 3114 io:format("mtrms2_mgc_verify_service_change_req -> unknown" 3115 "~n Else: ~p~n", [Else]), 3116 ED = mtrms2_err_desc(Else), 3117 ErrReply = {discard_ack, ED}, 3118 {error, Else, ErrReply}. 3119 3120mtrms2_mgc_verify_notify_request_fun() -> 3121 fun(Ev) -> 3122 mtrms2_mgc_verify_notify_request(Ev) 3123 end. 3124 3125mtrms2_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 3126 io:format("mtrms2_mgc_verify_notify_request -> ok" 3127 "~n AR: ~p~n", [AR]), 3128 case AR of 3129 #'ActionRequest'{contextId = Cid, 3130 commandRequests = [CR]} -> 3131 io:format("mtrms2_mgc_verify_notify_request:fun -> " 3132 "single command", []), 3133 #'CommandRequest'{command = Cmd} = CR, 3134 {notifyReq, NR} = Cmd, 3135 #'NotifyRequest'{terminationID = [Tid], 3136 observedEventsDescriptor = OED, 3137 errorDescriptor = asn1_NOVALUE} = NR, 3138 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 3139 #'ObservedEvent'{eventName = "al/of"} = OE, 3140 Reply = {discard_ack, 3141 [mtrms2_mgc_notify_reply_ar1(Cid, Tid)]}, 3142 {ok, AR, Reply}; 3143 #'ActionRequest'{contextId = Cid, 3144 commandRequests = CRs} -> 3145 io:format("mtrms2_mgc_verify_notify_request:fun -> " 3146 "multi command (~w)", [length(CRs)]), 3147 Tids = [Tid || 3148 #'CommandRequest'{command = 3149 {notifyReq, 3150 #'NotifyRequest'{ 3151 terminationID = [Tid]}}} 3152 <- CRs], 3153 Reply = 3154 {discard_ack, 3155 [mtrms2_mgc_notify_reply_ar2(Cid, Tids)]}, 3156 {ok, AR, Reply}; 3157 _ -> 3158 ED = mtrms2_err_desc(AR), 3159 ErrReply = {discard_ack, ED}, 3160 {error, AR, ErrReply} 3161 end; 3162mtrms2_mgc_verify_notify_request(Else) -> 3163 io:format("mtrms2_mgc_verify_notify_request -> unknown" 3164 "~n Else: ~p~n", [Else]), 3165 ED = mtrms2_err_desc(Else), 3166 ErrReply = {discard_ack, ED}, 3167 {error, Else, ErrReply}. 3168 3169mtrms2_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 3170 io:format("mtrms2_mgc_verify_handle_disconnect -> ok" 3171 "~n CH: ~p" 3172 "~n R: ~p" 3173 "~n", [CH, R]), 3174 {ok, CH, ok}; 3175mtrms2_mgc_verify_handle_disconnect(Else) -> 3176 io:format("mtrms2_mgc_verify_handle_disconnect -> unknown" 3177 "~n Else: ~p~n", [Else]), 3178 {error, Else, ok}. 3179 3180 3181mtrms2_mgc_service_change_reply_ar(Mid, Cid) -> 3182 SCRP = cre_serviceChangeResParm(Mid), 3183 SCRes = cre_serviceChangeResult(SCRP), 3184 Root = #megaco_term_id{id = ["root"]}, 3185 SCR = cre_serviceChangeReply([Root], SCRes), 3186 CR = cre_cmdReply(SCR), 3187 cre_actionReply(Cid, [CR]). 3188 3189%% mtrms2_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 3190%% AR = mtrms2_mgc_service_change_reply_ar(Mid, Cid), 3191%% TRes = cre_transResult([AR]), 3192%% TR = cre_transReply(TransId, TRes), 3193%% Trans = cre_transaction(TR), 3194%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3195%% cre_megacoMessage(Mess). 3196 3197mtrms2_mgc_notify_reply_ar1(Cid, Tid) -> 3198 NR = cre_notifyReply([Tid]), 3199 CR = cre_cmdReply(NR), 3200 cre_actionReply(Cid, [CR]). 3201 3202mtrms2_mgc_notify_reply_ar2(Cid, Tids) -> 3203 CRs = [cre_cmdReply(cre_notifyReply([Tid])) || Tid <- Tids], 3204 cre_actionReply(Cid, CRs). 3205 3206%% mtrms2_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 3207%% AR = mtrms2_mgc_notify_reply_ar1(Cid, TermId), 3208%% TRes = cre_transResult([AR]), 3209%% TR = cre_transReply(TransId, TRes), 3210%% Trans = cre_transaction(TR), 3211%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3212%% cre_megacoMessage(Mess). 3213 3214 3215%% 3216%% MG generator stuff 3217%% 3218-ifdef(megaco_hipe_special). 3219-define(mtrms2_mg_verify_handle_connect_fun(), 3220 {?MODULE, mtrms2_mg_verify_handle_connect, []}). 3221-define(mtrms2_mg_verify_service_change_reply_fun(Mid), 3222 {?MODULE, mtrms2_mg_verify_service_change_reply, [Mid]}). 3223-define(mtrms2_mg_verify_notify_reply_fun(), 3224 {?MODULE, mtrms2_mg_verify_notify_reply, []}). 3225-else. 3226-define(mtrms2_mg_verify_handle_connect_fun(), 3227 fun mtrms2_mg_verify_handle_connect/1). 3228-define(mtrms2_mg_verify_service_change_reply_fun(), 3229 fun mtrms2_mg_verify_service_change_reply/1). 3230-define(mtrms2_mg_verify_notify_reply_fun(), 3231 fun mtrms2_mg_verify_notify_reply/1). 3232-endif. 3233 3234mtrms2_mg_event_sequence(text, tcp) -> 3235 Mid = {deviceName,"mg"}, 3236 RI = [ 3237 {port, 2944}, 3238 {encoding_module, megaco_pretty_text_encoder}, 3239 {encoding_config, []}, 3240 {transport_module, megaco_tcp} 3241 ], 3242 ServiceChangeReq = [mtrms2_mg_service_change_request_ar(Mid, 1)], 3243 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 3244 NotifyReq1 = [mtrms2_mg_notify_request_ar1(1, Tid, 1)], 3245 NotifyReq2 = [mtrms2_mg_notify_request_ar2(2, Tid, 2)], 3246 ConnectVerify = ?mtrms2_mg_verify_handle_connect_fun(), 3247 ServiceChangeReplyVerify = ?mtrms2_mg_verify_service_change_reply_fun(), 3248 NotifyReplyVerify = ?mtrms2_mg_verify_notify_reply_fun(), 3249 EvSeq = [ 3250 {debug, true}, 3251 megaco_start, 3252 {megaco_start_user, Mid, RI, []}, 3253 start_transport, 3254 {megaco_trace, disable}, 3255 {megaco_system_info, users}, 3256 {megaco_system_info, connections}, 3257 connect, 3258 {megaco_callback, handle_connect, ConnectVerify}, 3259 megaco_connect, 3260 {megaco_cast, ServiceChangeReq, []}, 3261 {megaco_callback, handle_connect, ConnectVerify}, 3262 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 3263 {sleep, 1000}, 3264 {megaco_system_info, users}, 3265 {megaco_system_info, connections}, 3266 {sleep, 1000}, 3267 {megaco_update_conn_info, trans_req_maxcount, 10}, 3268 {megaco_update_conn_info, trans_req_maxsize, 1024}, 3269 {megaco_update_conn_info, trans_timer, 120000}, 3270 {megaco_update_conn_info, trans_req, true}, 3271 {megaco_conn_info, all}, 3272 {megaco_cast, NotifyReq1, []}, 3273 {megaco_cast, [NotifyReq1, NotifyReq1], []}, 3274 {megaco_cast, NotifyReq1, []}, 3275 {megaco_cast, NotifyReq2, []}, 3276 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3277 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3278 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3279 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3280 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3281 {sleep, 1000}, 3282 megaco_stop_user, 3283 megaco_stop, 3284 {sleep, 1000} 3285 ], 3286 EvSeq. 3287 3288mtrms2_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 3289 io:format("mtrms2_mg_verify_handle_connect -> ok" 3290 "~n CH: ~p~n", [CH]), 3291 {ok, CH, ok}; 3292mtrms2_mg_verify_handle_connect(Else) -> 3293 io:format("mtrms2_mg_verify_handle_connect -> unknown" 3294 "~n Else: ~p~n", [Else]), 3295 {error, Else, ok}. 3296 3297mtrms2_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 3298 {ok, [AR]}, _}) -> 3299 io:format("mtrms2_mg_verify_service_change_reply -> ok" 3300 "~n AR: ~p~n", [AR]), 3301 case AR of 3302 #'ActionReply'{commandReply = [SCR]} -> 3303 case SCR of 3304 {serviceChangeReply, 3305 #'ServiceChangeReply'{terminationID = [Tid], 3306 serviceChangeResult = Res}} -> 3307 case Tid of 3308 #megaco_term_id{contains_wildcards = false, 3309 id = ["root"]} -> 3310 case Res of 3311 {serviceChangeResParms, 3312 #'ServiceChangeResParm'{ 3313 serviceChangeMgcId = _RemoteMid}} -> 3314 {ok, AR, ok}; 3315 {Tag, Val} -> 3316 Err = {invalid_service_change_result, 3317 Tag, Val}, 3318 {error, Err, ok} 3319 end; 3320 _ -> 3321 Err = {invalid_termination_id, Tid}, 3322 {error, Err, ok} 3323 end; 3324 {Tag, Val} -> 3325 Err = {invalid_command_reply, Tag, Val}, 3326 {error, Err, ok} 3327 end; 3328 _ -> 3329 Err = {invalid_action_reply, AR}, 3330 {error, Err, ok} 3331 end; 3332mtrms2_mg_verify_service_change_reply(Else) -> 3333 io:format("mtrms2_mg_verify_service_change_reply -> unknown" 3334 "~n Else: ~p~n", [Else]), 3335 {error, Else, ok}. 3336 3337mtrms2_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 3338 {ok, [AR]}, _}) -> 3339 io:format("mtrms2_mg_verify_notify_reply -> ok" 3340 "~n AR: ~p~n", [AR]), 3341 case AR of 3342 #'ActionReply'{commandReply = [{notifyReply, _NR}]} -> 3343 io:format("mtrms2_mg_verify_notify_reply -> " 3344 "single notify reply", []), 3345 {ok, AR, ok}; 3346 #'ActionReply'{commandReply = [{notifyReply, _NR}|_] = CR} -> 3347 io:format("mtrms2_mg_verify_notify_reply -> " 3348 "multi notify reply: (~w)", [length(CR)]), 3349 {ok, AR, ok}; 3350 _ -> 3351 {error, {invalid_action_reply, AR}, ok} 3352 end; 3353mtrms2_mg_verify_notify_reply(Else) -> 3354 io:format("mtrms2_mg_verify_notify_reply -> unknown" 3355 "~n Else: ~p~n", [Else]), 3356 {error, Else, ok}. 3357 3358mtrms2_mg_service_change_request_ar(_Mid, Cid) -> 3359 Prof = cre_serviceChangeProf("resgw", 1), 3360 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 3361 Root = #megaco_term_id{id = ["root"]}, 3362 SCR = cre_serviceChangeReq([Root], SCP), 3363 CMD = cre_command(SCR), 3364 CR = cre_cmdReq(CMD), 3365 cre_actionReq(Cid, [CR]). 3366 3367%% mtrms2_mg_service_change_request_msg(Mid, TransId, Cid) -> 3368%% AR = mtrms2_mg_service_change_request_ar(Mid, Cid), 3369%% TR = cre_transReq(TransId, [AR]), 3370%% Trans = cre_transaction(TR), 3371%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3372%% cre_megacoMessage(Mess). 3373 3374mtrms2_mg_notify_request_ar1(Rid, Tid, Cid) -> 3375 TT = cre_timeNotation("19990729", "22000000"), 3376 Ev = cre_obsEvent("al/of", TT), 3377 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 3378 NR = cre_notifyReq([Tid], EvsDesc), 3379 CMD = cre_command(NR), 3380 CR = cre_cmdReq(CMD), 3381 cre_actionReq(Cid, [CR]). 3382 3383mtrms2_mg_notify_request_ar2(Rid, Tid, Cid) -> 3384 F = fun(N) -> 3385 T = 22000000 + N, 3386 TS = integer_to_list(T), 3387 TT = cre_timeNotation("19990729", TS), 3388 Ev = cre_obsEvent("al/of", TT), 3389 EvsDesc = cre_obsEvsDesc(Rid+N, [Ev]), 3390 NR = cre_notifyReq([Tid], EvsDesc), 3391 CMD = cre_command(NR), 3392 cre_cmdReq(CMD) 3393 end, 3394 Ns = [0,1,2,3,4,5,6,7,8,9], 3395 CRs = [F(N) || N <- Ns], 3396 cre_actionReq(Cid, CRs). 3397 3398%% mtrms2_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 3399%% AR = mtrms2_mg_notify_request_ar1(Rid, TermId, Cid), 3400%% TR = cre_transReq(TransId, [AR]), 3401%% Trans = cre_transaction(TR), 3402%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3403%% cre_megacoMessage(Mess). 3404 3405 3406mtrms2_err_desc(T) -> 3407 cre_ErrDesc(T). 3408 3409 3410%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3411 3412single_trans_req_and_ack(suite) -> 3413 []; 3414single_trans_req_and_ack(doc) -> 3415 []; 3416single_trans_req_and_ack(Config) when is_list(Config) -> 3417 Pre = fun() -> 3418 MgcNode = make_node_name(mgc), 3419 MgNode = make_node_name(mg), 3420 d("start nodes: " 3421 "~n MGC Node: ~p" 3422 "~n MG Node: ~p", 3423 [MgcNode, MgNode]), 3424 Nodes = [MgcNode, MgNode], 3425 ok = ?START_NODES(Nodes), 3426 Nodes 3427 end, 3428 Case = fun do_single_trans_req_and_ack/1, 3429 Post = fun(Nodes) -> 3430 d("stop nodes"), 3431 ?STOP_NODES(lists:reverse(Nodes)) 3432 end, 3433 try_tc(single_trans_req_and_ack, Pre, Case, Post). 3434 3435do_single_trans_req_and_ack([MgcNode, MgNode]) -> 3436 3437 d("[MGC] start the simulator "), 3438 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 3439 3440 d("[MGC] create the event sequence"), 3441 MgcEvSeq = straa_mgc_event_sequence(text, tcp), 3442 3443 i("wait some time before starting the MGC simulation"), 3444 sleep(1000), 3445 3446 d("[MGC] start the simulation"), 3447 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 3448 3449 %% i("wait some time before starting the MG simulator"), 3450 %% sleep(1000), 3451 3452 i("await MGC ready announcement"), 3453 receive 3454 announce_mgc -> 3455 i("received MGC ready announcement"), 3456 ok 3457 end, 3458 3459 d("[MG] start the simulator (generator)"), 3460 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 3461 3462 d("[MG] create the event sequence"), 3463 MgEvSeq = straa_mg_event_sequence(text, tcp), 3464 3465 i("wait some time before starting the MG simulation"), 3466 sleep(1000), 3467 3468 d("[MG] start the simulation"), 3469 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 3470 3471 d("await the generator reply(s)"), 3472 await_completion([MgcId, MgId]), 3473 3474 %% Tell Mgc to stop 3475 i("[MGC] stop generator"), 3476 megaco_test_megaco_generator:stop(Mgc), 3477 3478 %% Tell Mg to stop 3479 i("[MG] stop generator"), 3480 megaco_test_megaco_generator:stop(Mg), 3481 3482 i("done", []), 3483 ok. 3484 3485 3486%% 3487%% MGC generator stuff 3488%% 3489-ifdef(megaco_hipe_special). 3490-define(straa_mgc_verify_handle_connect_fun(), 3491 {?MODULE, straa_mgc_verify_handle_connect, []}). 3492-define(straa_mgc_verify_service_change_req_fun(Mid), 3493 {?MODULE, straa_mgc_verify_service_change_req, [Mid]}). 3494-define(straa_mgc_verify_notify_req_fun(), 3495 {?MODULE, straa_mgc_verify_notify_request, []}). 3496-define(straa_mgc_verify_ack_fun(), 3497 {?MODULE, straa_mgc_verify_ack, []}). 3498-define(straa_mgc_verify_handle_disconnect_fun(), 3499 {?MODULE, straa_mgc_verify_handle_disconnect, []}). 3500-else. 3501-define(straa_mgc_verify_handle_connect_fun(), 3502 fun straa_mgc_verify_handle_connect/1). 3503-define(straa_mgc_verify_service_change_req_fun(Mid), 3504 straa_mgc_verify_service_change_req_fun(Mid)). 3505-define(straa_mgc_verify_notify_req_fun(), 3506 straa_mgc_verify_notify_request_fun()). 3507-define(straa_mgc_verify_ack_fun(), 3508 fun straa_mgc_verify_ack/1). 3509-define(straa_mgc_verify_handle_disconnect_fun(), 3510 fun straa_mgc_verify_handle_disconnect/1). 3511-endif. 3512 3513straa_mgc_event_sequence(text, tcp) -> 3514 CTRL = self(), 3515 Mid = {deviceName,"ctrl"}, 3516 RI = [ 3517 {port, 2944}, 3518 {encoding_module, megaco_pretty_text_encoder}, 3519 {encoding_config, []}, 3520 {transport_module, megaco_tcp} 3521 ], 3522 ConnectVerify = ?straa_mgc_verify_handle_connect_fun(), 3523 ServiceChangeReqVerify = ?straa_mgc_verify_service_change_req_fun(Mid), 3524 NotifyReqVerify = ?straa_mgc_verify_notify_req_fun(), 3525 AckVerify = ?straa_mgc_verify_ack_fun(), 3526 DiscoVerify = ?straa_mgc_verify_handle_disconnect_fun(), 3527 EvSeq = [ 3528 {debug, true}, 3529 {megaco_trace, disable}, 3530 megaco_start, 3531 {megaco_start_user, Mid, RI, []}, 3532 start_transport, 3533 listen, 3534 3535 %% ANNOUNCE READY 3536 {trigger, fun() -> CTRL ! announce_mgc end}, 3537 3538 {megaco_callback, handle_connect, ConnectVerify}, 3539 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 3540 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3541 {megaco_callback, handle_trans_ack, AckVerify}, 3542 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3543 {megaco_callback, handle_disconnect, DiscoVerify}, 3544 {sleep, 1000}, 3545 megaco_stop_user, 3546 megaco_stop 3547 ], 3548 EvSeq. 3549 3550 3551straa_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 3552 io:format("straa_mgc_verify_handle_connect -> ok" 3553 "~n CH: ~p~n", [CH]), 3554 {ok, CH, ok}; 3555straa_mgc_verify_handle_connect(Else) -> 3556 io:format("straa_mgc_verify_handle_connect -> unknown" 3557 "~n Else: ~p~n", [Else]), 3558 {error, Else, ok}. 3559 3560straa_mgc_verify_service_change_req_fun(Mid) -> 3561 fun(Ev) -> 3562 straa_mgc_verify_service_change_req(Ev, Mid) 3563 end. 3564 3565straa_mgc_verify_service_change_req( 3566 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 3567 io:format("straa_mgc_verify_service_change_req -> ok" 3568 "~n AR: ~p~n", [AR]), 3569 case AR of 3570 #'ActionRequest'{commandRequests = [CR]} -> 3571 case CR of 3572 #'CommandRequest'{command = Cmd} -> 3573 case Cmd of 3574 {serviceChangeReq, 3575 #'ServiceChangeRequest'{terminationID = [Tid], 3576 serviceChangeParms = Parms}} -> 3577 case Tid of 3578 #megaco_term_id{contains_wildcards = false, 3579 id = ["root"]} -> 3580 case Parms of 3581 #'ServiceChangeParm'{ 3582 serviceChangeMethod = restart, 3583 serviceChangeReason = [[$9,$0,$1|_]]} -> 3584 Reply = 3585 {discard_ack, 3586 [straa_mgc_service_change_reply_ar(Mid, 1)]}, 3587 {ok, AR, Reply}; 3588 _ -> 3589 Err = {invalid_SCP, Parms}, 3590 ED = straa_err_desc(Parms), 3591 ErrReply = {discard_ack, 3592 ED}, 3593 {error, Err, ErrReply} 3594 end; 3595 _ -> 3596 Err = {invalid_termination_id, Tid}, 3597 ED = straa_err_desc(Tid), 3598 ErrReply = {discard_ack, ED}, 3599 {error, Err, ErrReply} 3600 end; 3601 _ -> 3602 Err = {invalid_command, Cmd}, 3603 ED = straa_err_desc(Cmd), 3604 ErrReply = {discard_ack, ED}, 3605 {error, Err, ErrReply} 3606 end; 3607 _ -> 3608 Err = {invalid_command_request, CR}, 3609 ED = straa_err_desc(CR), 3610 ErrReply = {discard_ack, ED}, 3611 {error, Err, ErrReply} 3612 end; 3613 _ -> 3614 Err = {invalid_action_request, AR}, 3615 ED = straa_err_desc(AR), 3616 ErrReply = {discard_ack, ED}, 3617 {error, Err, ErrReply} 3618 end; 3619straa_mgc_verify_service_change_req(Else, _Mid) -> 3620 io:format("straa_mgc_verify_service_change_req -> unknown" 3621 "~n Else: ~p~n", [Else]), 3622 ED = straa_err_desc(Else), 3623 ErrReply = {discard_ack, ED}, 3624 {error, Else, ErrReply}. 3625 3626straa_mgc_verify_notify_request_fun() -> 3627 fun(Ev) -> 3628 straa_mgc_verify_notify_request(Ev) 3629 end. 3630 3631straa_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 3632 io:format("straa_mgc_verify_notify_request:fun -> ok" 3633 "~n AR: ~p~n", [AR]), 3634 case AR of 3635 #'ActionRequest'{contextId = 1 = Cid, 3636 commandRequests = [CR]} -> 3637 #'CommandRequest'{command = Cmd} = CR, 3638 {notifyReq, NR} = Cmd, 3639 #'NotifyRequest'{terminationID = [Tid], 3640 observedEventsDescriptor = OED, 3641 errorDescriptor = asn1_NOVALUE} = NR, 3642 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 3643 #'ObservedEvent'{eventName = "al/of"} = OE, 3644 HandleAck = {handle_sloppy_ack, kalle}, 3645 Reply = {HandleAck, 3646 [straa_mgc_notify_reply_ar(Cid, Tid)]}, 3647 {ok, AR, Reply}; 3648 #'ActionRequest'{contextId = 2 = Cid, 3649 commandRequests = [CR]} -> 3650 #'CommandRequest'{command = Cmd} = CR, 3651 {notifyReq, NR} = Cmd, 3652 #'NotifyRequest'{terminationID = [Tid], 3653 observedEventsDescriptor = OED, 3654 errorDescriptor = asn1_NOVALUE} = NR, 3655 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 3656 #'ObservedEvent'{eventName = "al/of"} = OE, 3657 Reply = {discard_ack, 3658 [straa_mgc_notify_reply_ar(Cid, Tid)]}, 3659 {ok, AR, Reply}; 3660 _ -> 3661 ED = straa_err_desc(AR), 3662 ErrReply = {discard_ack, ED}, 3663 {error, AR, ErrReply} 3664 end; 3665straa_mgc_verify_notify_request(Else) -> 3666 io:format("straa_mgc_verify_notify_request:fun -> unknown" 3667 "~n Else: ~p~n", [Else]), 3668 ED = straa_err_desc(Else), 3669 ErrReply = {discard_ack, ED}, 3670 {error, Else, ErrReply}. 3671 3672straa_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 3673 io:format("straa_mgc_verify_ack -> ok" 3674 "~n CH: ~p" 3675 "~n", [CH]), 3676 {ok, CH, ok}; 3677straa_mgc_verify_ack(Else) -> 3678 io:format("straa_mgc_verify_ack -> unknown" 3679 "~n Else: ~p~n", [Else]), 3680 {error, Else, ok}. 3681 3682straa_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 3683 io:format("straa_mgc_verify_handle_disconnect -> ok" 3684 "~n CH: ~p" 3685 "~n R: ~p" 3686 "~n", [CH, R]), 3687 {ok, CH, ok}; 3688straa_mgc_verify_handle_disconnect(Else) -> 3689 io:format("straa_mgc_verify_handle_disconnect -> unknown" 3690 "~n Else: ~p~n", [Else]), 3691 {error, Else, ok}. 3692 3693 3694straa_mgc_service_change_reply_ar(Mid, Cid) -> 3695 SCRP = cre_serviceChangeResParm(Mid), 3696 SCRes = cre_serviceChangeResult(SCRP), 3697 Root = #megaco_term_id{id = ["root"]}, 3698 SCR = cre_serviceChangeReply([Root], SCRes), 3699 CR = cre_cmdReply(SCR), 3700 cre_actionReply(Cid, [CR]). 3701 3702%% straa_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 3703%% AR = straa_mgc_service_change_reply_ar(Mid, Cid), 3704%% TRes = cre_transResult([AR]), 3705%% TR = cre_transReply(TransId, TRes), 3706%% Trans = cre_transaction(TR), 3707%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3708%% cre_megacoMessage(Mess). 3709 3710straa_mgc_notify_reply_ar(Cid, TermId) -> 3711 NR = cre_notifyReply([TermId]), 3712 CR = cre_cmdReply(NR), 3713 cre_actionReply(Cid, [CR]). 3714 3715%% straa_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 3716%% AR = straa_mgc_notify_reply_ar(Cid, TermId), 3717%% TRes = cre_transResult([AR]), 3718%% TR = cre_transReply(TransId, TRes), 3719%% Trans = cre_transaction(TR), 3720%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3721%% cre_megacoMessage(Mess). 3722 3723 3724%% 3725%% MG generator stuff 3726%% 3727-ifdef(megaco_hipe_special). 3728-define(straa_mg_verify_handle_connect_fun(), 3729 {?MODULE, straa_mg_verify_handle_connect, []}). 3730-define(straa_mg_verify_service_change_reply_fun(), 3731 {?MODULE, straa_mg_verify_service_change_reply, []}). 3732-define(straa_mg_verify_notify_reply_fun(), 3733 {?MODULE, straa_mg_verify_notify_reply, []}). 3734-else. 3735-define(straa_mg_verify_handle_connect_fun(), 3736 fun straa_mg_verify_handle_connect/1). 3737-define(straa_mg_verify_service_change_reply_fun(), 3738 fun straa_mg_verify_service_change_reply/1). 3739-define(straa_mg_verify_notify_reply_fun(), 3740 fun straa_mg_verify_notify_reply/1). 3741-endif. 3742 3743straa_mg_event_sequence(text, tcp) -> 3744 Mid = {deviceName,"mg"}, 3745 RI = [ 3746 {port, 2944}, 3747 {encoding_module, megaco_pretty_text_encoder}, 3748 {encoding_config, []}, 3749 {transport_module, megaco_tcp} 3750 ], 3751 ServiceChangeReq = [straa_mg_service_change_request_ar(Mid, 1)], 3752 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 3753 NR = fun(N) -> 3754 [straa_mg_notify_request_ar(N, Tid, N)] 3755 end, 3756 ConnectVerify = ?straa_mg_verify_handle_connect_fun(), 3757 ServiceChangeReplyVerify = ?straa_mg_verify_service_change_reply_fun(), 3758 NotifyReplyVerify = ?straa_mg_verify_notify_reply_fun(), 3759 EvSeq = [ 3760 {debug, true}, 3761 megaco_start, 3762 {megaco_start_user, Mid, RI, []}, 3763 start_transport, 3764 {megaco_trace, disable}, 3765 {megaco_system_info, users}, 3766 {megaco_system_info, connections}, 3767 connect, 3768 {megaco_callback, handle_connect, ConnectVerify}, 3769 megaco_connect, 3770 {megaco_cast, ServiceChangeReq, []}, 3771 {megaco_callback, handle_connect, ConnectVerify}, 3772 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 3773 {sleep, 1000}, 3774 {megaco_update_conn_info, auto_ack, true}, 3775 {megaco_update_conn_info, trans_ack_maxcount, 10}, 3776 {megaco_update_conn_info, trans_timer, 1000}, 3777 {megaco_update_conn_info, trans_ack, true}, 3778 {megaco_update_conn_info, trans_req, true}, 3779 {megaco_conn_info, all}, 3780 {sleep, 1000}, 3781 {megaco_cast, NR(1), []}, 3782 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3783 {megaco_cast, NR(2), []}, 3784 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3785 {sleep, 3000}, 3786 megaco_stop_user, 3787 megaco_stop, 3788 {sleep, 1000} 3789 ], 3790 EvSeq. 3791 3792straa_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 3793 io:format("straa_mg_verify_handle_connect -> ok" 3794 "~n CH: ~p~n", [CH]), 3795 {ok, CH, ok}; 3796straa_mg_verify_handle_connect(Else) -> 3797 io:format("straa_mg_verify_handle_connect -> unknown" 3798 "~n Else: ~p~n", [Else]), 3799 {error, Else, ok}. 3800 3801straa_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 3802 {ok, [AR]}, _}) -> 3803 io:format("straa_mg_verify_service_change_reply -> ok" 3804 "~n AR: ~p~n", [AR]), 3805 case AR of 3806 #'ActionReply'{commandReply = [SCR]} -> 3807 case SCR of 3808 {serviceChangeReply, 3809 #'ServiceChangeReply'{terminationID = [Tid], 3810 serviceChangeResult = Res}} -> 3811 case Tid of 3812 #megaco_term_id{contains_wildcards = false, 3813 id = ["root"]} -> 3814 case Res of 3815 {serviceChangeResParms, 3816 #'ServiceChangeResParm'{ 3817 serviceChangeMgcId = _RemoteMid}} -> 3818 {ok, AR, ok}; 3819 {Tag, Val} -> 3820 Err = {invalid_service_change_result, 3821 Tag, Val}, 3822 {error, Err, ok} 3823 end; 3824 _ -> 3825 Err = {invalid_termination_id, Tid}, 3826 {error, Err, ok} 3827 end; 3828 {Tag, Val} -> 3829 Err = {invalid_command_reply, Tag, Val}, 3830 {error, Err, ok} 3831 end; 3832 _ -> 3833 Err = {invalid_action_reply, AR}, 3834 {error, Err, ok} 3835 end; 3836straa_mg_verify_service_change_reply(Else) -> 3837 io:format("straa_mg_verify_service_change_reply -> unknown" 3838 "~n Else: ~p~n", [Else]), 3839 {error, Else, ok}. 3840 3841straa_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 3842 {ok, [AR]}, _}) -> 3843 io:format("straa_mg_verify_notify_reply -> ok" 3844 "~n AR: ~p~n", [AR]), 3845 {ok, AR, ok}; 3846straa_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 3847 {error, Err}, _}) -> 3848 io:format("straa_mg_verify_notify_reply -> error" 3849 "~n Err: ~p~n", [Err]), 3850 {error, Err, ok}; 3851straa_mg_verify_notify_reply(Else) -> 3852 io:format("straa_mg_verify_notify_reply -> unknown" 3853 "~n Else: ~p~n", [Else]), 3854 {error, Else, ok}. 3855 3856straa_mg_service_change_request_ar(_Mid, Cid) -> 3857 Prof = cre_serviceChangeProf("resgw", 1), 3858 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 3859 Root = #megaco_term_id{id = ["root"]}, 3860 SCR = cre_serviceChangeReq([Root], SCP), 3861 CMD = cre_command(SCR), 3862 CR = cre_cmdReq(CMD), 3863 cre_actionReq(Cid, [CR]). 3864 3865%% straa_mg_service_change_request_msg(Mid, TransId, Cid) -> 3866%% AR = straa_mg_service_change_request_ar(Mid, Cid), 3867%% TR = cre_transReq(TransId, [AR]), 3868%% Trans = cre_transaction(TR), 3869%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3870%% cre_megacoMessage(Mess). 3871 3872straa_mg_notify_request_ar(Rid, Tid, Cid) -> 3873 TT = cre_timeNotation("19990729", "22000000"), 3874 Ev = cre_obsEvent("al/of", TT), 3875 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 3876 NR = cre_notifyReq([Tid], EvsDesc), 3877 CMD = cre_command(NR), 3878 CR = cre_cmdReq(CMD), 3879 cre_actionReq(Cid, [CR]). 3880 3881%% straa_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 3882%% AR = straa_mg_notify_request_ar(Rid, TermId, Cid), 3883%% TR = cre_transReq(TransId, [AR]), 3884%% Trans = cre_transaction(TR), 3885%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3886%% cre_megacoMessage(Mess). 3887 3888 3889%% 3890%% Common functions for the single_trans_req test case 3891%% 3892 3893straa_err_desc(T) -> 3894 cre_ErrDesc(T). 3895 3896 3897 3898 3899%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3900 3901multi_trans_req_and_ack_timeout(suite) -> 3902 []; 3903multi_trans_req_and_ack_timeout(doc) -> 3904 []; 3905multi_trans_req_and_ack_timeout(Config) when is_list(Config) -> 3906 Pre = fun() -> 3907 MgcNode = make_node_name(mgc), 3908 MgNode = make_node_name(mg), 3909 d("start nodes: " 3910 "~n MGC Node: ~p" 3911 "~n MG Node: ~p", 3912 [MgcNode, MgNode]), 3913 Nodes = [MgcNode, MgNode], 3914 ok = ?START_NODES(Nodes), 3915 Nodes 3916 end, 3917 Case = fun do_multi_trans_req_and_ack_timeout/1, 3918 Post = fun(Nodes) -> 3919 d("stop nodes"), 3920 ?STOP_NODES(lists:reverse(Nodes)) 3921 end, 3922 try_tc(multi_trans_req_and_ack_timeout, Pre, Case, Post). 3923 3924do_multi_trans_req_and_ack_timeout([MgcNode, MgNode]) -> 3925 3926 d("[MGC] start the simulator "), 3927 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 3928 3929 d("[MGC] create the event sequence"), 3930 MgcEvSeq = mtrtaat_mgc_event_sequence(text, tcp), 3931 3932 i("wait some time before starting the MGC simulation"), 3933 sleep(1000), 3934 3935 d("[MGC] start the simulation"), 3936 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 3937 3938 %% i("wait some time before starting the MG simulator"), 3939 %% sleep(1000), 3940 3941 i("await MGC ready announcement"), 3942 receive 3943 announce_mgc -> 3944 i("received MGC ready announcement"), 3945 ok 3946 end, 3947 3948 d("[MG] start the simulator (generator)"), 3949 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 3950 3951 d("[MG] create the event sequence"), 3952 MgEvSeq = mtrtaat_mg_event_sequence(text, tcp), 3953 3954 i("wait some time before starting the MG simulation"), 3955 sleep(1000), 3956 3957 d("[MG] start the simulation"), 3958 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 3959 3960 d("await the generator reply(s)"), 3961 await_completion([MgcId, MgId]), 3962 3963 %% Tell Mgc to stop 3964 i("[MGC] stop generator"), 3965 megaco_test_megaco_generator:stop(Mgc), 3966 3967 %% Tell Mg to stop 3968 i("[MG] stop generator"), 3969 megaco_test_megaco_generator:stop(Mg), 3970 3971 i("done", []), 3972 ok. 3973 3974 3975%% 3976%% MGC generator stuff 3977%% 3978-ifdef(megaco_hipe_special). 3979-define(mtrtaat_mgc_verify_handle_connect_fun(), 3980 {?MODULE, mtrtaat_mgc_verify_handle_connect, []}). 3981-define(mtrtaat_mgc_verify_service_change_req_fun(Mid), 3982 {?MODULE, mtrtaat_mgc_verify_service_change_req, [Mid]}). 3983-define(mtrtaat_mgc_verify_notify_req_fun(), 3984 {?MODULE, mtrtaat_mgc_verify_notify_request, []}). 3985-define(mtrtaat_mgc_verify_ack_fun(), 3986 {?MODULE, mtrtaat_mgc_verify_ack, []}). 3987-define(mtrtaat_mgc_verify_handle_disconnect_fun(), 3988 {?MODULE, mtrtaat_mgc_verify_handle_disconnect, []}). 3989-else. 3990-define(mtrtaat_mgc_verify_handle_connect_fun(), 3991 fun mtrtaat_mgc_verify_handle_connect/1). 3992-define(mtrtaat_mgc_verify_service_change_req_fun(Mid), 3993 mtrtaat_mgc_verify_service_change_req_fun(Mid)). 3994-define(mtrtaat_mgc_verify_notify_req_fun(), 3995 mtrtaat_mgc_verify_notify_request_fun()). 3996-define(mtrtaat_mgc_verify_ack_fun(), 3997 fun mtrtaat_mgc_verify_ack/1). 3998-define(mtrtaat_mgc_verify_handle_disconnect_fun(), 3999 fun mtrtaat_mgc_verify_handle_disconnect/1). 4000-endif. 4001 4002mtrtaat_mgc_event_sequence(text, tcp) -> 4003 CTRL = self(), 4004 Mid = {deviceName,"ctrl"}, 4005 RI = [ 4006 {port, 2944}, 4007 {encoding_module, megaco_pretty_text_encoder}, 4008 {encoding_config, []}, 4009 {transport_module, megaco_tcp} 4010 ], 4011 ConnectVerify = ?mtrtaat_mgc_verify_handle_connect_fun(), 4012 ServiceChangeReqVerify = ?mtrtaat_mgc_verify_service_change_req_fun(Mid), 4013 NotifyReqVerify = ?mtrtaat_mgc_verify_notify_req_fun(), 4014 AckVerify = ?mtrtaat_mgc_verify_ack_fun(), 4015 DiscoVerify = ?mtrtaat_mgc_verify_handle_disconnect_fun(), 4016 EvSeq = [ 4017 {debug, true}, 4018 {megaco_trace, disable}, 4019 megaco_start, 4020 {megaco_start_user, Mid, RI, []}, 4021 start_transport, 4022 listen, 4023 4024 %% ANNOUNCE READY 4025 {trigger, fun() -> CTRL ! announce_mgc end}, 4026 4027 {megaco_callback, handle_connect, ConnectVerify}, 4028 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 4029 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4030 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4031 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4032 {megaco_callback, handle_trans_ack, AckVerify}, 4033 {megaco_callback, handle_trans_ack, AckVerify}, 4034 {megaco_callback, handle_trans_ack, AckVerify}, 4035 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4036 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4037 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4038 {megaco_callback, handle_disconnect, DiscoVerify}, 4039 {sleep, 1000}, 4040 megaco_stop_user, 4041 megaco_stop 4042 ], 4043 EvSeq. 4044 4045 4046mtrtaat_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 4047 io:format("mtrtaat_mgc_verify_handle_connect -> ok" 4048 "~n CH: ~p~n", [CH]), 4049 {ok, CH, ok}; 4050mtrtaat_mgc_verify_handle_connect(Else) -> 4051 io:format("mtrtaat_mgc_verify_handle_connect -> unknown" 4052 "~n Else: ~p~n", [Else]), 4053 {error, Else, ok}. 4054 4055mtrtaat_mgc_verify_service_change_req_fun(Mid) -> 4056 fun(Ev) -> 4057 mtrtaat_mgc_verify_service_change_req(Ev, Mid) 4058 end. 4059 4060mtrtaat_mgc_verify_service_change_req( 4061 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 4062 io:format("mtrtaat_mgc_verify_service_change_req -> ok" 4063 "~n AR: ~p~n", [AR]), 4064 case AR of 4065 #'ActionRequest'{commandRequests = [CR]} -> 4066 case CR of 4067 #'CommandRequest'{command = Cmd} -> 4068 case Cmd of 4069 {serviceChangeReq, 4070 #'ServiceChangeRequest'{terminationID = [Tid], 4071 serviceChangeParms = Parms}} -> 4072 case Tid of 4073 #megaco_term_id{contains_wildcards = false, 4074 id = ["root"]} -> 4075 case Parms of 4076 #'ServiceChangeParm'{ 4077 serviceChangeMethod = restart, 4078 serviceChangeReason = [[$9,$0,$1|_]]} -> 4079 Reply = 4080 {discard_ack, 4081 [mtrtaat_mgc_service_change_reply_ar(Mid, 1)]}, 4082 {ok, AR, Reply}; 4083 _ -> 4084 Err = {invalid_SCP, Parms}, 4085 ED = mtrtaat_err_desc(Parms), 4086 ErrReply = {discard_ack, 4087 ED}, 4088 {error, Err, ErrReply} 4089 end; 4090 _ -> 4091 Err = {invalid_termination_id, Tid}, 4092 ED = mtrtaat_err_desc(Tid), 4093 ErrReply = {discard_ack, ED}, 4094 {error, Err, ErrReply} 4095 end; 4096 _ -> 4097 Err = {invalid_command, Cmd}, 4098 ED = mtrtaat_err_desc(Cmd), 4099 ErrReply = {discard_ack, ED}, 4100 {error, Err, ErrReply} 4101 end; 4102 _ -> 4103 Err = {invalid_command_request, CR}, 4104 ED = mtrtaat_err_desc(CR), 4105 ErrReply = {discard_ack, ED}, 4106 {error, Err, ErrReply} 4107 end; 4108 _ -> 4109 Err = {invalid_action_request, AR}, 4110 ED = mtrtaat_err_desc(AR), 4111 ErrReply = {discard_ack, ED}, 4112 {error, Err, ErrReply} 4113 end; 4114mtrtaat_mgc_verify_service_change_req(Else, _Mid) -> 4115 io:format("mtrtaat_mgc_verify_service_change_req -> unknown" 4116 "~n Else: ~p~n", [Else]), 4117 ED = mtrtaat_err_desc(Else), 4118 ErrReply = {discard_ack, ED}, 4119 {error, Else, ErrReply}. 4120 4121mtrtaat_mgc_verify_notify_request_fun() -> 4122 fun(Ev) -> 4123 mtrtaat_mgc_verify_notify_request(Ev) 4124 end. 4125 4126mtrtaat_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 4127 io:format("mtrtaat_mgc_verify_notify_request -> ok" 4128 "~n AR: ~p~n", [AR]), 4129 case AR of 4130 #'ActionRequest'{contextId = 1 = Cid, 4131 commandRequests = [CR]} -> 4132 #'CommandRequest'{command = Cmd} = CR, 4133 {notifyReq, NR} = Cmd, 4134 #'NotifyRequest'{terminationID = [Tid], 4135 observedEventsDescriptor = OED, 4136 errorDescriptor = asn1_NOVALUE} = NR, 4137 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 4138 #'ObservedEvent'{eventName = "al/of"} = OE, 4139 HandleAck = {handle_sloppy_ack, kalle}, 4140 Reply = {HandleAck, 4141 [mtrtaat_mgc_notify_reply_ar(Cid, Tid)]}, 4142 {ok, AR, Reply}; 4143 #'ActionRequest'{contextId = 2 = Cid, 4144 commandRequests = [CR]} -> 4145 #'CommandRequest'{command = Cmd} = CR, 4146 {notifyReq, NR} = Cmd, 4147 #'NotifyRequest'{terminationID = [Tid], 4148 observedEventsDescriptor = OED, 4149 errorDescriptor = asn1_NOVALUE} = NR, 4150 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 4151 #'ObservedEvent'{eventName = "al/of"} = OE, 4152 Reply = {discard_ack, [mtrtaat_mgc_notify_reply_ar(Cid, Tid)]}, 4153 {ok, AR, Reply}; 4154 _ -> 4155 ED = mtrtaat_err_desc(AR), 4156 ErrReply = {discard_ack, ED}, 4157 {error, AR, ErrReply} 4158 end; 4159mtrtaat_mgc_verify_notify_request(Else) -> 4160 io:format("mtrtaat_mgc_verify_notify_request -> unknown" 4161 "~n Else: ~p~n", [Else]), 4162 ED = mtrtaat_err_desc(Else), 4163 ErrReply = {discard_ack, ED}, 4164 {error, Else, ErrReply}. 4165 4166 4167mtrtaat_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 4168 io:format("mtrtaat_mgc_verify_ack -> ok" 4169 "~n CH: ~p" 4170 "~n", [CH]), 4171 {ok, CH, ok}; 4172mtrtaat_mgc_verify_ack(Else) -> 4173 io:format("mtrtaat_mgc_verify_ack -> unknown" 4174 "~n Else: ~p~n", [Else]), 4175 {error, Else, ok}. 4176 4177mtrtaat_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 4178 io:format("mtrtaat_mgc_verify_handle_disconnect -> ok" 4179 "~n CH: ~p" 4180 "~n R: ~p" 4181 "~n", [CH, R]), 4182 {ok, CH, ok}; 4183mtrtaat_mgc_verify_handle_disconnect(Else) -> 4184 io:format("mtrtaat_mgc_verify_handle_disconnect -> unknown" 4185 "~n Else: ~p~n", [Else]), 4186 {error, Else, ok}. 4187 4188 4189mtrtaat_mgc_service_change_reply_ar(Mid, Cid) -> 4190 SCRP = cre_serviceChangeResParm(Mid), 4191 SCRes = cre_serviceChangeResult(SCRP), 4192 Root = #megaco_term_id{id = ["root"]}, 4193 SCR = cre_serviceChangeReply([Root], SCRes), 4194 CR = cre_cmdReply(SCR), 4195 cre_actionReply(Cid, [CR]). 4196 4197%% mtrtaat_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 4198%% AR = mtrtaat_mgc_service_change_reply_ar(Mid, Cid), 4199%% TRes = cre_transResult([AR]), 4200%% TR = cre_transReply(TransId, TRes), 4201%% Trans = cre_transaction(TR), 4202%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 4203%% cre_megacoMessage(Mess). 4204 4205mtrtaat_mgc_notify_reply_ar(Cid, TermId) -> 4206 NR = cre_notifyReply([TermId]), 4207 CR = cre_cmdReply(NR), 4208 cre_actionReply(Cid, [CR]). 4209 4210%% mtrtaat_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 4211%% AR = mtrtaat_mgc_notify_reply_ar(Cid, TermId), 4212%% TRes = cre_transResult([AR]), 4213%% TR = cre_transReply(TransId, TRes), 4214%% Trans = cre_transaction(TR), 4215%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 4216%% cre_megacoMessage(Mess). 4217 4218 4219%% 4220%% MG generator stuff 4221%% 4222-ifdef(megaco_hipe_special). 4223-define(mtrtaat_mg_verify_handle_connect_fun(), 4224 {?MODULE, mtrtaat_mg_verify_handle_connect, []}). 4225-define(mtrtaat_mg_verify_service_change_reply_fun(), 4226 {?MODULE, mtrtaat_mg_verify_service_change_reply, []}). 4227-define(mtrtaat_mg_verify_notify_reply_fun(), 4228 {?MODULE, mtrtaat_mg_verify_notify_reply, []}). 4229-else. 4230-define(mtrtaat_mg_verify_handle_connect_fun(), 4231 fun mtrtaat_mg_verify_handle_connect/1). 4232-define(mtrtaat_mg_verify_service_change_reply_fun(), 4233 fun mtrtaat_mg_verify_service_change_reply/1). 4234-define(mtrtaat_mg_verify_notify_reply_fun(), 4235 fun mtrtaat_mg_verify_notify_reply/1). 4236-endif. 4237 4238mtrtaat_mg_event_sequence(text, tcp) -> 4239 Mid = {deviceName,"mg"}, 4240 RI = [ 4241 {port, 2944}, 4242 {encoding_module, megaco_pretty_text_encoder}, 4243 {encoding_config, []}, 4244 {transport_module, megaco_tcp} 4245 ], 4246 ServiceChangeReq = [mtrtaat_mg_service_change_request_ar(Mid, 1)], 4247 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 4248 NR = fun(Cid, Rid) -> 4249 [mtrtaat_mg_notify_request_ar(Rid, Tid, Cid)] 4250 end, 4251 ConnectVerify = ?mtrtaat_mg_verify_handle_connect_fun(), 4252 ServiceChangeReplyVerify = ?mtrtaat_mg_verify_service_change_reply_fun(), 4253 NotifyReplyVerify = ?mtrtaat_mg_verify_notify_reply_fun(), 4254 EvSeq = [ 4255 {debug, true}, 4256 megaco_start, 4257 {megaco_start_user, Mid, RI, []}, 4258 start_transport, 4259 {megaco_trace, disable}, 4260 {megaco_system_info, users}, 4261 {megaco_system_info, connections}, 4262 connect, 4263 {megaco_callback, handle_connect, ConnectVerify}, 4264 megaco_connect, 4265 {megaco_cast, ServiceChangeReq, []}, 4266 {megaco_callback, handle_connect, ConnectVerify}, 4267 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 4268 {sleep, 1000}, 4269 {megaco_system_info, users}, 4270 {megaco_system_info, connections}, 4271 {sleep, 1000}, 4272 {megaco_update_conn_info, auto_ack, true}, 4273 {megaco_update_conn_info, trans_ack_maxcount, 10}, 4274 {megaco_update_conn_info, trans_req_maxcount, 10}, 4275 {megaco_update_conn_info, trans_timer, 1000}, 4276 {megaco_update_conn_info, trans_ack, true}, 4277 {megaco_update_conn_info, trans_req, true}, 4278 {megaco_conn_info, all}, 4279 {megaco_cast, NR(1,1), []}, 4280 {megaco_cast, NR(1,2), []}, 4281 {megaco_cast, NR(1,3), []}, 4282 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4283 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4284 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4285 {megaco_cast, NR(2,1), []}, 4286 {megaco_cast, NR(2,2), []}, 4287 {megaco_cast, NR(2,3), []}, 4288 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4289 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4290 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4291 {sleep, 3000}, 4292 megaco_stop_user, 4293 megaco_stop, 4294 {sleep, 1000} 4295 ], 4296 EvSeq. 4297 4298mtrtaat_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 4299 io:format("mtrtaat_mg_verify_handle_connect -> ok" 4300 "~n CH: ~p~n", [CH]), 4301 {ok, CH, ok}; 4302mtrtaat_mg_verify_handle_connect(Else) -> 4303 io:format("mtrtaat_mg_verify_handle_connect -> unknown" 4304 "~n Else: ~p~n", [Else]), 4305 {error, Else, ok}. 4306 4307mtrtaat_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 4308 {ok, [AR]}, _}) -> 4309 io:format("mtrtaat_mg_verify_service_change_reply -> ok" 4310 "~n AR: ~p~n", [AR]), 4311 case AR of 4312 #'ActionReply'{commandReply = [SCR]} -> 4313 case SCR of 4314 {serviceChangeReply, 4315 #'ServiceChangeReply'{terminationID = [Tid], 4316 serviceChangeResult = Res}} -> 4317 case Tid of 4318 #megaco_term_id{contains_wildcards = false, 4319 id = ["root"]} -> 4320 case Res of 4321 {serviceChangeResParms, 4322 #'ServiceChangeResParm'{ 4323 serviceChangeMgcId = _RemoteMid}} -> 4324 {ok, AR, ok}; 4325 {Tag, Val} -> 4326 Err = {invalid_service_change_result, 4327 Tag, Val}, 4328 {error, Err, ok} 4329 end; 4330 _ -> 4331 Err = {invalid_termination_id, Tid}, 4332 {error, Err, ok} 4333 end; 4334 {Tag, Val} -> 4335 Err = {invalid_command_reply, Tag, Val}, 4336 {error, Err, ok} 4337 end; 4338 _ -> 4339 Err = {invalid_action_reply, AR}, 4340 {error, Err, ok} 4341 end; 4342mtrtaat_mg_verify_service_change_reply(Else) -> 4343 io:format("mtrtaat_mg_verify_service_change_reply -> unknown" 4344 "~n Else: ~p~n", [Else]), 4345 {error, Else, ok}. 4346 4347mtrtaat_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 4348 {ok, [AR]}, _}) -> 4349 io:format("mtrtaat_mg_verify_notify_reply -> ok" 4350 "~n AR: ~p~n", [AR]), 4351 {ok, AR, ok}; 4352mtrtaat_mg_verify_notify_reply(Else) -> 4353 io:format("mtrtaat_mg_verify_notify_reply -> unknown" 4354 "~n Else: ~p~n", [Else]), 4355 {error, Else, ok}. 4356 4357mtrtaat_mg_service_change_request_ar(_Mid, Cid) -> 4358 Prof = cre_serviceChangeProf("resgw", 1), 4359 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 4360 Root = #megaco_term_id{id = ["root"]}, 4361 SCR = cre_serviceChangeReq([Root], SCP), 4362 CMD = cre_command(SCR), 4363 CR = cre_cmdReq(CMD), 4364 cre_actionReq(Cid, [CR]). 4365 4366%% mtrtaat_mg_service_change_request_msg(Mid, TransId, Cid) -> 4367%% AR = mtrtaat_mg_service_change_request_ar(Mid, Cid), 4368%% TR = cre_transReq(TransId, [AR]), 4369%% Trans = cre_transaction(TR), 4370%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 4371%% cre_megacoMessage(Mess). 4372 4373mtrtaat_mg_notify_request_ar(Rid, Tid, Cid) -> 4374 TT = cre_timeNotation("19990729", "22000000"), 4375 Ev = cre_obsEvent("al/of", TT), 4376 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 4377 NR = cre_notifyReq([Tid], EvsDesc), 4378 CMD = cre_command(NR), 4379 CR = cre_cmdReq(CMD), 4380 cre_actionReq(Cid, [CR]). 4381 4382%% mtrtaat_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 4383%% AR = mtrtaat_mg_notify_request_ar(Rid, TermId, Cid), 4384%% TR = cre_transReq(TransId, [AR]), 4385%% Trans = cre_transaction(TR), 4386%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 4387%% cre_megacoMessage(Mess). 4388 4389 4390%% 4391%% Common functions for the multi_trans_req_timeout test case 4392%% 4393 4394mtrtaat_err_desc(T) -> 4395 cre_ErrDesc(T). 4396 4397 4398%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 4399 4400%% Transaction Sender 4401%% 4402%% 4403 4404multi_trans_req_and_ack_ackmaxcount(suite) -> 4405 []; 4406multi_trans_req_and_ack_ackmaxcount(doc) -> 4407 []; 4408multi_trans_req_and_ack_ackmaxcount(Config) when is_list(Config) -> 4409 Pre = fun() -> 4410 MgcNode = make_node_name(mgc), 4411 MgNode = make_node_name(mg), 4412 d("start nodes: " 4413 "~n MGC Node: ~p" 4414 "~n MG Node: ~p", 4415 [MgcNode, MgNode]), 4416 Nodes = [MgcNode, MgNode], 4417 ok = ?START_NODES(Nodes), 4418 Nodes 4419 end, 4420 Case = fun do_multi_trans_req_and_ack_ackmaxcount/1, 4421 Post = fun(Nodes) -> 4422 d("stop nodes"), 4423 ?STOP_NODES(lists:reverse(Nodes)) 4424 end, 4425 try_tc(multi_trans_req_and_ack_ackmaxcount, Pre, Case, Post). 4426 4427do_multi_trans_req_and_ack_ackmaxcount([MgcNode, MgNode]) -> 4428 4429 d("[MGC] start the simulator "), 4430 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 4431 4432 d("[MGC] create the event sequence"), 4433 MgcEvSeq = mtrtaaamc_mgc_event_sequence(text, tcp), 4434 4435 i("wait some time before starting the MGC simulation"), 4436 sleep(1000), 4437 4438 d("[MGC] start the simulation"), 4439 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 4440 4441 %% i("wait some time before starting the MG simulator"), 4442 %% sleep(1000), 4443 4444 i("await MGC ready announcement"), 4445 receive 4446 announce_mgc -> 4447 i("received MGC ready announcement"), 4448 ok 4449 end, 4450 4451 d("[MG] start the simulator (generator)"), 4452 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 4453 4454 d("[MG] create the event sequence"), 4455 MgEvSeq = mtrtaaamc_mg_event_sequence(text, tcp), 4456 4457 i("wait some time before starting the MG simulation"), 4458 sleep(1000), 4459 4460 d("[MG] start the simulation"), 4461 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 4462 4463 d("await the generator reply(s)"), 4464 await_completion([MgcId, MgId]), 4465 4466 %% Tell Mgc to stop 4467 i("[MGC] stop generator"), 4468 megaco_test_megaco_generator:stop(Mgc), 4469 4470 %% Tell Mg to stop 4471 i("[MG] stop generator"), 4472 megaco_test_megaco_generator:stop(Mg), 4473 4474 i("done", []), 4475 ok. 4476 4477 4478%% 4479%% MGC generator stuff 4480%% 4481-ifdef(megaco_hipe_special). 4482-define(mtrtaaamc_mgc_verify_handle_connect_fun(), 4483 {?MODULE, mtrtaaamc_mgc_verify_handle_connect, []}). 4484-define(mtrtaaamc_mgc_verify_service_change_req_fun(Mid), 4485 {?MODULE, mtrtaaamc_mgc_verify_service_change_req, [Mid]}). 4486-define(mtrtaaamc_mgc_verify_notify_req_fun(), 4487 {?MODULE, mtrtaaamc_mgc_verify_notify_request, []}). 4488-define(mtrtaaamc_mgc_verify_ack_fun(), 4489 {?MODULE, mtrtaaamc_mgc_verify_ack, []}). 4490-define(mtrtaaamc_mgc_verify_handle_disconnect_fun(), 4491 {?MODULE, mtrtaaamc_mgc_verify_handle_disconnect, []}). 4492-else. 4493-define(mtrtaaamc_mgc_verify_handle_connect_fun(), 4494 fun mtrtaaamc_mgc_verify_handle_connect/1). 4495-define(mtrtaaamc_mgc_verify_service_change_req_fun(Mid), 4496 mtrtaaamc_mgc_verify_service_change_req_fun(Mid)). 4497-define(mtrtaaamc_mgc_verify_notify_req_fun(), 4498 mtrtaaamc_mgc_verify_notify_request_fun()). 4499-define(mtrtaaamc_mgc_verify_ack_fun(), 4500 fun mtrtaaamc_mgc_verify_ack/1). 4501-define(mtrtaaamc_mgc_verify_handle_disconnect_fun(), 4502 fun mtrtaaamc_mgc_verify_handle_disconnect/1). 4503-endif. 4504 4505mtrtaaamc_mgc_event_sequence(text, tcp) -> 4506 CTRL = self(), 4507 Mid = {deviceName,"ctrl"}, 4508 RI = [ 4509 {port, 2944}, 4510 {encoding_module, megaco_pretty_text_encoder}, 4511 {encoding_config, []}, 4512 {transport_module, megaco_tcp} 4513 ], 4514 ConnectVerify = ?mtrtaaamc_mgc_verify_handle_connect_fun(), 4515 ServiceChangeReqVerify = ?mtrtaaamc_mgc_verify_service_change_req_fun(Mid), 4516 NotifyReqVerify = ?mtrtaaamc_mgc_verify_notify_req_fun(), 4517 AckVerify = ?mtrtaaamc_mgc_verify_ack_fun(), 4518 DiscoVerify = ?mtrtaaamc_mgc_verify_handle_disconnect_fun(), 4519 EvSeq = [ 4520 {debug, true}, 4521 {trigger, fun() -> 4522 put(verbosity, ?TEST_VERBOSITY) 4523 end}, 4524 {megaco_trace, disable}, 4525 megaco_start, 4526 {megaco_start_user, Mid, RI, []}, 4527 start_transport, 4528 listen, 4529 4530 %% ANNOUNCE READY 4531 {trigger, fun() -> CTRL ! announce_mgc end}, 4532 4533 {megaco_callback, handle_connect, ConnectVerify}, 4534 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 4535 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4536 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4537 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4538 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4539 {megaco_callback, handle_trans_ack, AckVerify}, 4540 {megaco_callback, handle_trans_ack, AckVerify}, 4541 {megaco_callback, handle_trans_ack, AckVerify}, 4542 {megaco_callback, handle_trans_ack, AckVerify}, 4543 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4544 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4545 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4546 {megaco_callback, handle_disconnect, DiscoVerify}, 4547 {sleep, 1000}, 4548 megaco_stop_user, 4549 megaco_stop 4550 ], 4551 EvSeq. 4552 4553 4554mtrtaaamc_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 4555 i("MGC Connect verification ok" 4556 "~n ~p~n", [CH]), 4557 {ok, CH, ok}; 4558mtrtaaamc_mgc_verify_handle_connect(Else) -> 4559 e("MGC Connect verification failed: unknown" 4560 "~n ~p~n", [Else]), 4561 {error, Else, ok}. 4562 4563mtrtaaamc_mgc_verify_service_change_req_fun(Mid) -> 4564 fun(Ev) -> 4565 mtrtaaamc_mgc_verify_service_change_req(Ev, Mid) 4566 end. 4567 4568mtrtaaamc_mgc_verify_service_change_req( 4569 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 4570 i("MGC Service Change Request verification: begin" 4571 "~n AR: ~p" 4572 "~n", [AR]), 4573 case AR of 4574 #'ActionRequest'{commandRequests = [CR]} -> 4575 case CR of 4576 #'CommandRequest'{command = Cmd} -> 4577 case Cmd of 4578 {serviceChangeReq, 4579 #'ServiceChangeRequest'{terminationID = [Tid], 4580 serviceChangeParms = Parms}} -> 4581 case Tid of 4582 #megaco_term_id{contains_wildcards = false, 4583 id = ["root"]} -> 4584 case Parms of 4585 #'ServiceChangeParm'{ 4586 serviceChangeMethod = restart, 4587 serviceChangeReason = [[$9,$0,$1|_]]} -> 4588 i("MGC Service Change Request " 4589 "verification ok"), 4590 Reply = 4591 {discard_ack, 4592 [mtrtaaamc_mgc_service_change_reply_ar(Mid, 1)]}, 4593 {ok, AR, Reply}; 4594 _ -> 4595 e("MGC Service Change Request " 4596 "verification failed: invalid SCP" 4597 "~n ~p" 4598 "~n", [Parms]), 4599 Err = {invalid_SCP, Parms}, 4600 ED = mtrtaaamc_err_desc(Parms), 4601 ErrReply = {discard_ack, 4602 ED}, 4603 {error, Err, ErrReply} 4604 end; 4605 _ -> 4606 e("MGC Service Change Request " 4607 "verification failed: " 4608 "invalid termination id" 4609 "~n ~p" 4610 "~n", [Tid]), 4611 Err = {invalid_termination_id, Tid}, 4612 ED = mtrtaaamc_err_desc(Tid), 4613 ErrReply = {discard_ack, ED}, 4614 {error, Err, ErrReply} 4615 end; 4616 _ -> 4617 e("MGC Service Change Request verification failed: " 4618 "invalid command" 4619 "~n ~p" 4620 "~n", [Cmd]), 4621 Err = {invalid_command, Cmd}, 4622 ED = mtrtaaamc_err_desc(Cmd), 4623 ErrReply = {discard_ack, ED}, 4624 {error, Err, ErrReply} 4625 end; 4626 _ -> 4627 e("MGC Service Change Request verification failed: " 4628 "invalid command request" 4629 "~n ~p" 4630 "~n", [CR]), 4631 Err = {invalid_command_request, CR}, 4632 ED = mtrtaaamc_err_desc(CR), 4633 ErrReply = {discard_ack, ED}, 4634 {error, Err, ErrReply} 4635 end; 4636 _ -> 4637 e("MGC Service Change Request verification failed: " 4638 "invalid action request" 4639 "~n ~p" 4640 "~n", [AR]), 4641 Err = {invalid_action_request, AR}, 4642 ED = mtrtaaamc_err_desc(AR), 4643 ErrReply = {discard_ack, ED}, 4644 {error, Err, ErrReply} 4645 end; 4646mtrtaaamc_mgc_verify_service_change_req(Else, _Mid) -> 4647 e("MGC Service Change Request verification failed: unknown" 4648 "~n ~p" 4649 "~n", [Else]), 4650 ED = mtrtaaamc_err_desc(Else), 4651 ErrReply = {discard_ack, ED}, 4652 {error, Else, ErrReply}. 4653 4654mtrtaaamc_mgc_verify_notify_request_fun() -> 4655 fun(Ev) -> 4656 mtrtaaamc_mgc_verify_notify_request(Ev) 4657 end. 4658 4659mtrtaaamc_mgc_verify_notify_request( 4660 {handle_trans_request, _, ?VERSION, [AR]}) -> 4661 i("MGC Notify Request verification: begin" 4662 "~n AR: ~p" 4663 "~n", [AR]), 4664 case AR of 4665 %% *** SLOPPY ACK *** 4666 #'ActionRequest'{contextId = 1 = Cid, 4667 commandRequests = [CR]} -> 4668 #'CommandRequest'{command = Cmd} = CR, 4669 {notifyReq, NR} = Cmd, 4670 #'NotifyRequest'{terminationID = [Tid], 4671 observedEventsDescriptor = OED, 4672 errorDescriptor = asn1_NOVALUE} = NR, 4673 #'ObservedEventsDescriptor'{requestId = Rid, 4674 observedEventLst = [OE]} = OED, 4675 #'ObservedEvent'{eventName = "al/of"} = OE, 4676 HandleAck = {handle_sloppy_ack, {kalle, Rid}}, 4677 i("MGC Notify Request verification ok: sloppy ack" 4678 "~n Cid: ~p" 4679 "~n Tid: ~p" 4680 "~n Rid: ~p", [Cid, Tid, Rid]), 4681 Reply = {HandleAck, 4682 [mtrtaaamc_mgc_notify_reply_ar(Cid, Tid)]}, 4683 {ok, AR, Reply}; 4684 4685 %% *** PROPER ACK *** 4686 #'ActionRequest'{contextId = 2 = Cid, 4687 commandRequests = [CR]} -> 4688 #'CommandRequest'{command = Cmd} = CR, 4689 {notifyReq, NR} = Cmd, 4690 #'NotifyRequest'{terminationID = [Tid], 4691 observedEventsDescriptor = OED, 4692 errorDescriptor = asn1_NOVALUE} = NR, 4693 #'ObservedEventsDescriptor'{requestId = _Rid, 4694 observedEventLst = [OE]} = OED, 4695 #'ObservedEvent'{eventName = "al/of"} = OE, 4696 i("MGC Notify Request verification ok: discard ack" 4697 "~n Cid: ~p" 4698 "~n Tid: ~p" 4699 "~n Rid: ~p", [Cid, Tid, _Rid]), 4700 Reply = {discard_ack, [mtrtaaamc_mgc_notify_reply_ar(Cid, Tid)]}, 4701 {ok, AR, Reply}; 4702 4703 _ -> 4704 e("MGC Notify Request verification failed: unexpected AR" 4705 "~n ~p" 4706 "~n", [AR]), 4707 ED = mtrtaaamc_err_desc(AR), 4708 ErrReply = {discard_ack, ED}, 4709 {error, AR, ErrReply} 4710 end; 4711mtrtaaamc_mgc_verify_notify_request(Else) -> 4712 e("MGC Notify Request verification failed: unexpected callback" 4713 "~n ~p" 4714 "~n", [Else]), 4715 ED = mtrtaaamc_err_desc(Else), 4716 ErrReply = {discard_ack, ED}, 4717 {error, Else, ErrReply}. 4718 4719mtrtaaamc_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, 4720 {kalle, Rid}}) -> 4721 i("MGC Ack verification: ok (kalle)" 4722 "~n CH: ~p" 4723 "~n Rid: ~p" 4724 "~n", [CH, Rid]), 4725 {ok, CH, ok}; 4726mtrtaaamc_mgc_verify_ack(Else) -> 4727 e("MGC Ack verification failed: unknown" 4728 "~n ~p~n", [Else]), 4729 {error, Else, ok}. 4730 4731mtrtaaamc_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 4732 i("MGC Disconnect verification: ok" 4733 "~n CH: ~p" 4734 "~n R: ~p" 4735 "~n", [CH, R]), 4736 {ok, CH, ok}; 4737mtrtaaamc_mgc_verify_handle_disconnect(Else) -> 4738 e("MGC Disconnect verification failed: unknown" 4739 "~n ~p" 4740 "~n", [Else]), 4741 {error, Else, ok}. 4742 4743 4744mtrtaaamc_mgc_service_change_reply_ar(Mid, Cid) -> 4745 SCRP = cre_serviceChangeResParm(Mid), 4746 SCRes = cre_serviceChangeResult(SCRP), 4747 Root = #megaco_term_id{id = ["root"]}, 4748 SCR = cre_serviceChangeReply([Root], SCRes), 4749 CR = cre_cmdReply(SCR), 4750 cre_actionReply(Cid, [CR]). 4751 4752mtrtaaamc_mgc_notify_reply_ar(Cid, TermId) -> 4753 NR = cre_notifyReply([TermId]), 4754 CR = cre_cmdReply(NR), 4755 cre_actionReply(Cid, [CR]). 4756 4757 4758 4759%% 4760%% MG generator stuff 4761%% 4762-ifdef(megaco_hipe_special). 4763-define(mtrtaaamc_mg_verify_handle_connect_fun(), 4764 {?MODULE, mtrtaaamc_mg_verify_handle_connect, []}). 4765-define(mtrtaaamc_mg_verify_service_change_reply_fun(), 4766 {?MODULE, mtrtaaamc_mg_verify_service_change_reply, []}). 4767-define(mtrtaaamc_mg_verify_notify_reply_fun(), 4768 {?MODULE, mtrtaaamc_mg_verify_notify_reply, []}). 4769-else. 4770-define(mtrtaaamc_mg_verify_handle_connect_fun(), 4771 fun mtrtaaamc_mg_verify_handle_connect/1). 4772-define(mtrtaaamc_mg_verify_service_change_reply_fun(), 4773 fun mtrtaaamc_mg_verify_service_change_reply/1). 4774-define(mtrtaaamc_mg_verify_notify_reply_fun(), 4775 fun mtrtaaamc_mg_verify_notify_reply/1). 4776-endif. 4777 4778mtrtaaamc_mg_event_sequence(text, tcp) -> 4779 Mid = {deviceName,"mg"}, 4780 RI = [ 4781 {port, 2944}, 4782 {encoding_module, megaco_pretty_text_encoder}, 4783 {encoding_config, []}, 4784 {transport_module, megaco_tcp} 4785 ], 4786 ServiceChangeReq = [mtrtaaamc_mg_service_change_request_ar(Mid, 1)], 4787 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 4788 NR = fun(Cid, Rid) -> 4789 [mtrtaaamc_mg_notify_request_ar(Rid, Tid, Cid)] 4790 end, 4791 ConnectVerify = ?mtrtaaamc_mg_verify_handle_connect_fun(), 4792 ServiceChangeReplyVerify = ?mtrtaaamc_mg_verify_service_change_reply_fun(), 4793 NotifyReplyVerify = ?mtrtaaamc_mg_verify_notify_reply_fun(), 4794 EvSeq = [ 4795 {debug, true}, 4796 {trigger, fun() -> 4797 put(verbosity, ?TEST_VERBOSITY) 4798 end}, 4799 megaco_start, 4800 {megaco_start_user, Mid, RI, []}, 4801 start_transport, 4802 {megaco_trace, disable}, 4803 {megaco_system_info, users}, 4804 {megaco_system_info, connections}, 4805 connect, 4806 {megaco_callback, handle_connect, ConnectVerify}, 4807 megaco_connect, 4808 {megaco_cast, ServiceChangeReq, []}, 4809 {megaco_callback, handle_connect, ConnectVerify}, 4810 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 4811 {sleep, 1000}, 4812 {megaco_system_info, users}, 4813 {megaco_system_info, connections}, 4814 {sleep, 1000}, 4815 {megaco_update_conn_info, auto_ack, true}, 4816 {megaco_update_conn_info, trans_ack_maxcount, 4}, 4817 {megaco_update_conn_info, trans_req_maxcount, 10}, 4818 {megaco_update_conn_info, trans_timer, 5000}, 4819 {megaco_update_conn_info, trans_ack, true}, 4820 {megaco_update_conn_info, trans_req, true}, 4821 {megaco_conn_info, all}, 4822 {megaco_conn_info, requests}, 4823 {megaco_cast, NR(1,1), []}, 4824 {megaco_conn_info, requests}, 4825 {megaco_cast, NR(1,2), []}, 4826 {megaco_conn_info, requests}, 4827 {megaco_cast, NR(1,3), []}, 4828 {megaco_conn_info, requests}, 4829 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4830 {megaco_conn_info, requests}, 4831 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4832 {megaco_conn_info, requests}, 4833 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4834 {megaco_conn_info, requests}, 4835 {megaco_cast, NR(2,1), []}, 4836 {megaco_conn_info, requests}, 4837 {megaco_cast, NR(2,2), []}, 4838 {megaco_conn_info, requests}, 4839 {megaco_cast, NR(2,3), []}, 4840 {megaco_conn_info, requests}, 4841 {megaco_cast, NR(1,4), [{trans_req,false}]}, 4842 {megaco_conn_info, requests}, 4843 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4844 {megaco_conn_info, requests}, 4845 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4846 {megaco_conn_info, requests}, 4847 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4848 {megaco_conn_info, requests}, 4849 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4850 {megaco_conn_info, requests}, 4851 {sleep, 3000}, 4852 megaco_stop_user, 4853 megaco_stop, 4854 {sleep, 1000} 4855 ], 4856 EvSeq. 4857 4858mtrtaaamc_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 4859 i("MG Connect verification: ok" 4860 "~n CH: ~p" 4861 "~n", [CH]), 4862 {ok, CH, ok}; 4863mtrtaaamc_mg_verify_handle_connect(Else) -> 4864 e("MG Connect verification failed: unknown" 4865 "~n ~p" 4866 "~n", [Else]), 4867 {error, Else, ok}. 4868 4869mtrtaaamc_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 4870 {ok, [AR]}, _}) -> 4871 i("MG Service Change Reply verification: begin" 4872 "~n AR: ~p" 4873 "~n", [AR]), 4874 case AR of 4875 #'ActionReply'{commandReply = [SCR]} -> 4876 case SCR of 4877 {serviceChangeReply, 4878 #'ServiceChangeReply'{terminationID = [Tid], 4879 serviceChangeResult = Res}} -> 4880 case Tid of 4881 #megaco_term_id{contains_wildcards = false, 4882 id = ["root"]} -> 4883 case Res of 4884 {serviceChangeResParms, 4885 #'ServiceChangeResParm'{ 4886 serviceChangeMgcId = _RemoteMid}} -> 4887 i("MG Service Change Reply verification ok"), 4888 {ok, AR, ok}; 4889 {Tag, Val} -> 4890 e("MG Service Change Reply " 4891 "verification failed: " 4892 "invalid service change result" 4893 "~n Tag: ~p" 4894 "~n Val: ~p" 4895 "~n", [Tag, Val]), 4896 Err = {invalid_service_change_result, 4897 Tag, Val}, 4898 {error, Err, ok} 4899 end; 4900 _ -> 4901 e("MG Service Change Reply verification failed: " 4902 "invalid termination id" 4903 "~n ~p" 4904 "~n", [Tid]), 4905 Err = {invalid_termination_id, Tid}, 4906 {error, Err, ok} 4907 end; 4908 {Tag, Val} -> 4909 e("MG Service Change Reply verification failed: " 4910 "invalid command reply" 4911 "~n Tag: ~p" 4912 "~n Val: ~p" 4913 "~n", [Tag, Val]), 4914 Err = {invalid_command_reply, Tag, Val}, 4915 {error, Err, ok} 4916 end; 4917 _ -> 4918 e("MG Service Change Reply verification failed: invalid action reply" 4919 "~n ~p" 4920 "~n", [AR]), 4921 Err = {invalid_action_reply, AR}, 4922 {error, Err, ok} 4923 end; 4924mtrtaaamc_mg_verify_service_change_reply(Else) -> 4925 e("MG Service Change Reply verification failed -> unknown" 4926 "~n ~p" 4927 "~n", [Else]), 4928 {error, Else, ok}. 4929 4930mtrtaaamc_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 4931 {ok, [AR]}, _}) -> 4932 i("MG Notify Reply verification ok:" 4933 "~n ~p~n", [AR]), 4934 {ok, AR, ok}; 4935mtrtaaamc_mg_verify_notify_reply({handle_unexpected_trans, CH, PV, T} = Else) -> 4936 e("MG Notify Reply verification failed: unexpected transaction" 4937 "~n CH: ~p" 4938 "~n PV: ~p" 4939 "~n T: ~p" 4940 "~n", [CH, PV, T]), 4941 {error, Else, ok}; 4942mtrtaaamc_mg_verify_notify_reply({handle_unexpected_trans, CH, PV, E, T} = Else) -> 4943 e("MG Notify Reply failed: unexpected transaction" 4944 "~n CH: ~p" 4945 "~n PV: ~p" 4946 "~n E: ~p" 4947 "~n T: ~p" 4948 "~n", [CH, PV, E, T]), 4949 {error, Else, ok}; 4950mtrtaaamc_mg_verify_notify_reply(Else) -> 4951 e("MG Notify Reply failed -> unknown" 4952 "~n ~p" 4953 "~n", [Else]), 4954 {error, Else, ok}. 4955 4956mtrtaaamc_mg_service_change_request_ar(_Mid, Cid) -> 4957 Prof = cre_serviceChangeProf("resgw", 1), 4958 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 4959 Root = #megaco_term_id{id = ["root"]}, 4960 SCR = cre_serviceChangeReq([Root], SCP), 4961 CMD = cre_command(SCR), 4962 CR = cre_cmdReq(CMD), 4963 cre_actionReq(Cid, [CR]). 4964 4965mtrtaaamc_mg_notify_request_ar(Rid, Tid, Cid) -> 4966 TT = cre_timeNotation("19990729", "22000000"), 4967 Ev = cre_obsEvent("al/of", TT), 4968 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 4969 NR = cre_notifyReq([Tid], EvsDesc), 4970 CMD = cre_command(NR), 4971 CR = cre_cmdReq(CMD), 4972 cre_actionReq(Cid, [CR]). 4973 4974 4975%% 4976%% Common functions for the multi_trans_req_timeout test case 4977%% 4978 4979mtrtaaamc_err_desc(T) -> 4980 cre_ErrDesc(T). 4981 4982 4983%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 4984 4985multi_trans_req_and_ack_reqmaxcount(suite) -> 4986 []; 4987multi_trans_req_and_ack_reqmaxcount(doc) -> 4988 []; 4989multi_trans_req_and_ack_reqmaxcount(Config) when is_list(Config) -> 4990 Pre = fun() -> 4991 MgcNode = make_node_name(mgc), 4992 MgNode = make_node_name(mg), 4993 d("start nodes: " 4994 "~n MGC Node: ~p" 4995 "~n MG Node: ~p", 4996 [MgcNode, MgNode]), 4997 Nodes = [MgcNode, MgNode], 4998 ok = ?START_NODES(Nodes), 4999 Nodes 5000 end, 5001 Case = fun do_multi_trans_req_and_ack_reqmaxcount/1, 5002 Post = fun(Nodes) -> 5003 d("stop nodes"), 5004 ?STOP_NODES(lists:reverse(Nodes)) 5005 end, 5006 try_tc(multi_trans_req_and_ack_reqmaxcount, Pre, Case, Post). 5007 5008do_multi_trans_req_and_ack_reqmaxcount([MgcNode, MgNode]) -> 5009 5010 d("[MGC] start the simulator "), 5011 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 5012 5013 d("[MGC] create the event sequence"), 5014 MgcEvSeq = mtrtaarac_mgc_event_sequence(text, tcp), 5015 5016 i("wait some time before starting the MGC simulation"), 5017 sleep(1000), 5018 5019 d("[MGC] start the simulation"), 5020 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 5021 5022 %% i("wait some time before starting the MG simulator"), 5023 %% sleep(1000), 5024 5025 i("await MGC ready announcement"), 5026 receive 5027 announce_mgc -> 5028 i("received MGC ready announcement"), 5029 ok 5030 end, 5031 5032 d("[MG] start the simulator (generator)"), 5033 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 5034 5035 d("[MG] create the event sequence"), 5036 MgEvSeq = mtrtaarac_mg_event_sequence(text, tcp), 5037 5038 i("wait some time before starting the MG simulation"), 5039 sleep(1000), 5040 5041 d("[MG] start the simulation"), 5042 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 5043 5044 d("await the generator reply(s)"), 5045 await_completion([MgcId, MgId]), 5046 5047 %% Tell Mgc to stop 5048 i("[MGC] stop generator"), 5049 megaco_test_megaco_generator:stop(Mgc), 5050 5051 %% Tell Mg to stop 5052 i("[MG] stop generator"), 5053 megaco_test_megaco_generator:stop(Mg), 5054 5055 i("done", []), 5056 ok. 5057 5058 5059%% 5060%% MGC generator stuff 5061%% 5062-ifdef(megaco_hipe_special). 5063-define(mtrtaarac_mgc_verify_handle_connect_fun(), 5064 {?MODULE, mtrtaarac_mgc_verify_handle_connect, []}). 5065-define(mtrtaarac_mgc_verify_service_change_req_fun(Mid), 5066 {?MODULE, mtrtaarac_mgc_verify_service_change_req, [Mid]}). 5067-define(mtrtaarac_mgc_verify_notify_req_fun(), 5068 {?MODULE, mtrtaarac_mgc_verify_notify_request, []}). 5069-define(mtrtaarac_mgc_verify_ack_fun(), 5070 {?MODULE, mtrtaarac_mgc_verify_ack, []}). 5071-define(mtrtaarac_mgc_verify_handle_disconnect_fun(), 5072 {?MODULE, mtrtaarac_mgc_verify_handle_disconnect, []}). 5073-else. 5074-define(mtrtaarac_mgc_verify_handle_connect_fun(), 5075 fun mtrtaarac_mgc_verify_handle_connect/1). 5076-define(mtrtaarac_mgc_verify_service_change_req_fun(Mid), 5077 mtrtaarac_mgc_verify_service_change_req_fun(Mid)). 5078-define(mtrtaarac_mgc_verify_notify_req_fun(), 5079 mtrtaarac_mgc_verify_notify_request_fun()). 5080-define(mtrtaarac_mgc_verify_ack_fun(), 5081 fun mtrtaarac_mgc_verify_ack/1). 5082-define(mtrtaarac_mgc_verify_handle_disconnect_fun(), 5083 fun mtrtaarac_mgc_verify_handle_disconnect/1). 5084-endif. 5085 5086mtrtaarac_mgc_event_sequence(text, tcp) -> 5087 CTRL = self(), 5088 Mid = {deviceName,"ctrl"}, 5089 RI = [ 5090 {port, 2944}, 5091 {encoding_module, megaco_pretty_text_encoder}, 5092 {encoding_config, []}, 5093 {transport_module, megaco_tcp} 5094 ], 5095 ConnectVerify = ?mtrtaarac_mgc_verify_handle_connect_fun(), 5096 ServiceChangeReqVerify = ?mtrtaarac_mgc_verify_service_change_req_fun(Mid), 5097 NotifyReqVerify = ?mtrtaarac_mgc_verify_notify_req_fun(), 5098 AckVerify = ?mtrtaarac_mgc_verify_ack_fun(), 5099 DiscoVerify = ?mtrtaarac_mgc_verify_handle_disconnect_fun(), 5100 EvSeq = [ 5101 {debug, true}, 5102 {megaco_trace, disable}, 5103 megaco_start, 5104 {megaco_start_user, Mid, RI, []}, 5105 start_transport, 5106 listen, 5107 5108 %% ANNOUNCE READY 5109 {trigger, fun() -> CTRL ! announce_mgc end}, 5110 5111 {megaco_callback, handle_connect, ConnectVerify}, 5112 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 5113 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5114 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5115 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5116 {megaco_callback, handle_trans_ack, AckVerify}, 5117 {megaco_callback, handle_trans_ack, AckVerify}, 5118 {megaco_callback, handle_trans_ack, AckVerify}, 5119 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5120 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5121 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5122 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5123 {megaco_callback, handle_disconnect, DiscoVerify}, 5124 {sleep, 1000}, 5125 megaco_stop_user, 5126 megaco_stop 5127 ], 5128 EvSeq. 5129 5130 5131mtrtaarac_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 5132 io:format("mtrtaarac_mgc_verify_handle_connect -> ok" 5133 "~n CH: ~p~n", [CH]), 5134 {ok, CH, ok}; 5135mtrtaarac_mgc_verify_handle_connect(Else) -> 5136 io:format("mtrtaarac_mgc_verify_handle_connect -> unknown" 5137 "~n Else: ~p~n", [Else]), 5138 {error, Else, ok}. 5139 5140mtrtaarac_mgc_verify_service_change_req_fun(Mid) -> 5141 fun(Ev) -> 5142 mtrtaarac_mgc_verify_service_change_req(Ev, Mid) 5143 end. 5144 5145mtrtaarac_mgc_verify_service_change_req( 5146 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 5147 io:format("mtrtaarac_mgc_verify_service_change_req -> ok" 5148 "~n AR: ~p~n", [AR]), 5149 case AR of 5150 #'ActionRequest'{commandRequests = [CR]} -> 5151 case CR of 5152 #'CommandRequest'{command = Cmd} -> 5153 case Cmd of 5154 {serviceChangeReq, 5155 #'ServiceChangeRequest'{terminationID = [Tid], 5156 serviceChangeParms = Parms}} -> 5157 case Tid of 5158 #megaco_term_id{contains_wildcards = false, 5159 id = ["root"]} -> 5160 case Parms of 5161 #'ServiceChangeParm'{ 5162 serviceChangeMethod = restart, 5163 serviceChangeReason = [[$9,$0,$1|_]]} -> 5164 Reply = 5165 {discard_ack, 5166 [mtrtaarac_mgc_service_change_reply_ar(Mid, 1)]}, 5167 {ok, AR, Reply}; 5168 _ -> 5169 Err = {invalid_SCP, Parms}, 5170 ED = mtrtaarac_err_desc(Parms), 5171 ErrReply = {discard_ack, 5172 ED}, 5173 {error, Err, ErrReply} 5174 end; 5175 _ -> 5176 Err = {invalid_termination_id, Tid}, 5177 ED = mtrtaarac_err_desc(Tid), 5178 ErrReply = {discard_ack, ED}, 5179 {error, Err, ErrReply} 5180 end; 5181 _ -> 5182 Err = {invalid_command, Cmd}, 5183 ED = mtrtaarac_err_desc(Cmd), 5184 ErrReply = {discard_ack, ED}, 5185 {error, Err, ErrReply} 5186 end; 5187 _ -> 5188 Err = {invalid_command_request, CR}, 5189 ED = mtrtaarac_err_desc(CR), 5190 ErrReply = {discard_ack, ED}, 5191 {error, Err, ErrReply} 5192 end; 5193 _ -> 5194 Err = {invalid_action_request, AR}, 5195 ED = mtrtaarac_err_desc(AR), 5196 ErrReply = {discard_ack, ED}, 5197 {error, Err, ErrReply} 5198 end; 5199mtrtaarac_mgc_verify_service_change_req(Else, _Mid) -> 5200 io:format("mtrtaarac_mgc_verify_service_change_req -> unknown" 5201 "~n Else: ~p~n", [Else]), 5202 ED = mtrtaarac_err_desc(Else), 5203 ErrReply = {discard_ack, ED}, 5204 {error, Else, ErrReply}. 5205 5206mtrtaarac_mgc_verify_notify_request_fun() -> 5207 fun(Ev) -> 5208 mtrtaarac_mgc_verify_notify_request(Ev) 5209 end. 5210 5211mtrtaarac_mgc_verify_notify_request( 5212 {handle_trans_request, _, ?VERSION, [AR]}) -> 5213 io:format("mtrtaarac_mgc_verify_notify_request:fun -> ok" 5214 "~n AR: ~p~n", [AR]), 5215 case AR of 5216 #'ActionRequest'{contextId = 1 = Cid, 5217 commandRequests = [CR]} -> 5218 #'CommandRequest'{command = Cmd} = CR, 5219 {notifyReq, NR} = Cmd, 5220 #'NotifyRequest'{terminationID = [Tid], 5221 observedEventsDescriptor = OED, 5222 errorDescriptor = asn1_NOVALUE} = NR, 5223 #'ObservedEventsDescriptor'{requestId = Rid, 5224 observedEventLst = [OE]} = OED, 5225 #'ObservedEvent'{eventName = "al/of"} = OE, 5226 HandleAck = {handle_sloppy_ack, {kalle, Rid}}, 5227 Reply = {HandleAck, 5228 [mtrtaarac_mgc_notify_reply_ar(Cid, Tid)]}, 5229 {ok, AR, Reply}; 5230 #'ActionRequest'{contextId = 2 = Cid, 5231 commandRequests = [CR]} -> 5232 #'CommandRequest'{command = Cmd} = CR, 5233 {notifyReq, NR} = Cmd, 5234 #'NotifyRequest'{terminationID = [Tid], 5235 observedEventsDescriptor = OED, 5236 errorDescriptor = asn1_NOVALUE} = NR, 5237 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 5238 #'ObservedEvent'{eventName = "al/of"} = OE, 5239 Reply = {discard_ack, [mtrtaarac_mgc_notify_reply_ar(Cid, Tid)]}, 5240 {ok, AR, Reply}; 5241 _ -> 5242 ED = mtrtaarac_err_desc(AR), 5243 ErrReply = {discard_ack, ED}, 5244 {error, AR, ErrReply} 5245 end; 5246mtrtaarac_mgc_verify_notify_request(Else) -> 5247 io:format("mtrtaarac_mgc_verify_notify_request:fun -> unknown" 5248 "~n Else: ~p~n", [Else]), 5249 ED = mtrtaarac_err_desc(Else), 5250 ErrReply = {discard_ack, ED}, 5251 {error, Else, ErrReply}. 5252 5253mtrtaarac_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, 5254 {kalle, Rid}}) -> 5255 io:format("mtrtaarac_mgc_verify_ack -> ok" 5256 "~n CH: ~p" 5257 "~n Rid: ~p" 5258 "~n", [CH, Rid]), 5259 {ok, CH, ok}; 5260mtrtaarac_mgc_verify_ack(Else) -> 5261 io:format("mtrtaarac_mgc_verify_ack -> unknown" 5262 "~n Else: ~p~n", [Else]), 5263 {error, Else, ok}. 5264 5265mtrtaarac_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 5266 io:format("mtrtaarac_mgc_verify_handle_disconnect -> ok" 5267 "~n CH: ~p" 5268 "~n R: ~p" 5269 "~n", [CH, R]), 5270 {ok, CH, ok}; 5271mtrtaarac_mgc_verify_handle_disconnect(Else) -> 5272 io:format("mtrtaarac_mgc_verify_handle_disconnect -> unknown" 5273 "~n Else: ~p~n", [Else]), 5274 {error, Else, ok}. 5275 5276 5277mtrtaarac_mgc_service_change_reply_ar(Mid, Cid) -> 5278 SCRP = cre_serviceChangeResParm(Mid), 5279 SCRes = cre_serviceChangeResult(SCRP), 5280 Root = #megaco_term_id{id = ["root"]}, 5281 SCR = cre_serviceChangeReply([Root], SCRes), 5282 CR = cre_cmdReply(SCR), 5283 cre_actionReply(Cid, [CR]). 5284 5285%% mtrtaarac_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 5286%% AR = mtrtaarac_mgc_service_change_reply_ar(Mid, Cid), 5287%% TRes = cre_transResult([AR]), 5288%% TR = cre_transReply(TransId, TRes), 5289%% Trans = cre_transaction(TR), 5290%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5291%% cre_megacoMessage(Mess). 5292 5293mtrtaarac_mgc_notify_reply_ar(Cid, TermId) -> 5294 NR = cre_notifyReply([TermId]), 5295 CR = cre_cmdReply(NR), 5296 cre_actionReply(Cid, [CR]). 5297 5298%% mtrtaarac_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 5299%% AR = mtrtaarac_mgc_notify_reply_ar(Cid, TermId), 5300%% TRes = cre_transResult([AR]), 5301%% TR = cre_transReply(TransId, TRes), 5302%% Trans = cre_transaction(TR), 5303%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5304%% cre_megacoMessage(Mess). 5305 5306 5307%% 5308%% MG generator stuff 5309%% 5310-ifdef(megaco_hipe_special). 5311-define(mtrtaarac_mg_verify_handle_connect_fun(), 5312 {?MODULE, mtrtaarac_mg_verify_handle_connect, []}). 5313-define(mtrtaarac_mg_verify_service_change_reply_fun(), 5314 {?MODULE, mtrtaarac_mg_verify_service_change_reply, []}). 5315-define(mtrtaarac_mg_verify_notify_reply_fun(), 5316 {?MODULE, mtrtaarac_mg_verify_notify_reply, []}). 5317-else. 5318-define(mtrtaarac_mg_verify_handle_connect_fun(), 5319 fun mtrtaarac_mg_verify_handle_connect/1). 5320-define(mtrtaarac_mg_verify_service_change_reply_fun(), 5321 fun mtrtaarac_mg_verify_service_change_reply/1). 5322-define(mtrtaarac_mg_verify_notify_reply_fun(), 5323 fun mtrtaarac_mg_verify_notify_reply/1). 5324-endif. 5325 5326mtrtaarac_mg_event_sequence(text, tcp) -> 5327 Mid = {deviceName,"mg"}, 5328 RI = [ 5329 {port, 2944}, 5330 {encoding_module, megaco_pretty_text_encoder}, 5331 {encoding_config, []}, 5332 {transport_module, megaco_tcp} 5333 ], 5334 ServiceChangeReq = [mtrtaarac_mg_service_change_request_ar(Mid, 1)], 5335 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 5336 NR = fun(Cid, Rid) -> 5337 [mtrtaarac_mg_notify_request_ar(Rid, Tid, Cid)] 5338 end, 5339 ConnectVerify = ?mtrtaarac_mg_verify_handle_connect_fun(), 5340 ServiceChangeReplyVerify = ?mtrtaarac_mg_verify_service_change_reply_fun(), 5341 NotifyReplyVerify = ?mtrtaarac_mg_verify_notify_reply_fun(), 5342 EvSeq = [ 5343 {debug, true}, 5344 megaco_start, 5345 {megaco_start_user, Mid, RI, []}, 5346 start_transport, 5347 {megaco_trace, disable}, 5348 {megaco_system_info, users}, 5349 {megaco_system_info, connections}, 5350 connect, 5351 {megaco_callback, handle_connect, ConnectVerify}, 5352 megaco_connect, 5353 {megaco_cast, ServiceChangeReq, []}, 5354 {megaco_callback, handle_connect, ConnectVerify}, 5355 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 5356 {sleep, 1000}, 5357 {megaco_system_info, users}, 5358 {megaco_system_info, connections}, 5359 {sleep, 1000}, 5360 {megaco_update_conn_info, auto_ack, true}, 5361 {megaco_update_conn_info, trans_ack_maxcount, 10}, 5362 {megaco_update_conn_info, trans_req_maxcount, 4}, 5363 {megaco_update_conn_info, trans_timer, 5000}, 5364 {megaco_update_conn_info, trans_ack, true}, 5365 {megaco_update_conn_info, trans_req, true}, 5366 {megaco_conn_info, all}, 5367 {megaco_cast, NR(1,1), []}, 5368 {megaco_cast, NR(1,2), []}, 5369 {megaco_cast, NR(1,3), []}, 5370 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5371 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5372 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5373 {megaco_cast, NR(2,1), []}, 5374 {megaco_cast, NR(2,2), []}, 5375 {megaco_cast, NR(2,3), []}, 5376 {megaco_cast, NR(2,4), []}, 5377 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5378 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5379 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5380 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5381 {sleep, 3000}, 5382 megaco_stop_user, 5383 megaco_stop, 5384 {sleep, 1000} 5385 ], 5386 EvSeq. 5387 5388mtrtaarac_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 5389 io:format("mtrtaarac_mg_verify_handle_connect -> ok" 5390 "~n CH: ~p~n", [CH]), 5391 {ok, CH, ok}; 5392mtrtaarac_mg_verify_handle_connect(Else) -> 5393 io:format("mtrtaarac_mg_verify_handle_connect -> unknown" 5394 "~n Else: ~p~n", [Else]), 5395 {error, Else, ok}. 5396 5397mtrtaarac_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 5398 {ok, [AR]}, _}) -> 5399 case AR of 5400 #'ActionReply'{commandReply = [SCR]} -> 5401 case SCR of 5402 {serviceChangeReply, 5403 #'ServiceChangeReply'{terminationID = [Tid], 5404 serviceChangeResult = Res}} -> 5405 case Tid of 5406 #megaco_term_id{contains_wildcards = false, 5407 id = ["root"]} -> 5408 case Res of 5409 {serviceChangeResParms, 5410 #'ServiceChangeResParm'{ 5411 serviceChangeMgcId = _RemoteMid}} -> 5412 i("received expected handle_trans_reply " 5413 "(service change) with ok" 5414 "~n AR: ~p", [AR]), 5415 {ok, AR, ok}; 5416 {Tag, Val} -> 5417 e("received expected handle_trans_reply " 5418 "(service change) with error" 5419 "~n Tag: ~p" 5420 "~n Val: ~p", [Tag, Val]), 5421 Err = {invalid_service_change_result, 5422 Tag, Val}, 5423 {error, Err, ok} 5424 end; 5425 _ -> 5426 e("received expected handle_trans_reply " 5427 "(service change) with error" 5428 "~n Tid: ~p", [Tid]), 5429 Err = {invalid_termination_id, Tid}, 5430 {error, Err, ok} 5431 end; 5432 {Tag, Val} -> 5433 e("received expected handle_trans_reply " 5434 "(action reply) with error" 5435 "~n Tag: ~p" 5436 "~n Val: ~p", [Tag, Val]), 5437 Err = {invalid_command_reply, Tag, Val}, 5438 {error, Err, ok} 5439 end; 5440 _ -> 5441 e("received expected handle_trans_reply with error" 5442 "~n AR: ~p", [AR]), 5443 Err = {invalid_action_reply, AR}, 5444 {error, Err, ok} 5445 end; 5446mtrtaarac_mg_verify_service_change_reply(Else) -> 5447 e("mtrtaarac_mg_verify_service_change_reply -> invalid service change reply" 5448 "~n Expected: handle_trans_reply (service change) with ok" 5449 "~n Received; ~p", [Else]), 5450 {error, Else, ok}. 5451 5452mtrtaarac_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 5453 {ok, [AR]}, _}) -> 5454 i("received expected handle_notify_reply with ok" 5455 "~n AR: ~p~n", [AR]), 5456 {ok, AR, ok}; 5457mtrtaarac_mg_verify_notify_reply(Else) -> 5458 e("MG Notify Reply verification failed: invalid notify reply" 5459 "~n Expected: handle_trans_reply with ok" 5460 "~n Received: ~p", [Else]), 5461 {error, Else, ok}. 5462 5463mtrtaarac_mg_service_change_request_ar(_Mid, Cid) -> 5464 Prof = cre_serviceChangeProf("resgw", 1), 5465 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 5466 Root = #megaco_term_id{id = ["root"]}, 5467 SCR = cre_serviceChangeReq([Root], SCP), 5468 CMD = cre_command(SCR), 5469 CR = cre_cmdReq(CMD), 5470 cre_actionReq(Cid, [CR]). 5471 5472mtrtaarac_mg_notify_request_ar(Rid, Tid, Cid) -> 5473 TT = cre_timeNotation("19990729", "22000000"), 5474 Ev = cre_obsEvent("al/of", TT), 5475 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 5476 NR = cre_notifyReq([Tid], EvsDesc), 5477 CMD = cre_command(NR), 5478 CR = cre_cmdReq(CMD), 5479 cre_actionReq(Cid, [CR]). 5480 5481 5482%% 5483%% Common functions for the multi_trans_req_timeout test case 5484%% 5485 5486mtrtaarac_err_desc(T) -> 5487 EC = ?megaco_internal_gateway_error, 5488 ET = lists:flatten(io_lib:format("~w",[T])), 5489 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 5490 5491 5492%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 5493 5494multi_trans_req_and_ack_maxsize1(suite) -> 5495 []; 5496multi_trans_req_and_ack_maxsize1(doc) -> 5497 []; 5498multi_trans_req_and_ack_maxsize1(Config) when is_list(Config) -> 5499 Pre = fun() -> 5500 MgcNode = make_node_name(mgc), 5501 MgNode = make_node_name(mg), 5502 d("start nodes: " 5503 "~n MGC Node: ~p" 5504 "~n MG Node: ~p", 5505 [MgcNode, MgNode]), 5506 Nodes = [MgcNode, MgNode], 5507 ok = ?START_NODES(Nodes), 5508 Nodes 5509 end, 5510 Case = fun do_multi_trans_req_and_ack_maxsize1/1, 5511 Post = fun(Nodes) -> 5512 d("stop nodes"), 5513 ?STOP_NODES(lists:reverse(Nodes)) 5514 end, 5515 try_tc(multi_trans_req_and_ack_maxsize1, Pre, Case, Post). 5516 5517do_multi_trans_req_and_ack_maxsize1([MgcNode, MgNode]) -> 5518 5519 d("[MGC] start the simulator "), 5520 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 5521 5522 d("[MGC] create the event sequence"), 5523 MgcEvSeq = mtrtaams1_mgc_event_sequence(text, tcp), 5524 5525 i("wait some time before starting the MGC simulation"), 5526 sleep(1000), 5527 5528 d("[MGC] start the simulation"), 5529 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 5530 5531 %% i("wait some time before starting the MG simulator"), 5532 %% sleep(1000), 5533 5534 i("await MGC ready announcement"), 5535 receive 5536 announce_mgc -> 5537 i("received MGC ready announcement"), 5538 ok 5539 end, 5540 5541 d("[MG] start the simulator (generator)"), 5542 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 5543 5544 d("[MG] create the event sequence"), 5545 MgEvSeq = mtrtaams1_mg_event_sequence(text, tcp), 5546 5547 i("wait some time before starting the MG simulation"), 5548 sleep(1000), 5549 5550 d("[MG] start the simulation"), 5551 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 5552 5553 d("await the generator reply(s)"), 5554 await_completion([MgcId, MgId]), 5555 5556 %% Tell Mgc to stop 5557 i("[MGC] stop generator"), 5558 megaco_test_megaco_generator:stop(Mgc), 5559 5560 %% Tell Mg to stop 5561 i("[MG] stop generator"), 5562 megaco_test_megaco_generator:stop(Mg), 5563 5564 i("done", []), 5565 ok. 5566 5567 5568%% 5569%% MGC generator stuff 5570%% 5571-ifdef(megaco_hipe_special). 5572-define(mtrtaams1_mgc_verify_handle_connect_fun(), 5573 {?MODULE, mtrtaams1_mgc_verify_handle_connect, []}). 5574-define(mtrtaams1_mgc_verify_service_change_req_fun(Mid), 5575 {?MODULE, mtrtaams1_mgc_verify_service_change_req, [Mid]}). 5576-define(mtrtaams1_mgc_verify_notify_req_fun(), 5577 {?MODULE, mtrtaams1_mgc_verify_notify_request, []}). 5578-define(mtrtaams1_mgc_verify_ack_fun(), 5579 {?MODULE, mtrtaams1_mgc_verify_ack, []}). 5580-define(mtrtaams1_mgc_verify_handle_disconnect_fun(), 5581 {?MODULE, mtrtaams1_mgc_verify_handle_disconnect, []}). 5582-else. 5583-define(mtrtaams1_mgc_verify_handle_connect_fun(), 5584 fun mtrtaams1_mgc_verify_handle_connect/1). 5585-define(mtrtaams1_mgc_verify_service_change_req_fun(Mid), 5586 mtrtaams1_mgc_verify_service_change_req_fun(Mid)). 5587-define(mtrtaams1_mgc_verify_notify_req_fun(), 5588 mtrtaams1_mgc_verify_notify_request_fun()). 5589-define(mtrtaams1_mgc_verify_ack_fun(), 5590 fun mtrtaams1_mgc_verify_ack/1). 5591-define(mtrtaams1_mgc_verify_handle_disconnect_fun(), 5592 fun mtrtaams1_mgc_verify_handle_disconnect/1). 5593-endif. 5594 5595mtrtaams1_mgc_event_sequence(text, tcp) -> 5596 CTRL = self(), 5597 Mid = {deviceName,"ctrl"}, 5598 RI = [ 5599 {port, 2944}, 5600 {encoding_module, megaco_pretty_text_encoder}, 5601 {encoding_config, []}, 5602 {transport_module, megaco_tcp} 5603 ], 5604 ConnectVerify = ?mtrtaams1_mgc_verify_handle_connect_fun(), 5605 ServiceChangeReqVerify = ?mtrtaams1_mgc_verify_service_change_req_fun(Mid), 5606 NotifyReqVerify = ?mtrtaams1_mgc_verify_notify_req_fun(), 5607 AckVerify = ?mtrtaams1_mgc_verify_ack_fun(), 5608 DiscoVerify = ?mtrtaams1_mgc_verify_handle_disconnect_fun(), 5609 EvSeq = [ 5610 {debug, true}, 5611 {megaco_trace, disable}, 5612 megaco_start, 5613 {megaco_start_user, Mid, RI, []}, 5614 start_transport, 5615 listen, 5616 5617 %% ANNOUNCE READY 5618 {trigger, fun() -> CTRL ! announce_mgc end}, 5619 5620 {megaco_callback, handle_connect, ConnectVerify}, 5621 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 5622 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5623 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5624 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5625 {megaco_callback, handle_trans_ack, AckVerify}, 5626 {megaco_callback, handle_trans_ack, AckVerify}, 5627 {megaco_callback, handle_trans_ack, AckVerify}, 5628 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5629 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5630 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5631 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5632 {megaco_callback, handle_disconnect, DiscoVerify}, 5633 {sleep, 1000}, 5634 megaco_stop_user, 5635 megaco_stop 5636 ], 5637 EvSeq. 5638 5639 5640mtrtaams1_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 5641 io:format("mtrtaams1_mgc_verify_handle_connect -> ok" 5642 "~n CH: ~p~n", [CH]), 5643 {ok, CH, ok}; 5644mtrtaams1_mgc_verify_handle_connect(Else) -> 5645 io:format("mtrtaams1_mgc_verify_handle_connect -> unknown" 5646 "~n Else: ~p~n", [Else]), 5647 {error, Else, ok}. 5648 5649mtrtaams1_mgc_verify_service_change_req_fun(Mid) -> 5650 fun(Ev) -> 5651 mtrtaams1_mgc_verify_service_change_req(Ev, Mid) 5652 end. 5653 5654mtrtaams1_mgc_verify_service_change_req( 5655 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 5656 io:format("mtrtaams1_mgc_verify_service_change_req -> ok" 5657 "~n AR: ~p~n", [AR]), 5658 case AR of 5659 #'ActionRequest'{commandRequests = [CR]} -> 5660 case CR of 5661 #'CommandRequest'{command = Cmd} -> 5662 case Cmd of 5663 {serviceChangeReq, 5664 #'ServiceChangeRequest'{terminationID = [Tid], 5665 serviceChangeParms = Parms}} -> 5666 case Tid of 5667 #megaco_term_id{contains_wildcards = false, 5668 id = ["root"]} -> 5669 case Parms of 5670 #'ServiceChangeParm'{ 5671 serviceChangeMethod = restart, 5672 serviceChangeReason = [[$9,$0,$1|_]]} -> 5673 Reply = 5674 {discard_ack, 5675 [mtrtaams1_mgc_service_change_reply_ar(Mid, 1)]}, 5676 {ok, AR, Reply}; 5677 _ -> 5678 Err = {invalid_SCP, Parms}, 5679 ED = mtrtaams1_err_desc(Parms), 5680 ErrReply = {discard_ack, 5681 ED}, 5682 {error, Err, ErrReply} 5683 end; 5684 _ -> 5685 Err = {invalid_termination_id, Tid}, 5686 ED = mtrtaams1_err_desc(Tid), 5687 ErrReply = {discard_ack, ED}, 5688 {error, Err, ErrReply} 5689 end; 5690 _ -> 5691 Err = {invalid_command, Cmd}, 5692 ED = mtrtaams1_err_desc(Cmd), 5693 ErrReply = {discard_ack, ED}, 5694 {error, Err, ErrReply} 5695 end; 5696 _ -> 5697 Err = {invalid_command_request, CR}, 5698 ED = mtrtaams1_err_desc(CR), 5699 ErrReply = {discard_ack, ED}, 5700 {error, Err, ErrReply} 5701 end; 5702 _ -> 5703 Err = {invalid_action_request, AR}, 5704 ED = mtrtaams1_err_desc(AR), 5705 ErrReply = {discard_ack, ED}, 5706 {error, Err, ErrReply} 5707 end; 5708mtrtaams1_mgc_verify_service_change_req(Else, _Mid) -> 5709 io:format("mtrtaams1_mgc_verify_service_change_req -> unknown" 5710 "~n Else: ~p~n", [Else]), 5711 ED = mtrtaams1_err_desc(Else), 5712 ErrReply = {discard_ack, ED}, 5713 {error, Else, ErrReply}. 5714 5715mtrtaams1_mgc_verify_notify_request_fun() -> 5716 fun(Ev) -> 5717 mtrtaams1_mgc_verify_notify_request(Ev) 5718 end. 5719 5720mtrtaams1_mgc_verify_notify_request( 5721 {handle_trans_request, _, ?VERSION, [AR]}) -> 5722 io:format("mtrtaams1_mgc_verify_notify_request -> ok" 5723 "~n AR: ~p~n", [AR]), 5724 case AR of 5725 #'ActionRequest'{contextId = 1 = Cid, 5726 commandRequests = [CR]} -> 5727 #'CommandRequest'{command = Cmd} = CR, 5728 {notifyReq, NR} = Cmd, 5729 #'NotifyRequest'{terminationID = [Tid], 5730 observedEventsDescriptor = OED, 5731 errorDescriptor = asn1_NOVALUE} = NR, 5732 #'ObservedEventsDescriptor'{requestId = Rid, 5733 observedEventLst = [OE]} = OED, 5734 #'ObservedEvent'{eventName = "al/of"} = OE, 5735 HandleAck = {handle_sloppy_ack, {kalle, Rid}}, 5736 Reply = {HandleAck, 5737 [mtrtaams1_mgc_notify_reply_ar(Cid, Tid)]}, 5738 {ok, AR, Reply}; 5739 #'ActionRequest'{contextId = 2 = Cid, 5740 commandRequests = [CR]} -> 5741 #'CommandRequest'{command = Cmd} = CR, 5742 {notifyReq, NR} = Cmd, 5743 #'NotifyRequest'{terminationID = [Tid], 5744 observedEventsDescriptor = OED, 5745 errorDescriptor = asn1_NOVALUE} = NR, 5746 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 5747 #'ObservedEvent'{eventName = "al/of"} = OE, 5748 Reply = {discard_ack, [mtrtaams1_mgc_notify_reply_ar(Cid, Tid)]}, 5749 {ok, AR, Reply}; 5750 _ -> 5751 ED = mtrtaams1_err_desc(AR), 5752 ErrReply = {discard_ack, ED}, 5753 {error, AR, ErrReply} 5754 end; 5755mtrtaams1_mgc_verify_notify_request(Else) -> 5756 io:format("mtrtaams1_mgc_verify_notify_request -> unknown" 5757 "~n Else: ~p~n", [Else]), 5758 ED = mtrtaams1_err_desc(Else), 5759 ErrReply = {discard_ack, ED}, 5760 {error, Else, ErrReply}. 5761 5762mtrtaams1_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, 5763 {kalle, Rid}}) -> 5764 io:format("mtrtaams1_mgc_verify_ack -> ok" 5765 "~n CH: ~p" 5766 "~n Rid: ~p" 5767 "~n", [CH, Rid]), 5768 {ok, CH, ok}; 5769mtrtaams1_mgc_verify_ack(Else) -> 5770 io:format("mtrtaams1_mgc_verify_ack -> unknown" 5771 "~n Else: ~p~n", [Else]), 5772 {error, Else, ok}. 5773 5774mtrtaams1_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 5775 io:format("mtrtaams1_mgc_verify_handle_disconnect -> ok" 5776 "~n CH: ~p" 5777 "~n R: ~p" 5778 "~n", [CH, R]), 5779 {ok, CH, ok}; 5780mtrtaams1_mgc_verify_handle_disconnect(Else) -> 5781 io:format("mtrtaams1_mgc_verify_handle_disconnect -> unknown" 5782 "~n Else: ~p~n", [Else]), 5783 {error, Else, ok}. 5784 5785 5786mtrtaams1_mgc_service_change_reply_ar(Mid, Cid) -> 5787 SCRP = cre_serviceChangeResParm(Mid), 5788 SCRes = cre_serviceChangeResult(SCRP), 5789 Root = #megaco_term_id{id = ["root"]}, 5790 SCR = cre_serviceChangeReply([Root], SCRes), 5791 CR = cre_cmdReply(SCR), 5792 cre_actionReply(Cid, [CR]). 5793 5794%% mtrtaams1_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 5795%% AR = mtrtaams1_mgc_service_change_reply_ar(Mid, Cid), 5796%% TRes = cre_transResult([AR]), 5797%% TR = cre_transReply(TransId, TRes), 5798%% Trans = cre_transaction(TR), 5799%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5800%% cre_megacoMessage(Mess). 5801 5802mtrtaams1_mgc_notify_reply_ar(Cid, TermId) -> 5803 NR = cre_notifyReply([TermId]), 5804 CR = cre_cmdReply(NR), 5805 cre_actionReply(Cid, [CR]). 5806 5807%% mtrtaams1_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 5808%% AR = mtrtaams1_mgc_notify_reply_ar(Cid, TermId), 5809%% TRes = cre_transResult([AR]), 5810%% TR = cre_transReply(TransId, TRes), 5811%% Trans = cre_transaction(TR), 5812%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5813%% cre_megacoMessage(Mess). 5814 5815 5816%% 5817%% MG generator stuff 5818%% 5819-ifdef(megaco_hipe_special). 5820-define(mtrtaams1_mg_verify_handle_connect_fun(), 5821 {?MODULE, mtrtaams1_mg_verify_handle_connect, []}). 5822-define(mtrtaams1_mg_verify_service_change_reply_fun(), 5823 {?MODULE, mtrtaams1_mg_verify_service_change_reply, []}). 5824-define(mtrtaams1_mg_verify_notify_reply_fun(), 5825 {?MODULE, mtrtaams1_mg_verify_notify_reply, []}). 5826-else. 5827-define(mtrtaams1_mg_verify_handle_connect_fun(), 5828 fun mtrtaams1_mg_verify_handle_connect/1). 5829-define(mtrtaams1_mg_verify_service_change_reply_fun(), 5830 fun mtrtaams1_mg_verify_service_change_reply/1). 5831-define(mtrtaams1_mg_verify_notify_reply_fun(), 5832 fun mtrtaams1_mg_verify_notify_reply/1). 5833-endif. 5834 5835mtrtaams1_mg_event_sequence(text, tcp) -> 5836 Mid = {deviceName,"mg"}, 5837 RI = [ 5838 {port, 2944}, 5839 {encoding_module, megaco_pretty_text_encoder}, 5840 {encoding_config, []}, 5841 {transport_module, megaco_tcp} 5842 ], 5843 ServiceChangeReq = [mtrtaams1_mg_service_change_request_ar(Mid, 1)], 5844 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 5845 NR = fun(Cid, Rid) -> 5846 [mtrtaams1_mg_notify_request_ar(Rid, Tid, Cid)] 5847 end, 5848 ConnectVerify = ?mtrtaams1_mg_verify_handle_connect_fun(), 5849 ServiceChangeReplyVerify = ?mtrtaams1_mg_verify_service_change_reply_fun(), 5850 NotifyReplyVerify = ?mtrtaams1_mg_verify_notify_reply_fun(), 5851 EvSeq = [ 5852 {debug, true}, 5853 megaco_start, 5854 {megaco_start_user, Mid, RI, []}, 5855 start_transport, 5856 {megaco_trace, disable}, 5857 {megaco_system_info, users}, 5858 {megaco_system_info, connections}, 5859 connect, 5860 {megaco_callback, handle_connect, ConnectVerify}, 5861 megaco_connect, 5862 {megaco_cast, ServiceChangeReq, []}, 5863 {megaco_callback, handle_connect, ConnectVerify}, 5864 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 5865 {sleep, 1000}, 5866 {megaco_system_info, users}, 5867 {megaco_system_info, connections}, 5868 {sleep, 1000}, 5869 {megaco_update_conn_info, auto_ack, true}, 5870 {megaco_update_conn_info, trans_ack_maxcount, 10}, 5871 {megaco_update_conn_info, trans_req_maxcount, 10}, 5872 {megaco_update_conn_info, trans_req_maxsize, 650}, 5873 {megaco_update_conn_info, trans_timer, 5000}, 5874 {megaco_update_conn_info, trans_ack, true}, 5875 {megaco_update_conn_info, trans_req, true}, 5876 {megaco_conn_info, all}, 5877 {megaco_cast, [NR(1,2), NR(1,3), NR(1,4)], []}, 5878 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5879 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5880 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5881 {megaco_cast, NR(2,1), []}, 5882 {megaco_cast, NR(2,2), []}, 5883 {megaco_cast, NR(2,3), []}, 5884 {megaco_cast, NR(2,4), []}, 5885 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5886 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5887 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5888 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5889 {sleep, 3000}, 5890 megaco_stop_user, 5891 megaco_stop, 5892 {sleep, 1000} 5893 ], 5894 EvSeq. 5895 5896mtrtaams1_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 5897 io:format("mtrtaams1_mg_verify_handle_connect -> ok" 5898 "~n CH: ~p~n", [CH]), 5899 {ok, CH, ok}; 5900mtrtaams1_mg_verify_handle_connect(Else) -> 5901 io:format("mtrtaams1_mg_verify_handle_connect -> unknown" 5902 "~n Else: ~p~n", [Else]), 5903 {error, Else, ok}. 5904 5905mtrtaams1_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 5906 {ok, [AR]}, _}) -> 5907 io:format("mtrtaams1_mg_verify_service_change_reply -> ok" 5908 "~n AR: ~p~n", [AR]), 5909 case AR of 5910 #'ActionReply'{commandReply = [SCR]} -> 5911 case SCR of 5912 {serviceChangeReply, 5913 #'ServiceChangeReply'{terminationID = [Tid], 5914 serviceChangeResult = Res}} -> 5915 case Tid of 5916 #megaco_term_id{contains_wildcards = false, 5917 id = ["root"]} -> 5918 case Res of 5919 {serviceChangeResParms, 5920 #'ServiceChangeResParm'{ 5921 serviceChangeMgcId = _RemoteMid}} -> 5922 {ok, AR, ok}; 5923 {Tag, Val} -> 5924 Err = {invalid_service_change_result, 5925 Tag, Val}, 5926 {error, Err, ok} 5927 end; 5928 _ -> 5929 Err = {invalid_termination_id, Tid}, 5930 {error, Err, ok} 5931 end; 5932 {Tag, Val} -> 5933 Err = {invalid_command_reply, Tag, Val}, 5934 {error, Err, ok} 5935 end; 5936 _ -> 5937 Err = {invalid_action_reply, AR}, 5938 {error, Err, ok} 5939 end; 5940mtrtaams1_mg_verify_service_change_reply(Else) -> 5941 io:format("mtrtaams1_mg_verify_service_change_reply -> unknown" 5942 "~n Else: ~p~n", [Else]), 5943 {error, Else, ok}. 5944 5945mtrtaams1_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 5946 {ok, [AR]}, _}) -> 5947 io:format("mtrtaams1_mg_verify_notify_reply -> ok" 5948 "~n AR: ~p~n", [AR]), 5949 {ok, AR, ok}; 5950mtrtaams1_mg_verify_notify_reply(Else) -> 5951 io:format("mtrtaams1_mg_verify_notify_reply -> unknown" 5952 "~n Else: ~p~n", [Else]), 5953 {error, Else, ok}. 5954 5955mtrtaams1_mg_service_change_request_ar(_Mid, Cid) -> 5956 Prof = cre_serviceChangeProf("resgw", 1), 5957 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 5958 Root = #megaco_term_id{id = ["root"]}, 5959 SCR = cre_serviceChangeReq([Root], SCP), 5960 CMD = cre_command(SCR), 5961 CR = cre_cmdReq(CMD), 5962 cre_actionReq(Cid, [CR]). 5963 5964%% mtrtaams1_mg_service_change_request_msg(Mid, TransId, Cid) -> 5965%% AR = mtrtaams1_mg_service_change_request_ar(Mid, Cid), 5966%% TR = cre_transReq(TransId, [AR]), 5967%% Trans = cre_transaction(TR), 5968%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5969%% cre_megacoMessage(Mess). 5970 5971mtrtaams1_mg_notify_request_ar(Rid, Tid, Cid) -> 5972 TT = cre_timeNotation("19990729", "22000000"), 5973 Ev = cre_obsEvent("al/of", TT), 5974 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 5975 NR = cre_notifyReq([Tid], EvsDesc), 5976 CMD = cre_command(NR), 5977 CR = cre_cmdReq(CMD), 5978 cre_actionReq(Cid, [CR]). 5979 5980%% mtrtaams1_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 5981%% AR = mtrtaams1_mg_notify_request_ar(Rid, TermId, Cid), 5982%% TR = cre_transReq(TransId, [AR]), 5983%% Trans = cre_transaction(TR), 5984%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5985%% cre_megacoMessage(Mess). 5986 5987 5988%% 5989%% Common functions for the multi_trans_req_timeout test case 5990%% 5991 5992mtrtaams1_err_desc(T) -> 5993 cre_ErrDesc(T). 5994 5995 5996%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 5997 5998multi_trans_req_and_ack_maxsize2(suite) -> 5999 []; 6000multi_trans_req_and_ack_maxsize2(doc) -> 6001 []; 6002multi_trans_req_and_ack_maxsize2(Config) when is_list(Config) -> 6003 Pre = fun() -> 6004 MgcNode = make_node_name(mgc), 6005 MgNode = make_node_name(mg), 6006 d("start nodes: " 6007 "~n MGC Node: ~p" 6008 "~n MG Node: ~p", 6009 [MgcNode, MgNode]), 6010 Nodes = [MgcNode, MgNode], 6011 ok = ?START_NODES(Nodes), 6012 Nodes 6013 end, 6014 Case = fun do_multi_trans_req_and_ack_maxsize2/1, 6015 Post = fun(Nodes) -> 6016 d("stop nodes"), 6017 ?STOP_NODES(lists:reverse(Nodes)) 6018 end, 6019 try_tc(multi_trans_req_and_ack_maxsize2, Pre, Case, Post). 6020 6021do_multi_trans_req_and_ack_maxsize2([MgcNode, MgNode]) -> 6022 6023 d("[MGC] start the simulator "), 6024 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 6025 6026 d("[MGC] create the event sequence"), 6027 MgcEvSeq = mtrtaams2_mgc_event_sequence(text, tcp), 6028 6029 i("wait some time before starting the MGC simulation"), 6030 sleep(1000), 6031 6032 d("[MGC] start the simulation"), 6033 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 6034 6035 %% i("wait some time before starting the MG simulator"), 6036 %% sleep(1000), 6037 6038 i("await MGC ready announcement"), 6039 receive 6040 announce_mgc -> 6041 i("received MGC ready announcement"), 6042 ok 6043 end, 6044 6045 d("[MG] start the simulator (generator)"), 6046 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 6047 6048 d("[MG] create the event sequence"), 6049 MgEvSeq = mtrtaams2_mg_event_sequence(text, tcp), 6050 6051 i("wait some time before starting the MG simulation"), 6052 sleep(1000), 6053 6054 d("[MG] start the simulation"), 6055 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 6056 6057 d("await the generator reply(s)"), 6058 await_completion([MgcId, MgId]), 6059 6060 %% Tell Mgc to stop 6061 i("[MGC] stop generator"), 6062 megaco_test_megaco_generator:stop(Mgc), 6063 6064 %% Tell Mg to stop 6065 i("[MG] stop generator"), 6066 megaco_test_megaco_generator:stop(Mg), 6067 6068 i("done", []), 6069 ok. 6070 6071 6072%% 6073%% MGC generator stuff 6074%% 6075-ifdef(megaco_hipe_special). 6076-define(mtrtaams2_mgc_verify_handle_connect_fun(), 6077 {?MODULE, mtrtaams2_mgc_verify_handle_connect, []}). 6078-define(mtrtaams2_mgc_verify_service_change_req_fun(Mid), 6079 {?MODULE, mtrtaams2_mgc_verify_service_change_req, [Mid]}). 6080-define(mtrtaams2_mgc_verify_notify_req_fun(), 6081 {?MODULE, mtrtaams2_mgc_verify_notify_request, []}). 6082-define(mtrtaams2_mgc_verify_ack_fun(), 6083 {?MODULE, mtrtaams2_mgc_verify_ack, []}). 6084-define(mtrtaams2_mgc_verify_handle_disconnect_fun(), 6085 {?MODULE, mtrtaams2_mgc_verify_handle_disconnect, []}). 6086-else. 6087-define(mtrtaams2_mgc_verify_handle_connect_fun(), 6088 fun mtrtaams2_mgc_verify_handle_connect/1). 6089-define(mtrtaams2_mgc_verify_service_change_req_fun(Mid), 6090 mtrtaams2_mgc_verify_service_change_req_fun(Mid)). 6091-define(mtrtaams2_mgc_verify_notify_req_fun(), 6092 mtrtaams2_mgc_verify_notify_request_fun()). 6093-define(mtrtaams2_mgc_verify_ack_fun(), 6094 fun mtrtaams2_mgc_verify_ack/1). 6095-define(mtrtaams2_mgc_verify_handle_disconnect_fun(), 6096 fun mtrtaams2_mgc_verify_handle_disconnect/1). 6097-endif. 6098 6099mtrtaams2_mgc_event_sequence(text, tcp) -> 6100 CTRL = self(), 6101 Mid = {deviceName,"ctrl"}, 6102 RI = [ 6103 {port, 2944}, 6104 {encoding_module, megaco_pretty_text_encoder}, 6105 {encoding_config, []}, 6106 {transport_module, megaco_tcp} 6107 ], 6108 ConnectVerify = ?mtrtaams2_mgc_verify_handle_connect_fun(), 6109 ServiceChangeReqVerify = ?mtrtaams2_mgc_verify_service_change_req_fun(Mid), 6110 NotifyReqVerify = ?mtrtaams2_mgc_verify_notify_req_fun(), 6111 AckVerify = ?mtrtaams2_mgc_verify_ack_fun(), 6112 DiscoVerify = ?mtrtaams2_mgc_verify_handle_disconnect_fun(), 6113 EvSeq = [ 6114 {debug, true}, 6115 {megaco_trace, disable}, 6116 megaco_start, 6117 {megaco_start_user, Mid, RI, []}, 6118 start_transport, 6119 {listen, [{serialize, true}]}, 6120 6121 %% ANNOUNCE READY 6122 {trigger, fun() -> CTRL ! announce_mgc end}, 6123 6124 {megaco_callback, handle_connect, ConnectVerify}, 6125 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 6126 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6127 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6128 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6129 {megaco_callback, handle_trans_ack, AckVerify}, 6130 {megaco_callback, handle_trans_ack, AckVerify}, 6131 {megaco_callback, handle_trans_ack, AckVerify}, 6132 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6133 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6134 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6135 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6136 {megaco_callback, handle_disconnect, DiscoVerify}, 6137 {sleep, 1000}, 6138 megaco_stop_user, 6139 megaco_stop 6140 ], 6141 EvSeq. 6142 6143 6144mtrtaams2_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 6145 p("mtrtaams2_mgc_verify_handle_connect -> ok" 6146 "~n CH: ~p", [CH]), 6147 {ok, CH, ok}; 6148mtrtaams2_mgc_verify_handle_connect(Else) -> 6149 p("mtrtaams2_mgc_verify_handle_connect -> unknown" 6150 "~n Else: ~p", [Else]), 6151 {error, Else, ok}. 6152 6153mtrtaams2_mgc_verify_service_change_req_fun(Mid) -> 6154 fun(Ev) -> 6155 mtrtaams2_mgc_verify_service_change_req(Ev, Mid) 6156 end. 6157 6158mtrtaams2_mgc_verify_service_change_req( 6159 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 6160 p("mtrtaams2_mgc_verify_service_change_req -> ok" 6161 "~n AR: ~p", [AR]), 6162 case AR of 6163 #'ActionRequest'{commandRequests = [CR]} -> 6164 case CR of 6165 #'CommandRequest'{command = Cmd} -> 6166 case Cmd of 6167 {serviceChangeReq, 6168 #'ServiceChangeRequest'{terminationID = [Tid], 6169 serviceChangeParms = Parms}} -> 6170 case Tid of 6171 #megaco_term_id{contains_wildcards = false, 6172 id = ["root"]} -> 6173 case Parms of 6174 #'ServiceChangeParm'{ 6175 serviceChangeMethod = restart, 6176 serviceChangeReason = [[$9,$0,$1|_]]} -> 6177 Reply = 6178 {discard_ack, 6179 [mtrtaams2_mgc_service_change_reply_ar(Mid, 1)]}, 6180 {ok, AR, Reply}; 6181 _ -> 6182 Err = {invalid_SCP, Parms}, 6183 ED = mtrtaams2_err_desc(Parms), 6184 ErrReply = {discard_ack, 6185 ED}, 6186 {error, Err, ErrReply} 6187 end; 6188 _ -> 6189 Err = {invalid_termination_id, Tid}, 6190 ED = mtrtaams2_err_desc(Tid), 6191 ErrReply = {discard_ack, ED}, 6192 {error, Err, ErrReply} 6193 end; 6194 _ -> 6195 Err = {invalid_command, Cmd}, 6196 ED = mtrtaams2_err_desc(Cmd), 6197 ErrReply = {discard_ack, ED}, 6198 {error, Err, ErrReply} 6199 end; 6200 _ -> 6201 Err = {invalid_command_request, CR}, 6202 ED = mtrtaams2_err_desc(CR), 6203 ErrReply = {discard_ack, ED}, 6204 {error, Err, ErrReply} 6205 end; 6206 _ -> 6207 Err = {invalid_action_request, AR}, 6208 ED = mtrtaams2_err_desc(AR), 6209 ErrReply = {discard_ack, ED}, 6210 {error, Err, ErrReply} 6211 end; 6212mtrtaams2_mgc_verify_service_change_req(Else, _Min) -> 6213 p("mtrtaams2_mgc_verify_service_change_req -> unknown" 6214 "~n Else: ~p", [Else]), 6215 ED = mtrtaams2_err_desc(Else), 6216 ErrReply = {discard_ack, ED}, 6217 {error, Else, ErrReply}. 6218 6219mtrtaams2_mgc_verify_notify_request_fun() -> 6220 fun(Ev) -> 6221 mtrtaams2_mgc_verify_notify_request(Ev) 6222 end. 6223 6224mtrtaams2_mgc_verify_notify_request( 6225 {handle_trans_request, _, ?VERSION, [AR]}) -> 6226 p("mtrtaams2_mgc_verify_notify_request:fun -> ok" 6227 "~n AR: ~p", [AR]), 6228 case AR of 6229 #'ActionRequest'{contextId = 1 = Cid, 6230 commandRequests = [CR]} -> 6231 p("mtrtaams2_mgc_verify_notify_request:fun -> " 6232 "single command", []), 6233 #'CommandRequest'{command = Cmd} = CR, 6234 {notifyReq, NR} = Cmd, 6235 #'NotifyRequest'{terminationID = [Tid], 6236 observedEventsDescriptor = OED, 6237 errorDescriptor = asn1_NOVALUE} = NR, 6238 #'ObservedEventsDescriptor'{requestId = Rid, 6239 observedEventLst = [OE]} = OED, 6240 #'ObservedEvent'{eventName = "al/of"} = OE, 6241 HandleAck = {handle_sloppy_ack, {kalle, Rid}}, 6242 Reply = {HandleAck, 6243 [mtrtaams2_mgc_notify_reply_ar1(Cid, Tid)]}, 6244 {ok, AR, Reply}; 6245 #'ActionRequest'{contextId = 2 = Cid, 6246 commandRequests = CRs} -> 6247 p("mtrtaams2_mgc_verify_notify_request:fun -> " 6248 "multi command (~w)", [length(CRs)]), 6249 Tids = [Tid || 6250 #'CommandRequest'{command = 6251 {notifyReq, 6252 #'NotifyRequest'{ 6253 terminationID = [Tid]}}} 6254 <- CRs], 6255 Reply = 6256 {discard_ack, 6257 [mtrtaams2_mgc_notify_reply_ar2(Cid, Tids)]}, 6258 {ok, AR, Reply}; 6259 _ -> 6260 ED = mtrtaams2_err_desc(AR), 6261 ErrReply = {discard_ack, ED}, 6262 {error, AR, ErrReply} 6263 end; 6264mtrtaams2_mgc_verify_notify_request(Else) -> 6265 p("mtrtaams2_mgc_verify_notify_request:fun -> unknown" 6266 "~n Else: ~p", [Else]), 6267 ED = mtrtaams2_err_desc(Else), 6268 ErrReply = {discard_ack, ED}, 6269 {error, Else, ErrReply}. 6270 6271mtrtaams2_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, 6272 {kalle, Rid}}) -> 6273 p("mtrtaams2_mgc_verify_ack -> ok" 6274 "~n CH: ~p" 6275 "~n Rid: ~p", [CH, Rid]), 6276 {ok, CH, ok}; 6277mtrtaams2_mgc_verify_ack(Else) -> 6278 p("mtrtaams2_mgc_verify_ack -> Else: " 6279 "~n~p", [Else]), 6280 {error, Else, ok}. 6281 6282mtrtaams2_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 6283 p("mtrtaams2_mgc_verify_handle_disconnect -> ok" 6284 "~n CH: ~p" 6285 "~n R: ~p", [CH, R]), 6286 {ok, CH, ok}; 6287mtrtaams2_mgc_verify_handle_disconnect(Else) -> 6288 p("mtrtaams2_mgc_verify_handle_disconnect -> unknown" 6289 "~n Else: ~p", [Else]), 6290 {error, Else, ok}. 6291 6292 6293mtrtaams2_mgc_service_change_reply_ar(Mid, Cid) -> 6294 SCRP = cre_serviceChangeResParm(Mid), 6295 SCRes = cre_serviceChangeResult(SCRP), 6296 Root = #megaco_term_id{id = ["root"]}, 6297 SCR = cre_serviceChangeReply([Root], SCRes), 6298 CR = cre_cmdReply(SCR), 6299 cre_actionReply(Cid, [CR]). 6300 6301%% mtrtaams2_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 6302%% AR = mtrtaams2_mgc_service_change_reply_ar(Mid, Cid), 6303%% TRes = cre_transResult([AR]), 6304%% TR = cre_transReply(TransId, TRes), 6305%% Trans = cre_transaction(TR), 6306%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6307%% cre_megacoMessage(Mess). 6308 6309mtrtaams2_mgc_notify_reply_ar1(Cid, TermId) -> 6310 NR = cre_notifyReply([TermId]), 6311 CR = cre_cmdReply(NR), 6312 cre_actionReply(Cid, [CR]). 6313 6314mtrtaams2_mgc_notify_reply_ar2(Cid, Tids) -> 6315 CRs = [cre_cmdReply(cre_notifyReply([Tid])) || Tid <- Tids], 6316 cre_actionReply(Cid, CRs). 6317 6318%% mtrtaams2_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 6319%% AR = mtrtaams2_mgc_notify_reply_ar1(Cid, TermId), 6320%% TRes = cre_transResult([AR]), 6321%% TR = cre_transReply(TransId, TRes), 6322%% Trans = cre_transaction(TR), 6323%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6324%% cre_megacoMessage(Mess). 6325 6326 6327%% 6328%% MG generator stuff 6329%% 6330-ifdef(megaco_hipe_special). 6331-define(mtrtaams2_mg_verify_handle_connect_fun(), 6332 {?MODULE, mtrtaams2_mg_verify_handle_connect, []}). 6333-define(mtrtaams2_mg_verify_service_change_reply_fun(), 6334 {?MODULE, mtrtaams2_mg_verify_service_change_reply, []}). 6335-define(mtrtaams2_mg_verify_notify_reply_fun(), 6336 {?MODULE, mtrtaams2_mg_verify_notify_reply, []}). 6337-else. 6338-define(mtrtaams2_mg_verify_handle_connect_fun(), 6339 fun mtrtaams2_mg_verify_handle_connect/1). 6340-define(mtrtaams2_mg_verify_service_change_reply_fun(), 6341 fun mtrtaams2_mg_verify_service_change_reply/1). 6342-define(mtrtaams2_mg_verify_notify_reply_fun(), 6343 fun mtrtaams2_mg_verify_notify_reply/1). 6344-endif. 6345 6346mtrtaams2_mg_event_sequence(text, tcp) -> 6347 Mid = {deviceName,"mg"}, 6348 RI = [ 6349 {port, 2944}, 6350 {encoding_module, megaco_pretty_text_encoder}, 6351 {encoding_config, []}, 6352 {transport_module, megaco_tcp} 6353 ], 6354 ServiceChangeReq = [mtrtaams2_mg_service_change_request_ar(Mid, 1)], 6355 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 6356 NR1 = fun(Cid, Rid) -> 6357 [mtrtaams2_mg_notify_request_ar1(10 + Rid, Tid, Cid)] 6358 end, 6359 NR2 = fun(Cid, Rid) -> 6360 [mtrtaams2_mg_notify_request_ar2(20 + Rid, Tid, Cid)] 6361 end, 6362 ConnectVerify = ?mtrtaams2_mg_verify_handle_connect_fun(), 6363 ServiceChangeReplyVerify = ?mtrtaams2_mg_verify_service_change_reply_fun(), 6364 NotifyReplyVerify = ?mtrtaams2_mg_verify_notify_reply_fun(), 6365 EvSeq = [ 6366 {debug, true}, 6367 megaco_start, 6368 {megaco_start_user, Mid, RI, []}, 6369 start_transport, 6370 {megaco_trace, disable}, 6371 {megaco_system_info, users}, 6372 {megaco_system_info, connections}, 6373 {connect, [{serialize, true}]}, 6374 {megaco_callback, handle_connect, ConnectVerify}, 6375 megaco_connect, 6376 {megaco_cast, ServiceChangeReq, []}, 6377 {megaco_callback, handle_connect, ConnectVerify}, 6378 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 6379 {sleep, 1000}, 6380 {megaco_system_info, users}, 6381 {megaco_system_info, connections}, 6382 {sleep, 1000}, 6383 {megaco_update_conn_info, auto_ack, true}, 6384 {megaco_update_conn_info, trans_ack_maxcount, 10}, 6385 {megaco_update_conn_info, trans_req_maxcount, 10}, 6386 {megaco_update_conn_info, trans_req_maxsize, 1024}, 6387 {megaco_update_conn_info, trans_timer, 5000}, 6388 {megaco_update_conn_info, trans_ack, true}, 6389 {megaco_update_conn_info, trans_req, true}, 6390 {megaco_conn_info, all}, 6391 {megaco_cast, [NR1(1,2), NR1(1,3), NR1(1,4)], []}, 6392 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6393 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6394 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6395 {megaco_cast, [NR1(2,5), NR1(2,6), NR1(2,7)], []}, 6396 {megaco_cast, NR2(2,1), []}, 6397 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6398 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6399 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6400 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6401 {sleep, 3000}, 6402 megaco_stop_user, 6403 megaco_stop, 6404 {sleep, 1000} 6405 ], 6406 EvSeq. 6407 6408mtrtaams2_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 6409 p("mtrtaams2_mg_verify_handle_connect -> ok" 6410 "~n CH: ~p", [CH]), 6411 {ok, CH, ok}; 6412mtrtaams2_mg_verify_handle_connect(Else) -> 6413 p("mtrtaams2_mg_verify_handle_connect -> unknown" 6414 "~n Else: ~p", [Else]), 6415 {error, Else, ok}. 6416 6417mtrtaams2_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 6418 {ok, [AR]}, _}) -> 6419 p("mtrtaams2_mg_verify_service_change_reply -> ok" 6420 "~n AR: ~p", [AR]), 6421 case AR of 6422 #'ActionReply'{commandReply = [SCR]} -> 6423 case SCR of 6424 {serviceChangeReply, 6425 #'ServiceChangeReply'{terminationID = [Tid], 6426 serviceChangeResult = Res}} -> 6427 case Tid of 6428 #megaco_term_id{contains_wildcards = false, 6429 id = ["root"]} -> 6430 case Res of 6431 {serviceChangeResParms, 6432 #'ServiceChangeResParm'{ 6433 serviceChangeMgcId = _RemoteMid}} -> 6434 {ok, AR, ok}; 6435 {Tag, Val} -> 6436 Err = {invalid_service_change_result, 6437 Tag, Val}, 6438 {error, Err, ok} 6439 end; 6440 _ -> 6441 Err = {invalid_termination_id, Tid}, 6442 {error, Err, ok} 6443 end; 6444 {Tag, Val} -> 6445 Err = {invalid_command_reply, Tag, Val}, 6446 {error, Err, ok} 6447 end; 6448 _ -> 6449 Err = {invalid_action_reply, AR}, 6450 {error, Err, ok} 6451 end; 6452mtrtaams2_mg_verify_service_change_reply(Else) -> 6453 p("mtrtaams2_mg_verify_service_change_reply -> unknown" 6454 "~n Else: ~p", [Else]), 6455 {error, Else, ok}. 6456 6457mtrtaams2_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 6458 {ok, [AR]}, _}) -> 6459 p("mtrtaams2_mg_verify_notify_reply -> ok" 6460 "~n AR: ~p", [AR]), 6461 {ok, AR, ok}; 6462mtrtaams2_mg_verify_notify_reply(Else) -> 6463 p("mtrtaams2_mg_verify_notify_reply -> unknown" 6464 "~n Else: ~p", [Else]), 6465 {error, Else, ok}. 6466 6467mtrtaams2_mg_service_change_request_ar(_Mid, Cid) -> 6468 Prof = cre_serviceChangeProf("resgw", 1), 6469 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 6470 Root = #megaco_term_id{id = ["root"]}, 6471 SCR = cre_serviceChangeReq([Root], SCP), 6472 CMD = cre_command(SCR), 6473 CR = cre_cmdReq(CMD), 6474 cre_actionReq(Cid, [CR]). 6475 6476%% mtrtaams2_mg_service_change_request_msg(Mid, TransId, Cid) -> 6477%% AR = mtrtaams2_mg_service_change_request_ar(Mid, Cid), 6478%% TR = cre_transReq(TransId, [AR]), 6479%% Trans = cre_transaction(TR), 6480%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6481%% cre_megacoMessage(Mess). 6482 6483mtrtaams2_mg_notify_request_ar1(Rid, Tid, Cid) -> 6484 TT = cre_timeNotation("19990729", "22000000"), 6485 Ev = cre_obsEvent("al/of", TT), 6486 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 6487 NR = cre_notifyReq([Tid], EvsDesc), 6488 CMD = cre_command(NR), 6489 CR = cre_cmdReq(CMD), 6490 cre_actionReq(Cid, [CR]). 6491 6492mtrtaams2_mg_notify_request_ar2(Rid, Tid, Cid) -> 6493 F = fun(N) -> 6494 T = 22000000 + N, 6495 TS = integer_to_list(T), 6496 TT = cre_timeNotation("19990729", TS), 6497 Ev = cre_obsEvent("al/of", TT), 6498 EvsDesc = cre_obsEvsDesc(Rid+N, [Ev]), 6499 NR = cre_notifyReq([Tid], EvsDesc), 6500 CMD = cre_command(NR), 6501 cre_cmdReq(CMD) 6502 end, 6503 Ns = [0,1,2,3,4,5,6,7,8,9], 6504 CRs = [F(N) || N <- Ns], 6505 cre_actionReq(Cid, CRs). 6506 6507%% mtrtaams2_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 6508%% AR = mtrtaams2_mg_notify_request_ar1(Rid, TermId, Cid), 6509%% TR = cre_transReq(TransId, [AR]), 6510%% Trans = cre_transaction(TR), 6511%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6512%% cre_megacoMessage(Mess). 6513 6514 6515%% 6516%% Common functions for the multi_trans_req_timeout test case 6517%% 6518 6519mtrtaams2_err_desc(T) -> 6520 cre_ErrDesc(T). 6521 6522 6523%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 6524 6525single_trans_req_and_pending(suite) -> 6526 []; 6527single_trans_req_and_pending(doc) -> 6528 []; 6529single_trans_req_and_pending(Config) when is_list(Config) -> 6530 ?SKIP(not_yet_implemented). 6531 6532 6533%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 6534 6535multi_trans_req_and_pending(suite) -> 6536 []; 6537multi_trans_req_and_pending(doc) -> 6538 []; 6539multi_trans_req_and_pending(Config) when is_list(Config) -> 6540 ?SKIP(not_yet_implemented). 6541 6542 6543%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 6544 6545multi_trans_req_and_ack_and_pending(suite) -> 6546 []; 6547multi_trans_req_and_ack_and_pending(doc) -> 6548 []; 6549multi_trans_req_and_ack_and_pending(Config) when is_list(Config) -> 6550 Pre = fun() -> 6551 MgcNode = make_node_name(mgc), 6552 MgNode = make_node_name(mg), 6553 d("start nodes: " 6554 "~n MGC Node: ~p" 6555 "~n MG Node: ~p", 6556 [MgcNode, MgNode]), 6557 Nodes = [MgcNode, MgNode], 6558 ok = ?START_NODES(Nodes), 6559 Nodes 6560 end, 6561 Case = fun do_multi_trans_req_and_ack_and_pending/1, 6562 Post = fun(Nodes) -> 6563 d("stop nodes"), 6564 ?STOP_NODES(lists:reverse(Nodes)) 6565 end, 6566 try_tc(mtraaap, Pre, Case, Post). 6567 6568do_multi_trans_req_and_ack_and_pending([MgcNode, MgNode]) -> 6569 6570 d("[MGC] start the simulator "), 6571 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 6572 6573 d("[MGC] create the event sequence"), 6574 MgcEvSeq = mtraaap_mgc_event_sequence(text, tcp), 6575 6576 i("wait some time before starting the MGC simulation"), 6577 sleep(1000), 6578 6579 d("[MGC] start the simulation"), 6580 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 6581 6582 %% i("wait some time before starting the MG simulator"), 6583 %% sleep(1000), 6584 6585 i("await MGC ready announcement"), 6586 receive 6587 announce_mgc -> 6588 i("received MGC ready announcement"), 6589 ok 6590 end, 6591 6592 d("[MG] start the simulator (generator)"), 6593 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 6594 6595 d("[MG] create the event sequence"), 6596 MgEvSeq = mtraaap_mg_event_sequence(text, tcp), 6597 6598 i("wait some time before starting the MG simulation"), 6599 sleep(1000), 6600 6601 d("[MG] start the simulation"), 6602 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 6603 6604 d("await the generator reply(s)"), 6605 await_completion([MgcId, MgId]), 6606 6607 %% Tell Mgc to stop 6608 i("[MGC] stop generator"), 6609 megaco_test_megaco_generator:stop(Mgc), 6610 6611 %% Tell Mg to stop 6612 i("[MG] stop generator"), 6613 megaco_test_megaco_generator:stop(Mg), 6614 6615 i("done", []), 6616 ok. 6617 6618 6619%% 6620%% MGC generator stuff 6621%% 6622-ifdef(megaco_hipe_special). 6623-define(mtraaap_mgc_verify_handle_connect_fun(), 6624 {?MODULE, mtraaap_mgc_verify_handle_connect, []}). 6625-define(mtraaap_mgc_verify_service_change_req_fun(Mid), 6626 {?MODULE, mtraaap_mgc_verify_service_change_req, [Mid]}). 6627-define(mtraaap_mgc_verify_notify_req_fun(), 6628 {?MODULE, mtraaap_mgc_verify_notify_request, []}). 6629-define(mtraaap_mgc_verify_notify_reply_fun(), 6630 {?MODULE, mtraaap_mgc_verify_notify_reply, []}). 6631-define(mtraaap_mgc_verify_ack_fun(), 6632 {?MODULE, mtraaap_mgc_verify_ack, []}). 6633-define(mtraaap_mgc_verify_handle_disconnect_fun(), 6634 {?MODULE, mtraaap_mgc_verify_handle_disconnect, []}). 6635-else. 6636-define(mtraaap_mgc_verify_handle_connect_fun(), 6637 fun mtraaap_mgc_verify_handle_connect/1). 6638-define(mtraaap_mgc_verify_service_change_req_fun(Mid), 6639 mtraaap_mgc_verify_service_change_req_fun(Mid)). 6640-define(mtraaap_mgc_verify_notify_req_fun(), 6641 mtraaap_mgc_verify_notify_request_fun()). 6642-define(mtraaap_mgc_verify_notify_reply_fun(), 6643 fun mtraaap_mgc_verify_notify_reply/1). 6644-define(mtraaap_mgc_verify_ack_fun(), 6645 fun mtraaap_mgc_verify_ack/1). 6646-define(mtraaap_mgc_verify_handle_disconnect_fun(), 6647 fun mtraaap_mgc_verify_handle_disconnect/1). 6648-endif. 6649 6650mtraaap_mgc_event_sequence(text, tcp) -> 6651 CTRL = self(), 6652 Mid = {deviceName,"ctrl"}, 6653 RI = [ 6654 {port, 2944}, 6655 {encoding_module, megaco_pretty_text_encoder}, 6656 {encoding_config, []}, 6657 {transport_module, megaco_tcp} 6658 ], 6659 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 6660 NR = fun(Cid, Rid) -> 6661 [mtraaap_mgc_notify_request_ar(Rid, Tid, Cid)] 6662 end, 6663 ReqTmr = #megaco_incr_timer{wait_for = 500, 6664 factor = 1, 6665 max_retries = 1}, 6666 ConnectVerify = ?mtraaap_mgc_verify_handle_connect_fun(), 6667 ServiceChangeReqVerify = ?mtraaap_mgc_verify_service_change_req_fun(Mid), 6668 NotifyReqVerify = ?mtraaap_mgc_verify_notify_req_fun(), 6669 NotifyReplyVerify = ?mtraaap_mgc_verify_notify_reply_fun(), 6670 AckVerify = ?mtraaap_mgc_verify_ack_fun(), 6671 DiscoVerify = ?mtraaap_mgc_verify_handle_disconnect_fun(), 6672 EvSeq = [ 6673 {debug, true}, 6674 {megaco_trace, disable}, 6675 megaco_start, 6676 {megaco_start_user, Mid, RI, []}, 6677 start_transport, 6678 listen, 6679 6680 %% ANNOUNCE READY 6681 {trigger, fun() -> CTRL ! announce_mgc end}, 6682 6683 {megaco_callback, handle_connect, ConnectVerify}, 6684 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 6685 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6686 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6687 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6688 {megaco_update_conn_info, request_timer, ReqTmr}, 6689 {megaco_cast, NR(1,1), []}, 6690 {megaco_callback, [{handle_trans_ack, 3, AckVerify}, 6691 {handle_trans_request, 3, NotifyReqVerify}, 6692 {handle_trans_reply, 1, NotifyReplyVerify}]}, 6693 {megaco_callback, handle_disconnect, DiscoVerify}, 6694 {sleep, 1000}, 6695 megaco_stop_user, 6696 megaco_stop 6697 ], 6698 EvSeq. 6699 6700 6701mtraaap_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 6702 io:format("mtraaap_mgc_verify_handle_connect -> ok" 6703 "~n CH: ~p~n", [CH]), 6704 {ok, CH, ok}; 6705mtraaap_mgc_verify_handle_connect(Else) -> 6706 io:format("mtraaap_mgc_verify_handle_connect -> unknown" 6707 "~n Else: ~p~n", [Else]), 6708 {error, Else, ok}. 6709 6710mtraaap_mgc_verify_service_change_req_fun(Mid) -> 6711 fun(Ev) -> 6712 mtraaap_mgc_verify_service_change_req(Ev, Mid) 6713 end. 6714 6715mtraaap_mgc_verify_service_change_req( 6716 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 6717 io:format("mtraaap_mgc_verify_service_change_req -> ok" 6718 "~n AR: ~p~n", [AR]), 6719 case AR of 6720 #'ActionRequest'{commandRequests = [CR]} -> 6721 case CR of 6722 #'CommandRequest'{command = Cmd} -> 6723 case Cmd of 6724 {serviceChangeReq, 6725 #'ServiceChangeRequest'{terminationID = [Tid], 6726 serviceChangeParms = Parms}} -> 6727 case Tid of 6728 #megaco_term_id{contains_wildcards = false, 6729 id = ["root"]} -> 6730 case Parms of 6731 #'ServiceChangeParm'{ 6732 serviceChangeMethod = restart, 6733 serviceChangeReason = [[$9,$0,$1|_]]} -> 6734 Reply = 6735 {discard_ack, 6736 [mtraaap_mgc_service_change_reply_ar(Mid, 1)]}, 6737 {ok, AR, Reply}; 6738 _ -> 6739 Err = {invalid_SCP, Parms}, 6740 ED = mtraaap_err_desc(Parms), 6741 ErrReply = {discard_ack, 6742 ED}, 6743 {error, Err, ErrReply} 6744 end; 6745 _ -> 6746 Err = {invalid_termination_id, Tid}, 6747 ED = mtraaap_err_desc(Tid), 6748 ErrReply = {discard_ack, ED}, 6749 {error, Err, ErrReply} 6750 end; 6751 _ -> 6752 Err = {invalid_command, Cmd}, 6753 ED = mtraaap_err_desc(Cmd), 6754 ErrReply = {discard_ack, ED}, 6755 {error, Err, ErrReply} 6756 end; 6757 _ -> 6758 Err = {invalid_command_request, CR}, 6759 ED = mtraaap_err_desc(CR), 6760 ErrReply = {discard_ack, ED}, 6761 {error, Err, ErrReply} 6762 end; 6763 _ -> 6764 Err = {invalid_action_request, AR}, 6765 ED = mtraaap_err_desc(AR), 6766 ErrReply = {discard_ack, ED}, 6767 {error, Err, ErrReply} 6768 end; 6769mtraaap_mgc_verify_service_change_req(Else, _Mid) -> 6770 io:format("mtraaap_mgc_verify_service_change_req -> unknown" 6771 "~n Else: ~p~n", [Else]), 6772 ED = mtraaap_err_desc(Else), 6773 ErrReply = {discard_ack, ED}, 6774 {error, Else, ErrReply}. 6775 6776mtraaap_mgc_verify_notify_request_fun() -> 6777 fun(Ev) -> 6778 mtraaap_mgc_verify_notify_request(Ev) 6779 end. 6780 6781mtraaap_mgc_verify_notify_request( 6782 {handle_trans_request, _, ?VERSION, [AR]}) -> 6783 io:format("mtraaap_mgc_verify_notify_request -> ok" 6784 "~n AR: ~p~n", [AR]), 6785 case AR of 6786 #'ActionRequest'{contextId = 1 = Cid, 6787 commandRequests = [CR]} -> 6788 #'CommandRequest'{command = Cmd} = CR, 6789 {notifyReq, NR} = Cmd, 6790 #'NotifyRequest'{terminationID = [Tid], 6791 observedEventsDescriptor = OED, 6792 errorDescriptor = asn1_NOVALUE} = NR, 6793 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 6794 #'ObservedEvent'{eventName = "al/of"} = OE, 6795 HandleAck = {handle_sloppy_ack, kalle}, 6796 Reply = {HandleAck, 6797 [mtraaap_mgc_notify_reply_ar(Cid, Tid)]}, 6798 {ok, AR, Reply}; 6799 #'ActionRequest'{contextId = 2 = Cid, 6800 commandRequests = [CR]} -> 6801 #'CommandRequest'{command = Cmd} = CR, 6802 {notifyReq, NR} = Cmd, 6803 #'NotifyRequest'{terminationID = [Tid], 6804 observedEventsDescriptor = OED, 6805 errorDescriptor = asn1_NOVALUE} = NR, 6806 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 6807 #'ObservedEvent'{eventName = "al/of"} = OE, 6808 Reply = {discard_ack, [mtraaap_mgc_notify_reply_ar(Cid, Tid)]}, 6809 {ok, AR, Reply}; 6810 _ -> 6811 ED = mtraaap_err_desc(AR), 6812 ErrReply = {discard_ack, ED}, 6813 {error, AR, ErrReply} 6814 end; 6815mtraaap_mgc_verify_notify_request(Else) -> 6816 io:format("mtraaap_mgc_verify_notify_request -> unknown" 6817 "~n Else: ~p~n", [Else]), 6818 ED = mtraaap_err_desc(Else), 6819 ErrReply = {discard_ack, ED}, 6820 {error, Else, ErrReply}. 6821 6822mtraaap_mgc_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 6823 {ok, [AR]}, _}) -> 6824 io:format("mtraaap_mgc_verify_notify_reply -> ok" 6825 "~n AR: ~p~n", [AR]), 6826 {ok, AR, ok}; 6827mtraaap_mgc_verify_notify_reply(Else) -> 6828 io:format("mtraaap_mgc_verify_notify_reply -> unknown" 6829 "~n Else: ~p~n", [Else]), 6830 {error, Else, ok}. 6831 6832mtraaap_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 6833 io:format("mtraaap_mgc_verify_ack -> ok" 6834 "~n CH: ~p" 6835 "~n", [CH]), 6836 {ok, CH, ok}; 6837mtraaap_mgc_verify_ack(Else) -> 6838 io:format("mtraaap_mgc_verify_ack -> unknown" 6839 "~n Else: ~p~n", [Else]), 6840 {error, Else, ok}. 6841 6842mtraaap_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 6843 io:format("mtraaap_mgc_verify_handle_disconnect -> ok" 6844 "~n CH: ~p" 6845 "~n R: ~p" 6846 "~n", [CH, R]), 6847 {ok, CH, ok}; 6848mtraaap_mgc_verify_handle_disconnect(Else) -> 6849 io:format("mtraaap_mgc_verify_handle_disconnect -> unknown" 6850 "~n Else: ~p~n", [Else]), 6851 {error, Else, ok}. 6852 6853 6854mtraaap_mgc_service_change_reply_ar(Mid, Cid) -> 6855 SCRP = cre_serviceChangeResParm(Mid), 6856 SCRes = cre_serviceChangeResult(SCRP), 6857 Root = #megaco_term_id{id = ["root"]}, 6858 SCR = cre_serviceChangeReply([Root], SCRes), 6859 CR = cre_cmdReply(SCR), 6860 cre_actionReply(Cid, [CR]). 6861 6862%% mtraaap_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 6863%% AR = mtraaap_mgc_service_change_reply_ar(Mid, Cid), 6864%% TRes = cre_transResult([AR]), 6865%% TR = cre_transReply(TransId, TRes), 6866%% Trans = cre_transaction(TR), 6867%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6868%% cre_megacoMessage(Mess). 6869 6870mtraaap_mgc_notify_request_ar(Rid, Tid, Cid) -> 6871 TT = cre_timeNotation("19990729", "44000000"), 6872 Ev = cre_obsEvent("al/of", TT), 6873 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 6874 NR = cre_notifyReq([Tid], EvsDesc), 6875 CMD = cre_command(NR), 6876 CR = cre_cmdReq(CMD), 6877 cre_actionReq(Cid, [CR]). 6878 6879mtraaap_mgc_notify_reply_ar(Cid, TermId) -> 6880 NR = cre_notifyReply([TermId]), 6881 CR = cre_cmdReply(NR), 6882 cre_actionReply(Cid, [CR]). 6883 6884%% mtraaap_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 6885%% AR = mtraaap_mgc_notify_reply_ar(Cid, TermId), 6886%% TRes = cre_transResult([AR]), 6887%% TR = cre_transReply(TransId, TRes), 6888%% Trans = cre_transaction(TR), 6889%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6890%% cre_megacoMessage(Mess). 6891 6892 6893%% 6894%% MG generator stuff 6895%% 6896-ifdef(megaco_hipe_special). 6897-define(mtraaap_mg_verify_handle_connect_fun(), 6898 {?MODULE, mtraaap_mg_verify_handle_connect, []}). 6899-define(mtraaap_mg_verify_service_change_reply_fun(), 6900 {?MODULE, mtraaap_mg_verify_service_change_reply, []}). 6901-define(mtraaap_mg_verify_notify_req_fun(), 6902 {?MODULE, mtraaap_mgc_verify_notify_request, []}). 6903-define(mtraaap_mg_verify_notify_reply_fun(), 6904 {?MODULE, mtraaap_mg_verify_notify_reply, []}). 6905-else. 6906-define(mtraaap_mg_verify_handle_connect_fun(), 6907 fun mtraaap_mg_verify_handle_connect/1). 6908-define(mtraaap_mg_verify_service_change_reply_fun(), 6909 fun mtraaap_mg_verify_service_change_reply/1). 6910-define(mtraaap_mg_verify_notify_req_fun(), 6911 mtraaap_mgc_verify_notify_request_fun()). 6912-define(mtraaap_mg_verify_notify_reply_fun(), 6913 fun mtraaap_mg_verify_notify_reply/1). 6914-endif. 6915 6916mtraaap_mg_event_sequence(text, tcp) -> 6917 Mid = {deviceName,"mg"}, 6918 RI = [ 6919 {port, 2944}, 6920 {encoding_module, megaco_pretty_text_encoder}, 6921 {encoding_config, []}, 6922 {transport_module, megaco_tcp} 6923 ], 6924 ServiceChangeReq = [mtraaap_mg_service_change_request_ar(Mid, 1)], 6925 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 6926 NR = fun(Cid, Rid) -> 6927 [mtraaap_mg_notify_request_ar(Rid, Tid, Cid)] 6928 end, 6929 ConnectVerify = ?mtraaap_mg_verify_handle_connect_fun(), 6930 ServiceChangeReplyVerify = ?mtraaap_mg_verify_service_change_reply_fun(), 6931 NotifyReqVerify = ?mtraaap_mg_verify_notify_req_fun(), 6932 NotifyReplyVerify = ?mtraaap_mg_verify_notify_reply_fun(), 6933 EvSeq = [ 6934 {debug, true}, 6935 megaco_start, 6936 {megaco_start_user, Mid, RI, []}, 6937 start_transport, 6938 {megaco_trace, disable}, 6939 {megaco_system_info, users}, 6940 {megaco_system_info, connections}, 6941 connect, 6942 {megaco_callback, handle_connect, ConnectVerify}, 6943 megaco_connect, 6944 {megaco_cast, ServiceChangeReq, []}, 6945 {megaco_callback, handle_connect, ConnectVerify}, 6946 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 6947 {sleep, 1000}, 6948 {megaco_system_info, users}, 6949 {megaco_system_info, connections}, 6950 {sleep, 1000}, 6951 {megaco_update_conn_info, auto_ack, true}, 6952 {megaco_update_conn_info, trans_ack_maxcount, 10}, 6953 {megaco_update_conn_info, trans_req_maxcount, 10}, 6954 {megaco_update_conn_info, trans_timer, 1000}, 6955 {megaco_update_conn_info, trans_ack, true}, 6956 {megaco_update_conn_info, trans_req, true}, 6957 {megaco_conn_info, all}, 6958 {megaco_cast, NR(1,1), []}, 6959 {megaco_cast, NR(1,2), []}, 6960 {megaco_cast, NR(1,3), []}, 6961 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6962 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6963 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6964 {megaco_update_conn_info, trans_timer, 120000}, 6965 {megaco_cast, NR(2,1), []}, 6966 {megaco_cast, NR(2,2), []}, 6967 {megaco_cast, NR(2,3), []}, 6968 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6969 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6970 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6971 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6972 {sleep, 3000}, 6973 megaco_stop_user, 6974 megaco_stop, 6975 {sleep, 1000} 6976 ], 6977 EvSeq. 6978 6979mtraaap_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 6980 io:format("mtraaap_mg_verify_handle_connect -> ok" 6981 "~n CH: ~p~n", [CH]), 6982 {ok, CH, ok}; 6983mtraaap_mg_verify_handle_connect(Else) -> 6984 io:format("mtraaap_mg_verify_handle_connect -> unknown" 6985 "~n Else: ~p~n", [Else]), 6986 {error, Else, ok}. 6987 6988mtraaap_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 6989 {ok, [AR]}, _}) -> 6990 io:format("mtraaap_mg_verify_service_change_reply -> ok" 6991 "~n AR: ~p~n", [AR]), 6992 case AR of 6993 #'ActionReply'{commandReply = [SCR]} -> 6994 case SCR of 6995 {serviceChangeReply, 6996 #'ServiceChangeReply'{terminationID = [Tid], 6997 serviceChangeResult = Res}} -> 6998 case Tid of 6999 #megaco_term_id{contains_wildcards = false, 7000 id = ["root"]} -> 7001 case Res of 7002 {serviceChangeResParms, 7003 #'ServiceChangeResParm'{ 7004 serviceChangeMgcId = _RemoteMid}} -> 7005 {ok, AR, ok}; 7006 {Tag, Val} -> 7007 Err = {invalid_service_change_result, 7008 Tag, Val}, 7009 {error, Err, ok} 7010 end; 7011 _ -> 7012 Err = {invalid_termination_id, Tid}, 7013 {error, Err, ok} 7014 end; 7015 {Tag, Val} -> 7016 Err = {invalid_command_reply, Tag, Val}, 7017 {error, Err, ok} 7018 end; 7019 _ -> 7020 Err = {invalid_action_reply, AR}, 7021 {error, Err, ok} 7022 end; 7023mtraaap_mg_verify_service_change_reply(Else) -> 7024 io:format("mtraaap_mg_verify_service_change_reply -> unknown" 7025 "~n Else: ~p~n", [Else]), 7026 {error, Else, ok}. 7027 7028 7029mtraaap_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 7030 {ok, [AR]}, _}) -> 7031 io:format("mtraaap_mg_verify_notify_reply -> ok" 7032 "~n AR: ~p~n", [AR]), 7033 {ok, AR, ok}; 7034mtraaap_mg_verify_notify_reply(Else) -> 7035 io:format("mtraaap_mg_verify_notify_reply -> unknown" 7036 "~n Else: ~p~n", [Else]), 7037 {error, Else, ok}. 7038 7039mtraaap_mg_service_change_request_ar(_Mid, Cid) -> 7040 Prof = cre_serviceChangeProf("resgw", 1), 7041 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 7042 Root = #megaco_term_id{id = ["root"]}, 7043 SCR = cre_serviceChangeReq([Root], SCP), 7044 CMD = cre_command(SCR), 7045 CR = cre_cmdReq(CMD), 7046 cre_actionReq(Cid, [CR]). 7047 7048%% mtraaap_mg_service_change_request_msg(Mid, TransId, Cid) -> 7049%% AR = mtraaap_mg_service_change_request_ar(Mid, Cid), 7050%% TR = cre_transReq(TransId, [AR]), 7051%% Trans = cre_transaction(TR), 7052%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 7053%% cre_megacoMessage(Mess). 7054 7055%% mtraaap_mg_notify_reply_ar(Cid, TermId) -> 7056%% NR = cre_notifyReply([TermId]), 7057%% CR = cre_cmdReply(NR), 7058%% cre_actionReply(Cid, [CR]). 7059 7060mtraaap_mg_notify_request_ar(Rid, Tid, Cid) -> 7061 TT = cre_timeNotation("19990729", "22000000"), 7062 Ev = cre_obsEvent("al/of", TT), 7063 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 7064 NR = cre_notifyReq([Tid], EvsDesc), 7065 CMD = cre_command(NR), 7066 CR = cre_cmdReq(CMD), 7067 cre_actionReq(Cid, [CR]). 7068 7069%% mtraaap_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 7070%% AR = mtraaap_mg_notify_request_ar(Rid, TermId, Cid), 7071%% TR = cre_transReq(TransId, [AR]), 7072%% Trans = cre_transaction(TR), 7073%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 7074%% cre_megacoMessage(Mess). 7075 7076 7077%% 7078%% Common functions for this test case 7079%% 7080 7081mtraaap_err_desc(T) -> 7082 cre_ErrDesc(T). 7083 7084 7085%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7086 7087multi_ack_and_pending(suite) -> 7088 []; 7089multi_ack_and_pending(doc) -> 7090 []; 7091multi_ack_and_pending(Config) when is_list(Config) -> 7092 ?SKIP(not_yet_implemented). 7093 7094 7095%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7096 7097multi_trans_req_and_reply(suite) -> 7098 []; 7099multi_trans_req_and_reply(doc) -> 7100 []; 7101multi_trans_req_and_reply(Config) when is_list(Config) -> 7102 ?SKIP(not_yet_implemented). 7103 7104 7105%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7106 7107multi_trans_req_and_ack_and_reply(suite) -> 7108 []; 7109multi_trans_req_and_ack_and_reply(doc) -> 7110 []; 7111multi_trans_req_and_ack_and_reply(Config) when is_list(Config) -> 7112 Pre = fun() -> 7113 MgcNode = make_node_name(mgc), 7114 MgNode = make_node_name(mg), 7115 d("start nodes: " 7116 "~n MGC Node: ~p" 7117 "~n MG Node: ~p", 7118 [MgcNode, MgNode]), 7119 Nodes = [MgcNode, MgNode], 7120 ok = ?START_NODES(Nodes), 7121 Nodes 7122 end, 7123 Case = fun do_multi_trans_req_and_ack_and_reply/1, 7124 Post = fun(Nodes) -> 7125 d("stop nodes"), 7126 ?STOP_NODES(lists:reverse(Nodes)) 7127 end, 7128 try_tc(multi_trans_req_and_ack_and_reply, Pre, Case, Post). 7129 7130do_multi_trans_req_and_ack_and_reply([MgcNode, MgNode]) -> 7131 7132 d("[MGC] start the simulator "), 7133 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 7134 7135 d("[MGC] create the event sequence"), 7136 MgcEvSeq = mtraaar_mgc_event_sequence(text, tcp), 7137 7138 i("wait some time before starting the MGC simulation"), 7139 sleep(1000), 7140 7141 d("[MGC] start the simulation"), 7142 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 7143 7144 %% i("wait some time before starting the MG simulator"), 7145 %% sleep(1000), 7146 7147 i("await MGC ready announcement"), 7148 receive 7149 announce_mgc -> 7150 i("received MGC ready announcement"), 7151 ok 7152 end, 7153 7154 d("[MG] start the simulator (generator)"), 7155 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 7156 7157 d("[MG] create the event sequence"), 7158 MgEvSeq = mtraaar_mg_event_sequence(text, tcp), 7159 7160 i("wait some time before starting the MG simulation"), 7161 sleep(1000), 7162 7163 d("[MG] start the simulation"), 7164 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 7165 7166 d("await the generator reply(s)"), 7167 await_completion([MgcId, MgId]), 7168 7169 %% Tell Mgc to stop 7170 i("[MGC] stop generator"), 7171 megaco_test_megaco_generator:stop(Mgc), 7172 7173 %% Tell Mg to stop 7174 i("[MG] stop generator"), 7175 megaco_test_megaco_generator:stop(Mg), 7176 7177 i("done", []), 7178 ok. 7179 7180 7181%% 7182%% MGC generator stuff 7183%% 7184-ifdef(megaco_hipe_special). 7185-define(mtraaar_mgc_verify_handle_connect_fun(), 7186 {?MODULE, mtraaar_mgc_verify_handle_connect, []}). 7187-define(mtraaar_mgc_verify_service_change_req_fun(Mid), 7188 {?MODULE, mtraaar_mgc_verify_service_change_req, [Mid]}). 7189-define(mtraaar_mgc_verify_notify_req_fun(N), 7190 {?MODULE, mtraaar_mgc_verify_notify_request, [N]}). 7191-define(mtraaar_mgc_verify_notify_reply_fun(N), 7192 {?MODULE, mtraaar_mgc_verify_notify_reply, [N]}). 7193-define(mtraaar_mgc_verify_ack_fun(), 7194 {?MODULE, mtraaar_mgc_verify_ack, []}). 7195-define(mtraaar_mgc_verify_handle_disconnect_fun(), 7196 {?MODULE, mtraaar_mgc_verify_handle_disconnect, []}). 7197-else. 7198-define(mtraaar_mgc_verify_handle_connect_fun(), 7199 fun mtraaar_mgc_verify_handle_connect/1). 7200-define(mtraaar_mgc_verify_service_change_req_fun(Mid), 7201 mtraaar_mgc_verify_service_change_req_fun(Mid)). 7202-define(mtraaar_mgc_verify_notify_req_fun(N), 7203 fun(Request) -> 7204 mtraaar_mgc_verify_notify_request(N, Request) 7205 end). 7206-define(mtraaar_mgc_verify_notify_reply_fun(N), 7207 fun(Reply) -> 7208 mtraaar_mgc_verify_notify_reply(N, Reply) 7209 end). 7210-define(mtraaar_mgc_verify_ack_fun(), 7211 fun mtraaar_mgc_verify_ack/1). 7212-define(mtraaar_mgc_verify_handle_disconnect_fun(), 7213 fun mtraaar_mgc_verify_handle_disconnect/1). 7214-endif. 7215 7216mtraaar_mgc_event_sequence(text, tcp) -> 7217 CTRL = self(), 7218 Mid = {deviceName,"ctrl"}, 7219 RI = [ 7220 {port, 2944}, 7221 {encoding_module, megaco_pretty_text_encoder}, 7222 {encoding_config, []}, 7223 {transport_module, megaco_tcp} 7224 ], 7225 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 7226 SNR = fun(Cid, Rid) -> 7227 [mtraaar_mgc_notify_request_ar(Rid, Tid, Cid)] 7228 end, 7229 ConnectVerify = ?mtraaar_mgc_verify_handle_connect_fun(), 7230 ServiceChangeReqVerify = ?mtraaar_mgc_verify_service_change_req_fun(Mid), 7231 %% NotifyReqVerify = ?mtraaar_mgc_verify_notify_req_fun(), 7232 NReqV = 7233 fun(N) -> 7234 ?mtraaar_mgc_verify_notify_req_fun(N) 7235 end, 7236 %% NotifyReplyVerify = ?mtraaar_mgc_verify_notify_reply_fun(), 7237 NRepV = fun(N) -> 7238 ?mtraaar_mgc_verify_notify_reply_fun(N) 7239 end, 7240 AckVerify = ?mtraaar_mgc_verify_ack_fun(), 7241 DiscoVerify = ?mtraaar_mgc_verify_handle_disconnect_fun(), 7242 EvSeq = [ 7243 {debug, true}, 7244 %% {megaco_trace, max}, 7245 {megaco_trace, disable}, 7246 megaco_start, 7247 {megaco_start_user, Mid, RI, []}, 7248 start_transport, 7249 listen, 7250 7251 %% ANNOUNCE READY 7252 {trigger, fun() -> CTRL ! announce_mgc end}, 7253 7254 {megaco_callback, handle_connect, ConnectVerify}, 7255 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 7256 {megaco_callback, handle_trans_request, NReqV(1)}, 7257 {megaco_callback, handle_trans_request, NReqV(2)}, 7258 {megaco_callback, handle_trans_request, NReqV(3)}, 7259 {megaco_update_conn_info, request_timer, 1000}, 7260 {sleep, 1000}, 7261 {megaco_cast, SNR(1,1), []}, 7262 7263 {megaco_callback, [{handle_trans_ack, 3, AckVerify}, 7264 {handle_trans_request, 3, NReqV(4)}, 7265 {handle_trans_reply, 1, NRepV(1)}]}, 7266 {megaco_callback, handle_disconnect, DiscoVerify}, 7267 {sleep, 1000}, 7268 megaco_stop_user, 7269 megaco_stop 7270 ], 7271 EvSeq. 7272 7273 7274mtraaar_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 7275 io:format("mtraaar_mgc_verify_handle_connect -> ok" 7276 "~n CH: ~p~n", [CH]), 7277 {ok, CH, ok}; 7278mtraaar_mgc_verify_handle_connect(Else) -> 7279 io:format("mtraaar_mgc_verify_handle_connect -> unknown" 7280 "~n Else: ~p~n", [Else]), 7281 {error, Else, ok}. 7282 7283mtraaar_mgc_verify_service_change_req_fun(Mid) -> 7284 fun(Ev) -> 7285 mtraaar_mgc_verify_service_change_req(Ev, Mid) 7286 end. 7287 7288mtraaar_mgc_verify_service_change_req( 7289 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 7290 io:format("mtraaar_mgc_verify_service_change_req -> ok" 7291 "~n AR: ~p~n", [AR]), 7292 case AR of 7293 #'ActionRequest'{commandRequests = [CR]} -> 7294 case CR of 7295 #'CommandRequest'{command = Cmd} -> 7296 case Cmd of 7297 {serviceChangeReq, 7298 #'ServiceChangeRequest'{terminationID = [Tid], 7299 serviceChangeParms = Parms}} -> 7300 case Tid of 7301 #megaco_term_id{contains_wildcards = false, 7302 id = ["root"]} -> 7303 case Parms of 7304 #'ServiceChangeParm'{ 7305 serviceChangeMethod = restart, 7306 serviceChangeReason = [[$9,$0,$1|_]]} -> 7307 Reply = 7308 {discard_ack, 7309 [mtraaar_mgc_service_change_reply_ar(Mid, 1)]}, 7310 {ok, AR, Reply}; 7311 _ -> 7312 Err = {invalid_SCP, Parms}, 7313 ED = mtraaar_err_desc(Parms), 7314 ErrReply = {discard_ack, 7315 ED}, 7316 {error, Err, ErrReply} 7317 end; 7318 _ -> 7319 Err = {invalid_termination_id, Tid}, 7320 ED = mtraaar_err_desc(Tid), 7321 ErrReply = {discard_ack, ED}, 7322 {error, Err, ErrReply} 7323 end; 7324 _ -> 7325 Err = {invalid_command, Cmd}, 7326 ED = mtraaar_err_desc(Cmd), 7327 ErrReply = {discard_ack, ED}, 7328 {error, Err, ErrReply} 7329 end; 7330 _ -> 7331 Err = {invalid_command_request, CR}, 7332 ED = mtraaar_err_desc(CR), 7333 ErrReply = {discard_ack, ED}, 7334 {error, Err, ErrReply} 7335 end; 7336 _ -> 7337 Err = {invalid_action_request, AR}, 7338 ED = mtraaar_err_desc(AR), 7339 ErrReply = {discard_ack, ED}, 7340 {error, Err, ErrReply} 7341 end; 7342mtraaar_mgc_verify_service_change_req(Else, _Mid) -> 7343 io:format("mtraaar_mgc_verify_service_change_req -> unknown" 7344 "~n Else: ~p~n", [Else]), 7345 ED = mtraaar_err_desc(Else), 7346 ErrReply = {discard_ack, ED}, 7347 {error, Else, ErrReply}. 7348 7349mtraaar_mgc_verify_notify_request( 7350 N, 7351 {handle_trans_request, _, ?VERSION, [AR]}) -> 7352 io:format("mtraaar_mgc_verify_notify_request -> [~w] ok" 7353 "~n AR: ~p~n", [N, AR]), 7354 case AR of 7355 #'ActionRequest'{contextId = 1 = Cid, 7356 commandRequests = [CR]} -> 7357 #'CommandRequest'{command = Cmd} = CR, 7358 {notifyReq, NR} = Cmd, 7359 #'NotifyRequest'{terminationID = [Tid], 7360 observedEventsDescriptor = OED, 7361 errorDescriptor = asn1_NOVALUE} = NR, 7362 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 7363 #'ObservedEvent'{eventName = "al/of"} = OE, 7364 HandleAck = {handle_sloppy_ack, kalle}, 7365 Reply = {HandleAck, 7366 [mtraaar_mgc_notify_reply_ar(Cid, Tid)]}, 7367 {ok, AR, Reply}; 7368 #'ActionRequest'{contextId = 2 = Cid, 7369 commandRequests = [CR]} -> 7370 #'CommandRequest'{command = Cmd} = CR, 7371 {notifyReq, NR} = Cmd, 7372 #'NotifyRequest'{terminationID = [Tid], 7373 observedEventsDescriptor = OED, 7374 errorDescriptor = asn1_NOVALUE} = NR, 7375 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 7376 #'ObservedEvent'{eventName = "al/of"} = OE, 7377 Reply = {discard_ack, [mtraaar_mgc_notify_reply_ar(Cid, Tid)]}, 7378 {ok, AR, Reply}; 7379 _ -> 7380 ED = mtraaar_err_desc(AR), 7381 ErrReply = {discard_ack, ED}, 7382 {error, AR, ErrReply} 7383 end; 7384mtraaar_mgc_verify_notify_request(N, Else) -> 7385 io:format("mtraaar_mgc_verify_notify_request -> [~w] unknown" 7386 "~n Else: ~p~n", [N, Else]), 7387 ED = mtraaar_err_desc(Else), 7388 ErrReply = {discard_ack, ED}, 7389 {error, Else, ErrReply}. 7390 7391mtraaar_mgc_verify_notify_reply(N, 7392 {handle_trans_reply, _CH, ?VERSION, 7393 {ok, [AR]}, _}) -> 7394 io:format("mtraaar_mgc_verify_notify_reply -> [~w] ok" 7395 "~n AR: ~p~n", [N, AR]), 7396 {ok, AR, ok}; 7397mtraaar_mgc_verify_notify_reply(N, 7398 {handle_trans_reply, CH, ?VERSION, 7399 UnknownResult, _}) -> 7400 io:format("mtraaar_mgc_verify_notify_reply -> [~w] unknown result" 7401 "~n UnknownResult: ~p~n", [N, UnknownResult]), 7402 {error, {unknown_reply_result, UnknownResult, CH}, ok}; 7403mtraaar_mgc_verify_notify_reply(N, Else) -> 7404 io:format("mtraaar_mgc_verify_notify_reply -> [~w] unknown" 7405 "~n Else: ~p~n", [N, Else]), 7406 {error, {unknown_reply, Else}, ok}. 7407 7408mtraaar_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 7409 io:format("mtraaar_mgc_verify_ack -> ok" 7410 "~n CH: ~p" 7411 "~n", [CH]), 7412 {ok, CH, ok}; 7413mtraaar_mgc_verify_ack(Else) -> 7414 io:format("mtraaar_mgc_verify_ack -> unknown" 7415 "~n Else: ~p~n", [Else]), 7416 {error, Else, ok}. 7417 7418mtraaar_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 7419 io:format("mtraaar_mgc_verify_handle_disconnect -> ok" 7420 "~n CH: ~p" 7421 "~n R: ~p" 7422 "~n", [CH, R]), 7423 {ok, CH, ok}; 7424mtraaar_mgc_verify_handle_disconnect(Else) -> 7425 io:format("mtraaar_mgc_verify_handle_disconnect -> unknown" 7426 "~n Else: ~p~n", [Else]), 7427 {error, Else, ok}. 7428 7429 7430mtraaar_mgc_service_change_reply_ar(Mid, Cid) -> 7431 SCRP = cre_serviceChangeResParm(Mid), 7432 SCRes = cre_serviceChangeResult(SCRP), 7433 Root = #megaco_term_id{id = ["root"]}, 7434 SCR = cre_serviceChangeReply([Root], SCRes), 7435 CR = cre_cmdReply(SCR), 7436 cre_actionReply(Cid, [CR]). 7437 7438%% mtraaar_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 7439%% AR = mtraaar_mgc_service_change_reply_ar(Mid, Cid), 7440%% TRes = cre_transResult([AR]), 7441%% TR = cre_transReply(TransId, TRes), 7442%% Trans = cre_transaction(TR), 7443%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 7444%% cre_megacoMessage(Mess). 7445 7446mtraaar_mgc_notify_request_ar(Rid, Tid, Cid) -> 7447 TT = cre_timeNotation("19990729", "44000000"), 7448 Ev = cre_obsEvent("al/of", TT), 7449 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 7450 NR = cre_notifyReq([Tid], EvsDesc), 7451 CMD = cre_command(NR), 7452 CR = cre_cmdReq(CMD), 7453 cre_actionReq(Cid, [CR]). 7454 7455mtraaar_mgc_notify_reply_ar(Cid, TermId) -> 7456 NR = cre_notifyReply([TermId]), 7457 CR = cre_cmdReply(NR), 7458 cre_actionReply(Cid, [CR]). 7459 7460%% mtraaar_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 7461%% AR = mtraaar_mgc_notify_reply_ar(Cid, TermId), 7462%% TRes = cre_transResult([AR]), 7463%% TR = cre_transReply(TransId, TRes), 7464%% Trans = cre_transaction(TR), 7465%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 7466%% cre_megacoMessage(Mess). 7467 7468 7469%% 7470%% MG generator stuff 7471%% 7472-ifdef(megaco_hipe_special). 7473-define(mtraaar_mg_verify_handle_connect_fun(), 7474 {?MODULE, mtraaar_mg_verify_handle_connect, []}). 7475-define(mtraaar_mg_verify_service_change_reply_fun(), 7476 {?MODULE, mtraaar_mg_verify_service_change_reply, []}). 7477-define(mtraaar_mg_verify_notify_req_fun(), 7478 {?MODULE, mtraaar_mgc_verify_notify_request, []}). 7479-define(mtraaar_mg_verify_notify_reply_fun(), 7480 {?MODULE, mtraaar_mg_verify_notify_reply, []}). 7481-else. 7482-define(mtraaar_mg_verify_handle_connect_fun(), 7483 fun mtraaar_mg_verify_handle_connect/1). 7484-define(mtraaar_mg_verify_service_change_reply_fun(), 7485 fun mtraaar_mg_verify_service_change_reply/1). 7486-define(mtraaar_mg_verify_notify_req_fun(N), 7487 %% We reuse the mgc code... 7488 fun(Request) -> 7489 mtraaar_mgc_verify_notify_request(N, Request) 7490 end). 7491-define(mtraaar_mg_verify_notify_reply_fun(N), 7492 fun(Reply) -> 7493 mtraaar_mg_verify_notify_reply(N, Reply) 7494 end). 7495-endif. 7496 7497mtraaar_mg_event_sequence(text, tcp) -> 7498 Mid = {deviceName,"mg"}, 7499 RI = [ 7500 {port, 2944}, 7501 {encoding_module, megaco_pretty_text_encoder}, 7502 {encoding_config, []}, 7503 {transport_module, megaco_tcp} 7504 ], 7505 ServiceChangeReq = [mtraaar_mg_service_change_request_ar(Mid, 1)], 7506 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 7507 SNR = fun(Cid, Rid) -> 7508 [mtraaar_mg_notify_request_ar(Rid, Tid, Cid)] 7509 end, 7510 ConnectVerify = ?mtraaar_mg_verify_handle_connect_fun(), 7511 ServiceChangeReplyVerify = ?mtraaar_mg_verify_service_change_reply_fun(), 7512 %% NotifyReqVerify = ?mtraaar_mg_verify_notify_req_fun(), 7513 NReqV = 7514 fun(N) -> 7515 ?mtraaar_mg_verify_notify_req_fun(N) 7516 end, 7517 %% NotifyReplyVerify = ?mtraaar_mg_verify_notify_reply_fun(), 7518 NRepV = 7519 fun(N) -> 7520 ?mtraaar_mg_verify_notify_reply_fun(N) 7521 end, 7522 EvSeq = [ 7523 {debug, true}, 7524 megaco_start, 7525 {megaco_start_user, Mid, RI, []}, 7526 start_transport, 7527 %% {megaco_trace, max}, 7528 {megaco_trace, disable}, 7529 {megaco_system_info, users}, 7530 {megaco_system_info, connections}, 7531 connect, 7532 {megaco_callback, handle_connect, ConnectVerify}, 7533 megaco_connect, 7534 {megaco_cast, ServiceChangeReq, []}, 7535 {megaco_callback, handle_connect, ConnectVerify}, 7536 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 7537 {sleep, 1000}, 7538 {megaco_system_info, users}, 7539 {megaco_system_info, connections}, 7540 {sleep, 1000}, 7541 {megaco_update_conn_info, auto_ack, true}, 7542 {megaco_update_conn_info, trans_ack_maxcount, 10}, 7543 {megaco_update_conn_info, trans_req_maxcount, 10}, 7544 {megaco_update_conn_info, trans_timer, 1000}, 7545 {megaco_update_conn_info, trans_ack, true}, 7546 {megaco_update_conn_info, trans_req, true}, 7547 {megaco_conn_info, all}, 7548 {megaco_cast, SNR(1,1), []}, 7549 {sleep, 100}, 7550 {megaco_cast, SNR(1,2), []}, 7551 {sleep, 100}, 7552 {megaco_cast, SNR(1,3), []}, 7553 {megaco_callback, handle_trans_reply, NRepV(1)}, 7554 {megaco_callback, handle_trans_reply, NRepV(2)}, 7555 {megaco_callback, handle_trans_reply, NRepV(3)}, 7556 {megaco_update_conn_info, trans_timer, 120000}, 7557 {megaco_cast, SNR(2,1), []}, 7558 {sleep, 100}, 7559 {megaco_cast, SNR(2,2), []}, 7560 {sleep, 100}, 7561 {megaco_cast, SNR(2,3), []}, 7562 {megaco_callback, handle_trans_request, NReqV(1)}, 7563 {megaco_callback, handle_trans_reply, NRepV(4)}, 7564 {megaco_callback, handle_trans_reply, NRepV(5)}, 7565 {megaco_callback, handle_trans_reply, NRepV(6)}, 7566 {sleep, 3000}, 7567 megaco_stop_user, 7568 megaco_stop, 7569 {sleep, 1000} 7570 ], 7571 EvSeq. 7572 7573mtraaar_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 7574 io:format("mtraaar_mg_verify_handle_connect -> ok" 7575 "~n CH: ~p~n", [CH]), 7576 {ok, CH, ok}; 7577mtraaar_mg_verify_handle_connect(Else) -> 7578 io:format("mtraaar_mg_verify_handle_connect -> unknown" 7579 "~n Else: ~p~n", [Else]), 7580 {error, Else, ok}. 7581 7582mtraaar_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 7583 {ok, [AR]}, _}) -> 7584 io:format("mtraaar_mg_verify_service_change_reply -> ok" 7585 "~n AR: ~p~n", [AR]), 7586 case AR of 7587 #'ActionReply'{commandReply = [SCR]} -> 7588 case SCR of 7589 {serviceChangeReply, 7590 #'ServiceChangeReply'{terminationID = [Tid], 7591 serviceChangeResult = Res}} -> 7592 case Tid of 7593 #megaco_term_id{contains_wildcards = false, 7594 id = ["root"]} -> 7595 case Res of 7596 {serviceChangeResParms, 7597 #'ServiceChangeResParm'{ 7598 serviceChangeMgcId = _RemoteMid}} -> 7599 {ok, AR, ok}; 7600 {Tag, Val} -> 7601 Err = {invalid_service_change_result, 7602 Tag, Val}, 7603 {error, Err, ok} 7604 end; 7605 _ -> 7606 Err = {invalid_termination_id, Tid}, 7607 {error, Err, ok} 7608 end; 7609 {Tag, Val} -> 7610 Err = {invalid_command_reply, Tag, Val}, 7611 {error, Err, ok} 7612 end; 7613 _ -> 7614 Err = {invalid_action_reply, AR}, 7615 {error, Err, ok} 7616 end; 7617mtraaar_mg_verify_service_change_reply(Else) -> 7618 io:format("mtraaar_mg_verify_service_change_reply -> unknown" 7619 "~n Else: ~p~n", [Else]), 7620 {error, Else, ok}. 7621 7622mtraaar_mg_verify_notify_reply(N, 7623 {handle_trans_reply, 7624 _CH, 7625 ?VERSION, 7626 {ok, [AR]}, 7627 _}) -> 7628 io:format("mtraaar_mg_verify_notify_reply -> [~w] ok" 7629 "~n AR: ~p~n", [N, AR]), 7630 {ok, AR, ok}; 7631mtraaar_mg_verify_notify_reply(N, 7632 {handle_trans_reply, 7633 _CH, 7634 ?VERSION, 7635 ERROR, 7636 _}) -> 7637 io:format("mtraaar_mg_verify_notify_reply -> [~w] reply error" 7638 "~n ERROR: ~p~n", [N, ERROR]), 7639 {error, ERROR, ok}; 7640mtraaar_mg_verify_notify_reply(N, 7641 Else) when is_tuple(Else) -> 7642 io:format("mtraaar_mg_verify_notify_reply -> [~w] ~w instead of ~w" 7643 "~n Else: ~p" 7644 "~n", [N, element(1, Else), handle_trans_reply, Else]), 7645 {error, Else, ok}; 7646mtraaar_mg_verify_notify_reply(N, 7647 Else) -> 7648 io:format("mtraaar_mg_verify_notify_reply -> [~w] unknown" 7649 "~n Else: ~p~n", [N, Else]), 7650 {error, Else, ok}. 7651 7652mtraaar_mg_service_change_request_ar(_Mid, Cid) -> 7653 Prof = cre_serviceChangeProf("resgw", 1), 7654 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 7655 Root = #megaco_term_id{id = ["root"]}, 7656 SCR = cre_serviceChangeReq([Root], SCP), 7657 CMD = cre_command(SCR), 7658 CR = cre_cmdReq(CMD), 7659 cre_actionReq(Cid, [CR]). 7660 7661mtraaar_mg_notify_request_ar(Rid, Tid, Cid) -> 7662 TT = cre_timeNotation("19990729", "22000000"), 7663 Ev = cre_obsEvent("al/of", TT), 7664 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 7665 NR = cre_notifyReq([Tid], EvsDesc), 7666 CMD = cre_command(NR), 7667 CR = cre_cmdReq(CMD), 7668 cre_actionReq(Cid, [CR]). 7669 7670%% 7671%% Common functions for the multi_trans_req_timeout test case 7672%% 7673 7674mtraaar_err_desc(T) -> 7675 cre_ErrDesc(T). 7676 7677 7678%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7679 7680multi_ack_and_reply(suite) -> 7681 []; 7682multi_ack_and_reply(doc) -> 7683 []; 7684multi_ack_and_reply(Config) when is_list(Config) -> 7685 ?SKIP(not_yet_implemented). 7686 7687 7688%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7689 7690otp_7192_1(suite) -> 7691 []; 7692otp_7192_1(doc) -> 7693 [""]; 7694otp_7192_1(Config) when is_list(Config) -> 7695 Pre = fun() -> 7696 MgcNode = make_node_name(mgc), 7697 MgNode = make_node_name(mg), 7698 d("start nodes: " 7699 "~n MGC Node: ~p" 7700 "~n MG Node: ~p", 7701 [MgcNode, MgNode]), 7702 Nodes = [MgcNode, MgNode], 7703 ok = ?START_NODES(Nodes), 7704 Nodes 7705 end, 7706 Case = fun do_otp_7192_1/1, 7707 Post = fun(Nodes) -> 7708 d("stop nodes"), 7709 ?STOP_NODES(lists:reverse(Nodes)) 7710 end, 7711 try_tc(otp_7192_1, Pre, Case, Post). 7712 7713do_otp_7192_1([MgcNode, MgNode]) -> 7714 MgMid = {deviceName,"mg"}, 7715 7716 d("[MGC] start the simulator "), 7717 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 7718 7719 d("[MGC] create the event sequence"), 7720 MgcEvSeq = otp71921_mgc_event_sequence(text, tcp, MgMid), 7721 7722 i("wait some time before starting the MGC simulation"), 7723 sleep(1000), 7724 7725 d("[MGC] start the simulation"), 7726 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 7727 7728 i("wait some time before starting the MG simulator"), 7729 sleep(1000), 7730 7731 d("[MG] start the simulator (generator)"), 7732 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 7733 7734 d("[MG] create the event sequence"), 7735 MgEvSeq = otp71921_mg_event_sequence(text, tcp, MgMid), 7736 7737 i("wait some time before starting the MG simulation"), 7738 sleep(1000), 7739 7740 d("[MG] start the simulation"), 7741 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 7742 7743 d("await the generator(s) completion"), 7744 await_completion([MgcId, MgId], 30000), 7745 7746 %% Tell Mgc to stop 7747 i("[MGC] stop generator"), 7748 megaco_test_megaco_generator:stop(Mgc), 7749 7750 %% Tell Mg to stop 7751 i("[MG] stop generator"), 7752 megaco_test_megaco_generator:stop(Mg), 7753 7754 i("done", []), 7755 ok. 7756 7757 7758%% 7759%% MGC generator stuff 7760%% 7761-ifdef(megaco_hipe_special). 7762-define(otp71921_mgc_verify_handle_connect_fun(), 7763 {?MODULE, otp71921_mgc_verify_handle_connect, []}). 7764-define(otp71921_mgc_verify_service_change_req_fun(Mid), 7765 {?MODULE, otp71921_mgc_verify_service_change_req, [Mid]}). 7766-define(otp71921_mgc_verify_notify_req_fun(), 7767 {?MODULE, otp71921_mgc_verify_notify_request, []}). 7768-define(otp71921_mgc_verify_notify_reply_fun(), 7769 {?MODULE, otp71921_mgc_verify_notify_reply, []}). 7770-define(otp71921_mgc_verify_ack_fun(), 7771 {?MODULE, otp71921_mgc_verify_ack, []}). 7772-define(otp71921_mgc_verify_handle_disconnect_fun(), 7773 {?MODULE, otp71921_mgc_verify_handle_disconnect, []}). 7774-else. 7775-define(otp71921_mgc_verify_handle_connect_fun(), 7776 fun otp71921_mgc_verify_handle_connect/1). 7777-define(otp71921_mgc_verify_service_change_req_fun(Mid), 7778 otp71921_mgc_verify_service_change_req_fun(Mid)). 7779-define(otp71921_mgc_verify_notify_req_fun(), 7780 otp71921_mgc_verify_notify_request_fun()). 7781-define(otp71921_mgc_verify_notify_reply_fun(), 7782 fun otp71921_mgc_verify_notify_reply/1). 7783-define(otp71921_mgc_verify_ack_fun(), 7784 fun otp71921_mgc_verify_ack/1). 7785-define(otp71921_mgc_verify_handle_disconnect_fun(), 7786 fun otp71921_mgc_verify_handle_disconnect/1). 7787-endif. 7788 7789otp71921_mgc_event_sequence(text, tcp, MgMid) -> 7790 CTRL = self(), 7791 Mid = {deviceName, "ctrl"}, 7792 RI = [ 7793 {port, 2944}, 7794 {encoding_module, megaco_pretty_text_encoder}, 7795 {encoding_config, []}, 7796 {transport_module, megaco_tcp} 7797 ], 7798 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 7799 NR = fun(Cid, Rid) -> 7800 [otp71921_mgc_notify_request_ar(Rid, Tid, Cid)] 7801 end, 7802 LocalConnectVerify = ?otp71921_mgc_verify_handle_connect_fun(), 7803 ServiceChangeReqVerify = ?otp71921_mgc_verify_service_change_req_fun(Mid), 7804 NotifyReqVerify = ?otp71921_mgc_verify_notify_req_fun(), 7805 NotifyReplyVerify = ?otp71921_mgc_verify_notify_reply_fun(), 7806 AckVerify = ?otp71921_mgc_verify_ack_fun(), 7807 DiscoVerify = ?otp71921_mgc_verify_handle_disconnect_fun(), 7808 EvSeq = [ 7809 {debug, true}, 7810 %% {megaco_trace, max}, 7811 {megaco_trace, disable}, 7812 megaco_start, 7813 {megaco_start_user, Mid, RI, []}, 7814 start_transport, 7815 listen, 7816 7817 %% ANNOUNCE READY 7818 {trigger, fun() -> CTRL ! announce_mgc end}, 7819 7820 {megaco_connect, MgMid}, 7821 {megaco_callback, handle_connect, LocalConnectVerify}, 7822 %% {megaco_callback, handle_connect, RemoteConnectVerify}, 7823 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 7824 {megaco_callback, handle_trans_request, NotifyReqVerify}, 7825 {megaco_callback, handle_trans_request, NotifyReqVerify}, 7826 {megaco_callback, handle_trans_request, NotifyReqVerify}, 7827 {megaco_update_conn_info, request_timer, 1000}, 7828 {megaco_cast, NR(1,1), []}, 7829 7830 {megaco_callback, [{handle_trans_ack, 3, AckVerify}, 7831 {handle_trans_request, 3, NotifyReqVerify}, 7832 {handle_trans_reply, 1, NotifyReplyVerify}]}, 7833 {megaco_callback, handle_disconnect, DiscoVerify}, 7834 {sleep, 1000}, 7835 megaco_stop_user, 7836 megaco_stop 7837 ], 7838 EvSeq. 7839 7840 7841otp71921_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 7842 io:format("otp71921_mgc_verify_handle_connect -> ok" 7843 "~n CH: ~p~n", [CH]), 7844 {ok, CH, ok}; 7845otp71921_mgc_verify_handle_connect(Else) -> 7846 io:format("otp71921_mgc_verify_handle_connect -> unknown" 7847 "~n Else: ~p~n", [Else]), 7848 {error, Else, ok}. 7849 7850otp71921_mgc_verify_service_change_req_fun(Mid) -> 7851 fun(Ev) -> 7852 otp71921_mgc_verify_service_change_req(Ev, Mid) 7853 end. 7854 7855otp71921_mgc_verify_service_change_req( 7856 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 7857 io:format("otp71921_mgc_verify_service_change_req -> ok" 7858 "~n AR: ~p~n", [AR]), 7859 case AR of 7860 #'ActionRequest'{commandRequests = [CR]} -> 7861 case CR of 7862 #'CommandRequest'{command = Cmd} -> 7863 case Cmd of 7864 {serviceChangeReq, 7865 #'ServiceChangeRequest'{terminationID = [Tid], 7866 serviceChangeParms = Parms}} -> 7867 case Tid of 7868 #megaco_term_id{contains_wildcards = false, 7869 id = ["root"]} -> 7870 case Parms of 7871 #'ServiceChangeParm'{ 7872 serviceChangeMethod = restart, 7873 serviceChangeReason = [[$9,$0,$1|_]]} -> 7874 Reply = 7875 {discard_ack, 7876 [otp71921_mgc_service_change_reply_ar(Mid, 1)]}, 7877 {ok, AR, Reply}; 7878 _ -> 7879 Err = {invalid_SCP, Parms}, 7880 ED = otp71921_err_desc(Parms), 7881 ErrReply = {discard_ack, 7882 ED}, 7883 {error, Err, ErrReply} 7884 end; 7885 _ -> 7886 Err = {invalid_termination_id, Tid}, 7887 ED = otp71921_err_desc(Tid), 7888 ErrReply = {discard_ack, ED}, 7889 {error, Err, ErrReply} 7890 end; 7891 _ -> 7892 Err = {invalid_command, Cmd}, 7893 ED = otp71921_err_desc(Cmd), 7894 ErrReply = {discard_ack, ED}, 7895 {error, Err, ErrReply} 7896 end; 7897 _ -> 7898 Err = {invalid_command_request, CR}, 7899 ED = otp71921_err_desc(CR), 7900 ErrReply = {discard_ack, ED}, 7901 {error, Err, ErrReply} 7902 end; 7903 _ -> 7904 Err = {invalid_action_request, AR}, 7905 ED = otp71921_err_desc(AR), 7906 ErrReply = {discard_ack, ED}, 7907 {error, Err, ErrReply} 7908 end; 7909otp71921_mgc_verify_service_change_req(Else, _Mid) -> 7910 io:format("otp71921_mgc_verify_service_change_req -> unknown" 7911 "~n Else: ~p~n", [Else]), 7912 ED = otp71921_err_desc(Else), 7913 ErrReply = {discard_ack, ED}, 7914 {error, Else, ErrReply}. 7915 7916otp71921_mgc_verify_notify_request_fun() -> 7917 fun(Ev) -> 7918 otp71921_mgc_verify_notify_request(Ev) 7919 end. 7920 7921otp71921_mgc_verify_notify_request( 7922 {handle_trans_request, _, ?VERSION, [AR]}) -> 7923 io:format("otp71921_mgc_verify_notify_request -> ok" 7924 "~n AR: ~p~n", [AR]), 7925 case AR of 7926 #'ActionRequest'{contextId = 1 = Cid, 7927 commandRequests = [CR]} -> 7928 #'CommandRequest'{command = Cmd} = CR, 7929 {notifyReq, NR} = Cmd, 7930 #'NotifyRequest'{terminationID = [Tid], 7931 observedEventsDescriptor = OED, 7932 errorDescriptor = asn1_NOVALUE} = NR, 7933 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 7934 #'ObservedEvent'{eventName = "al/of"} = OE, 7935 HandleAck = {handle_sloppy_ack, kalle}, 7936 Reply = {HandleAck, 7937 [otp71921_mgc_notify_reply_ar(Cid, Tid)]}, 7938 {ok, AR, Reply}; 7939 #'ActionRequest'{contextId = 2 = Cid, 7940 commandRequests = [CR]} -> 7941 #'CommandRequest'{command = Cmd} = CR, 7942 {notifyReq, NR} = Cmd, 7943 #'NotifyRequest'{terminationID = [Tid], 7944 observedEventsDescriptor = OED, 7945 errorDescriptor = asn1_NOVALUE} = NR, 7946 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 7947 #'ObservedEvent'{eventName = "al/of"} = OE, 7948 Reply = {discard_ack, [otp71921_mgc_notify_reply_ar(Cid, Tid)]}, 7949 {ok, AR, Reply}; 7950 _ -> 7951 ED = otp71921_err_desc(AR), 7952 ErrReply = {discard_ack, ED}, 7953 {error, AR, ErrReply} 7954 end; 7955otp71921_mgc_verify_notify_request(Else) -> 7956 io:format("otp71921_mgc_verify_notify_request -> unknown" 7957 "~n Else: ~p~n", [Else]), 7958 ED = otp71921_err_desc(Else), 7959 ErrReply = {discard_ack, ED}, 7960 {error, Else, ErrReply}. 7961 7962otp71921_mgc_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 7963 {ok, [AR]}, _}) -> 7964 io:format("otp71921_mgc_verify_notify_reply -> ok" 7965 "~n AR: ~p~n", [AR]), 7966 {ok, AR, ok}; 7967otp71921_mgc_verify_notify_reply({handle_trans_reply, CH, ?VERSION, 7968 UnknownResult, _}) -> 7969 io:format("otp71921_mgc_verify_notify_reply -> unknown result" 7970 "~n UnknownResult: ~p~n", [UnknownResult]), 7971 {error, {unknown_reply_result, UnknownResult, CH}, ok}; 7972otp71921_mgc_verify_notify_reply(Else) -> 7973 io:format("otp71921_mgc_verify_notify_reply -> unknown" 7974 "~n Else: ~p~n", [Else]), 7975 {error, {unknown_reply, Else}, ok}. 7976 7977otp71921_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 7978 io:format("otp71921_mgc_verify_ack -> ok" 7979 "~n CH: ~p" 7980 "~n", [CH]), 7981 {ok, CH, ok}; 7982otp71921_mgc_verify_ack(Else) -> 7983 io:format("otp71921_mgc_verify_ack -> unknown" 7984 "~n Else: ~p~n", [Else]), 7985 {error, Else, ok}. 7986 7987otp71921_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 7988 io:format("otp71921_mgc_verify_handle_disconnect -> ok" 7989 "~n CH: ~p" 7990 "~n R: ~p" 7991 "~n", [CH, R]), 7992 {ok, CH, ok}; 7993otp71921_mgc_verify_handle_disconnect(Else) -> 7994 io:format("otp71921_mgc_verify_handle_disconnect -> unknown" 7995 "~n Else: ~p~n", [Else]), 7996 {error, Else, ok}. 7997 7998 7999otp71921_mgc_service_change_reply_ar(Mid, Cid) -> 8000 SCRP = cre_serviceChangeResParm(Mid), 8001 SCRes = cre_serviceChangeResult(SCRP), 8002 Root = #megaco_term_id{id = ["root"]}, 8003 SCR = cre_serviceChangeReply([Root], SCRes), 8004 CR = cre_cmdReply(SCR), 8005 cre_actionReply(Cid, [CR]). 8006 8007%% otp71921_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 8008%% AR = otp71921_mgc_service_change_reply_ar(Mid, Cid), 8009%% TRes = cre_transResult([AR]), 8010%% TR = cre_transReply(TransId, TRes), 8011%% Trans = cre_transaction(TR), 8012%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8013%% cre_megacoMessage(Mess). 8014 8015otp71921_mgc_notify_request_ar(Rid, Tid, Cid) -> 8016 TT = cre_timeNotation("19990729", "44000000"), 8017 Ev = cre_obsEvent("al/of", TT), 8018 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 8019 NR = cre_notifyReq([Tid], EvsDesc), 8020 CMD = cre_command(NR), 8021 CR = cre_cmdReq(CMD), 8022 cre_actionReq(Cid, [CR]). 8023 8024otp71921_mgc_notify_reply_ar(Cid, TermId) -> 8025 NR = cre_notifyReply([TermId]), 8026 CR = cre_cmdReply(NR), 8027 cre_actionReply(Cid, [CR]). 8028 8029%% otp71921_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 8030%% AR = otp71921_mgc_notify_reply_ar(Cid, TermId), 8031%% TRes = cre_transResult([AR]), 8032%% TR = cre_transReply(TransId, TRes), 8033%% Trans = cre_transaction(TR), 8034%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8035%% cre_megacoMessage(Mess). 8036 8037 8038%% 8039%% MG generator stuff 8040%% 8041-ifdef(megaco_hipe_special). 8042-define(otp71921_mg_verify_handle_connect_fun(), 8043 {?MODULE, otp71921_mg_verify_handle_connect, []}). 8044-define(otp71921_mg_verify_service_change_reply_fun(), 8045 {?MODULE, otp71921_mg_verify_service_change_reply, []}). 8046-define(otp71921_mg_verify_notify_req_fun(), 8047 {?MODULE, otp71921_mgc_verify_notify_request, []}). 8048-define(otp71921_mg_verify_notify_reply_fun(), 8049 {?MODULE, otp71921_mg_verify_notify_reply, []}). 8050-else. 8051-define(otp71921_mg_verify_handle_connect_fun(), 8052 fun otp71921_mg_verify_handle_connect/1). 8053-define(otp71921_mg_verify_service_change_reply_fun(), 8054 fun otp71921_mg_verify_service_change_reply/1). 8055-define(otp71921_mg_verify_notify_req_fun(), 8056 otp71921_mgc_verify_notify_request_fun()). 8057-define(otp71921_mg_verify_notify_reply_fun(), 8058 fun otp71921_mg_verify_notify_reply/1). 8059-endif. 8060 8061otp71921_mg_event_sequence(text, tcp, Mid) -> 8062 RI = [ 8063 {port, 2944}, 8064 {encoding_module, megaco_pretty_text_encoder}, 8065 {encoding_config, []}, 8066 {transport_module, megaco_tcp} 8067 ], 8068 ServiceChangeReq = [otp71921_mg_service_change_request_ar(Mid, 1)], 8069 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 8070 NR = fun(Cid, Rid) -> 8071 [otp71921_mg_notify_request_ar(Rid, Tid, Cid)] 8072 end, 8073 ConnectVerify = ?otp71921_mg_verify_handle_connect_fun(), 8074 ServiceChangeReplyVerify = ?otp71921_mg_verify_service_change_reply_fun(), 8075 NotifyReqVerify = ?otp71921_mg_verify_notify_req_fun(), 8076 NotifyReplyVerify = ?otp71921_mg_verify_notify_reply_fun(), 8077 EvSeq = [ 8078 {debug, true}, 8079 megaco_start, 8080 {megaco_start_user, Mid, RI, []}, 8081 start_transport, 8082 %% {megaco_trace, max}, 8083 {megaco_trace, disable}, 8084 {megaco_system_info, users}, 8085 {megaco_system_info, connections}, 8086 connect, 8087 {megaco_callback, handle_connect, ConnectVerify}, 8088 megaco_connect, 8089 {megaco_cast, ServiceChangeReq, []}, 8090 {megaco_callback, handle_connect, ConnectVerify}, 8091 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 8092 {sleep, 1000}, 8093 {megaco_system_info, users}, 8094 {megaco_system_info, connections}, 8095 {sleep, 1000}, 8096 {megaco_update_conn_info, auto_ack, true}, 8097 {megaco_update_conn_info, trans_ack_maxcount, 10}, 8098 {megaco_update_conn_info, trans_req_maxcount, 10}, 8099 {megaco_update_conn_info, trans_timer, 1000}, 8100 {megaco_update_conn_info, trans_ack, true}, 8101 {megaco_update_conn_info, trans_req, true}, 8102 {megaco_conn_info, all}, 8103 {megaco_cast, NR(1,1), []}, 8104 {megaco_cast, NR(1,2), []}, 8105 {megaco_cast, NR(1,3), []}, 8106 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8107 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8108 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8109 {megaco_update_conn_info, trans_timer, 120000}, 8110 {megaco_cast, NR(2,1), []}, 8111 {megaco_cast, NR(2,2), []}, 8112 {megaco_cast, NR(2,3), []}, 8113 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8114 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8115 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8116 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8117 {sleep, 3000}, 8118 megaco_stop_user, 8119 megaco_stop, 8120 {sleep, 1000} 8121 ], 8122 EvSeq. 8123 8124otp71921_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 8125 io:format("otp71921_mg_verify_handle_connect -> ok" 8126 "~n CH: ~p~n", [CH]), 8127 {ok, CH, ok}; 8128otp71921_mg_verify_handle_connect(Else) -> 8129 io:format("otp71921_mg_verify_handle_connect -> unknown" 8130 "~n Else: ~p~n", [Else]), 8131 {error, Else, ok}. 8132 8133otp71921_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 8134 {ok, [AR]}, _}) -> 8135 io:format("otp71921_mg_verify_service_change_reply -> ok" 8136 "~n AR: ~p~n", [AR]), 8137 case AR of 8138 #'ActionReply'{commandReply = [SCR]} -> 8139 case SCR of 8140 {serviceChangeReply, 8141 #'ServiceChangeReply'{terminationID = [Tid], 8142 serviceChangeResult = Res}} -> 8143 case Tid of 8144 #megaco_term_id{contains_wildcards = false, 8145 id = ["root"]} -> 8146 case Res of 8147 {serviceChangeResParms, 8148 #'ServiceChangeResParm'{ 8149 serviceChangeMgcId = _RemoteMid}} -> 8150 {ok, AR, ok}; 8151 {Tag, Val} -> 8152 Err = {invalid_service_change_result, 8153 Tag, Val}, 8154 {error, Err, ok} 8155 end; 8156 _ -> 8157 Err = {invalid_termination_id, Tid}, 8158 {error, Err, ok} 8159 end; 8160 {Tag, Val} -> 8161 Err = {invalid_command_reply, Tag, Val}, 8162 {error, Err, ok} 8163 end; 8164 _ -> 8165 Err = {invalid_action_reply, AR}, 8166 {error, Err, ok} 8167 end; 8168otp71921_mg_verify_service_change_reply(Else) -> 8169 io:format("otp71921_mg_verify_service_change_reply -> unknown" 8170 "~n Else: ~p~n", [Else]), 8171 {error, Else, ok}. 8172 8173%% otp71921_mg_verify_notify_request_fun() -> 8174%% fun(Ev) -> 8175%% otp71921_mg_verify_notify_request(Ev) 8176%% end. 8177 8178%% otp71921_mg_verify_notify_request( 8179%% {handle_trans_request, _, ?VERSION, [AR]}) -> 8180%% io:format("otp71921_mg_verify_notify_request -> ok" 8181%% "~n AR: ~p~n", [AR]), 8182%% case AR of 8183%% #'ActionRequest'{contextId = 1 = Cid, 8184%% commandRequests = [CR]} -> 8185%% #'CommandRequest'{command = Cmd} = CR, 8186%% {notifyReq, NR} = Cmd, 8187%% #'NotifyRequest'{terminationID = [Tid], 8188%% observedEventsDescriptor = OED, 8189%% errorDescriptor = asn1_NOVALUE} = NR, 8190%% #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 8191%% #'ObservedEvent'{eventName = "al/of"} = OE, 8192%% Reply = {discard_ack, [otp71921_mg_notify_reply_ar(Cid, Tid)]}, 8193%% {ok, AR, Reply}; 8194%% _ -> 8195%% ED = otp71921_err_desc(AR), 8196%% ErrReply = {discard_ack, ED}, 8197%% {error, AR, ErrReply} 8198%% end; 8199%% otp71921_mg_verify_notify_request(Else) -> 8200%% io:format("otp71921_mg_verify_notify_request -> unknown" 8201%% "~n Else: ~p~n", [Else]), 8202%% ED = otp71921_err_desc(Else), 8203%% ErrReply = {discard_ack, ED}, 8204%% {error, Else, ErrReply}. 8205 8206otp71921_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 8207 {ok, [AR]}, _}) -> 8208 io:format("otp71921_mg_verify_notify_reply -> ok" 8209 "~n AR: ~p~n", [AR]), 8210 {ok, AR, ok}; 8211otp71921_mg_verify_notify_reply(Else) -> 8212 io:format("otp71921_mg_verify_notify_reply -> unknown" 8213 "~n Else: ~p~n", [Else]), 8214 {error, Else, ok}. 8215 8216otp71921_mg_service_change_request_ar(_Mid, Cid) -> 8217 Prof = cre_serviceChangeProf("resgw", 1), 8218 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 8219 Root = #megaco_term_id{id = ["root"]}, 8220 SCR = cre_serviceChangeReq([Root], SCP), 8221 CMD = cre_command(SCR), 8222 CR = cre_cmdReq(CMD), 8223 cre_actionReq(Cid, [CR]). 8224 8225%% otp71921_mg_service_change_request_msg(Mid, TransId, Cid) -> 8226%% AR = otp71921_mg_service_change_request_ar(Mid, Cid), 8227%% TR = cre_transReq(TransId, [AR]), 8228%% Trans = cre_transaction(TR), 8229%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8230%% cre_megacoMessage(Mess). 8231 8232%% otp71921_mg_notify_reply_ar(Cid, TermId) -> 8233%% NR = cre_notifyReply([TermId]), 8234%% CR = cre_cmdReply(NR), 8235%% cre_actionReply(Cid, [CR]). 8236 8237otp71921_mg_notify_request_ar(Rid, Tid, Cid) -> 8238 TT = cre_timeNotation("19990729", "22000000"), 8239 Ev = cre_obsEvent("al/of", TT), 8240 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 8241 NR = cre_notifyReq([Tid], EvsDesc), 8242 CMD = cre_command(NR), 8243 CR = cre_cmdReq(CMD), 8244 cre_actionReq(Cid, [CR]). 8245 8246%% otp71921_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 8247%% AR = otp71921_mg_notify_request_ar(Rid, TermId, Cid), 8248%% TR = cre_transReq(TransId, [AR]), 8249%% Trans = cre_transaction(TR), 8250%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8251%% cre_megacoMessage(Mess). 8252 8253 8254%% 8255%% Common functions for the multi_trans_req_timeout test case 8256%% 8257 8258otp71921_err_desc(T) -> 8259 EC = ?megaco_internal_gateway_error, 8260 ET = lists:flatten(io_lib:format("~w",[T])), 8261 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 8262 8263 8264%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 8265 8266otp_7192_2(suite) -> 8267 []; 8268otp_7192_2(doc) -> 8269 []; 8270otp_7192_2(Config) when is_list(Config) -> 8271 Pre = fun() -> 8272 MgcNode = make_node_name(mgc), 8273 MgNode = make_node_name(mg), 8274 d("start nodes: " 8275 "~n MGC Node: ~p" 8276 "~n MG Node: ~p", 8277 [MgcNode, MgNode]), 8278 Nodes = [MgcNode, MgNode], 8279 ok = ?START_NODES(Nodes), 8280 Nodes 8281 end, 8282 Case = fun do_otp_7192_2/1, 8283 Post = fun(Nodes) -> 8284 d("stop nodes"), 8285 ?STOP_NODES(lists:reverse(Nodes)) 8286 end, 8287 try_tc(otp_7192_2, Pre, Case, Post). 8288 8289do_otp_7192_2([MgcNode, MgNode]) -> 8290 8291 MgMid = {deviceName,"mg"}, 8292 8293 d("[MGC] start the simulator "), 8294 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 8295 8296 d("[MGC] create the event sequence"), 8297 MgcEvSeq = otp71922_mgc_event_sequence(text, tcp, MgMid), 8298 8299 i("wait some time before starting the MGC simulation"), 8300 sleep(1000), 8301 8302 d("[MGC] start the simulation"), 8303 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 8304 8305 i("wait some time before starting the MG simulator"), 8306 sleep(1000), 8307 8308 d("[MG] start the simulator (generator)"), 8309 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 8310 8311 d("[MG] create the event sequence"), 8312 MgEvSeq = otp71922_mg_event_sequence(text, tcp, MgMid), 8313 8314 i("wait some time before starting the MG simulation"), 8315 sleep(1000), 8316 8317 d("[MG] start the simulation"), 8318 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 8319 8320 d("await the generator(s) completion"), 8321 await_completion([MgcId, MgId], 30000), 8322 8323 %% Tell Mgc to stop 8324 i("[MGC] stop generator"), 8325 megaco_test_megaco_generator:stop(Mgc), 8326 8327 %% Tell Mg to stop 8328 i("[MG] stop generator"), 8329 megaco_test_megaco_generator:stop(Mg), 8330 8331 i("done", []), 8332 ok. 8333 8334 8335%% 8336%% MGC generator stuff 8337%% 8338-ifdef(megaco_hipe_special). 8339-define(otp71922_mgc_verify_handle_connect_fun(), 8340 {?MODULE, otp71922_mgc_verify_handle_connect, []}). 8341-define(otp71922_mgc_verify_service_change_req_fun(Mid), 8342 {?MODULE, otp71922_mgc_verify_service_change_req, [Mid]}). 8343-define(otp71922_mgc_verify_notify_req_fun(), 8344 {?MODULE, otp71922_mgc_verify_notify_request, []}). 8345-define(otp71922_mgc_verify_notify_reply_fun(), 8346 {?MODULE, otp71922_mgc_verify_notify_reply, []}). 8347-define(otp71922_mgc_verify_ack_fun(), 8348 {?MODULE, otp71922_mgc_verify_ack, []}). 8349-define(otp71922_mgc_verify_handle_disconnect_fun(), 8350 {?MODULE, otp71922_mgc_verify_handle_disconnect, []}). 8351-else. 8352-define(otp71922_mgc_verify_handle_connect_fun(), 8353 fun otp71922_mgc_verify_handle_connect/1). 8354-define(otp71922_mgc_verify_service_change_req_fun(Mid), 8355 otp71922_mgc_verify_service_change_req_fun(Mid)). 8356-define(otp71922_mgc_verify_notify_req_fun(), 8357 otp71922_mgc_verify_notify_request_fun()). 8358-define(otp71922_mgc_verify_notify_reply_fun(), 8359 fun otp71922_mgc_verify_notify_reply/1). 8360-define(otp71922_mgc_verify_ack_fun(), 8361 fun otp71922_mgc_verify_ack/1). 8362-define(otp71922_mgc_verify_handle_disconnect_fun(), 8363 fun otp71922_mgc_verify_handle_disconnect/1). 8364-endif. 8365 8366otp71922_mgc_event_sequence(text, tcp, MgMid) -> 8367 CTRL = self(), 8368 Mid = {deviceName, "ctrl"}, 8369 RI = [ 8370 {port, 2944}, 8371 {encoding_module, megaco_pretty_text_encoder}, 8372 {encoding_config, []}, 8373 {transport_module, megaco_tcp} 8374 ], 8375 Tid = #megaco_term_id{id = ["00000000","00000100","01101101"]}, 8376 NR = fun(Cid, Rid) -> 8377 [otp71922_mgc_notify_request_ar(Rid, Tid, Cid)] 8378 end, 8379 LocalConnectVerify = ?otp71922_mgc_verify_handle_connect_fun(), 8380 ServiceChangeReqVerify = ?otp71922_mgc_verify_service_change_req_fun(Mid), 8381 NotifyReqVerify = ?otp71922_mgc_verify_notify_req_fun(), 8382 NotifyReplyVerify = ?otp71922_mgc_verify_notify_reply_fun(), 8383 AckVerify = ?otp71922_mgc_verify_ack_fun(), 8384 DiscoVerify = ?otp71922_mgc_verify_handle_disconnect_fun(), 8385 EvSeq = [ 8386 {debug, true}, 8387 %% {megaco_trace, max}, 8388 {megaco_trace, disable}, 8389 megaco_start, 8390 {megaco_start_user, Mid, RI, []}, 8391 start_transport, 8392 listen, 8393 8394 %% ANNOUNCE READY 8395 {trigger, fun() -> CTRL ! announce_mgc end}, 8396 8397 {megaco_connect, MgMid}, 8398 {megaco_callback, handle_connect, LocalConnectVerify}, 8399 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 8400 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8401 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8402 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8403 {megaco_update_conn_info, request_timer, 1000}, 8404 {megaco_cast, NR(1,1), []}, 8405 8406 {megaco_callback, [{handle_trans_ack, 3, AckVerify}, 8407 {handle_trans_request, 3, NotifyReqVerify}, 8408 {handle_trans_reply, 1, NotifyReplyVerify}]}, 8409 {megaco_callback, handle_disconnect, DiscoVerify}, 8410 {sleep, 1000}, 8411 megaco_stop_user, 8412 megaco_stop 8413 ], 8414 EvSeq. 8415 8416 8417otp71922_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 8418 i("received expected handle_connect with" 8419 "~n CH: ~p" 8420 "~n => force a 2 second sleep before return", [CH]), 8421 {ok, timer:seconds(2), CH, ok}; 8422otp71922_mgc_verify_handle_connect(Else) -> 8423 e("otp71922_mgc_verify_handle_connect -> invalid handle-connect: " 8424 "~n Extected: handle_connect" 8425 "~n Received: ~p", [Else]), 8426 {error, Else, ok}. 8427 8428otp71922_mgc_verify_service_change_req_fun(Mid) -> 8429 fun(Ev) -> 8430 otp71922_mgc_verify_service_change_req(Ev, Mid) 8431 end. 8432 8433otp71922_mgc_verify_service_change_req( 8434 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 8435 i("otp71922_mgc_verify_service_change_req -> ok" 8436 "~n AR: ~p", [AR]), 8437 case AR of 8438 #'ActionRequest'{commandRequests = [CR]} -> 8439 case CR of 8440 #'CommandRequest'{command = Cmd} -> 8441 case Cmd of 8442 {serviceChangeReq, 8443 #'ServiceChangeRequest'{terminationID = [Tid], 8444 serviceChangeParms = Parms}} -> 8445 case Tid of 8446 #megaco_term_id{contains_wildcards = false, 8447 id = ["root"]} -> 8448 case Parms of 8449 #'ServiceChangeParm'{ 8450 serviceChangeMethod = restart, 8451 serviceChangeReason = [[$9,$0,$1|_]]} -> 8452 Reply = 8453 {discard_ack, 8454 [otp71922_mgc_service_change_reply_ar(Mid, 1)]}, 8455 {ok, AR, Reply}; 8456 _ -> 8457 Err = {invalid_SCP, Parms}, 8458 ED = otp71922_err_desc(Parms), 8459 ErrReply = {discard_ack, 8460 ED}, 8461 {error, Err, ErrReply} 8462 end; 8463 _ -> 8464 Err = {invalid_termination_id, Tid}, 8465 ED = otp71922_err_desc(Tid), 8466 ErrReply = {discard_ack, ED}, 8467 {error, Err, ErrReply} 8468 end; 8469 _ -> 8470 Err = {invalid_command, Cmd}, 8471 ED = otp71922_err_desc(Cmd), 8472 ErrReply = {discard_ack, ED}, 8473 {error, Err, ErrReply} 8474 end; 8475 _ -> 8476 Err = {invalid_command_request, CR}, 8477 ED = otp71922_err_desc(CR), 8478 ErrReply = {discard_ack, ED}, 8479 {error, Err, ErrReply} 8480 end; 8481 _ -> 8482 Err = {invalid_action_request, AR}, 8483 ED = otp71922_err_desc(AR), 8484 ErrReply = {discard_ack, ED}, 8485 {error, Err, ErrReply} 8486 end; 8487otp71922_mgc_verify_service_change_req(Else, _Mid) -> 8488 io:format("otp71922_mgc_verify_service_change_req -> unknown" 8489 "~n Else: ~p~n", [Else]), 8490 ED = otp71922_err_desc(Else), 8491 ErrReply = {discard_ack, ED}, 8492 {error, Else, ErrReply}. 8493 8494otp71922_mgc_verify_notify_request_fun() -> 8495 fun(Ev) -> 8496 otp71922_mgc_verify_notify_request(Ev) 8497 end. 8498 8499otp71922_mgc_verify_notify_request( 8500 {handle_trans_request, _, ?VERSION, [AR]}) -> 8501 io:format("otp71922_mgc_verify_notify_request -> ok" 8502 "~n AR: ~p~n", [AR]), 8503 case AR of 8504 #'ActionRequest'{contextId = 1 = Cid, 8505 commandRequests = [CR]} -> 8506 #'CommandRequest'{command = Cmd} = CR, 8507 {notifyReq, NR} = Cmd, 8508 #'NotifyRequest'{terminationID = [Tid], 8509 observedEventsDescriptor = OED, 8510 errorDescriptor = asn1_NOVALUE} = NR, 8511 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 8512 #'ObservedEvent'{eventName = "al/of"} = OE, 8513 HandleAck = {handle_sloppy_ack, kalle}, 8514 Reply = {HandleAck, 8515 [otp71922_mgc_notify_reply_ar(Cid, Tid)]}, 8516 {ok, AR, Reply}; 8517 #'ActionRequest'{contextId = 2 = Cid, 8518 commandRequests = [CR]} -> 8519 #'CommandRequest'{command = Cmd} = CR, 8520 {notifyReq, NR} = Cmd, 8521 #'NotifyRequest'{terminationID = [Tid], 8522 observedEventsDescriptor = OED, 8523 errorDescriptor = asn1_NOVALUE} = NR, 8524 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 8525 #'ObservedEvent'{eventName = "al/of"} = OE, 8526 Reply = {discard_ack, [otp71922_mgc_notify_reply_ar(Cid, Tid)]}, 8527 {ok, AR, Reply}; 8528 _ -> 8529 ED = otp71922_err_desc(AR), 8530 ErrReply = {discard_ack, ED}, 8531 {error, AR, ErrReply} 8532 end; 8533otp71922_mgc_verify_notify_request(Else) -> 8534 io:format("otp71922_mgc_verify_notify_request -> unknown" 8535 "~n Else: ~p~n", [Else]), 8536 ED = otp71922_err_desc(Else), 8537 ErrReply = {discard_ack, ED}, 8538 {error, Else, ErrReply}. 8539 8540otp71922_mgc_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 8541 {ok, [AR]}, _}) -> 8542 io:format("otp71922_mgc_verify_notify_reply -> ok" 8543 "~n AR: ~p~n", [AR]), 8544 {ok, AR, ok}; 8545otp71922_mgc_verify_notify_reply({handle_trans_reply, CH, ?VERSION, 8546 UnknownResult, _}) -> 8547 io:format("otp71922_mgc_verify_notify_reply -> unknown result" 8548 "~n UnknownResult: ~p~n", [UnknownResult]), 8549 {error, {unknown_reply_result, UnknownResult, CH}, ok}; 8550otp71922_mgc_verify_notify_reply(Else) -> 8551 io:format("otp71922_mgc_verify_notify_reply -> unknown" 8552 "~n Else: ~p~n", [Else]), 8553 {error, {unknown_reply, Else}, ok}. 8554 8555otp71922_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 8556 io:format("otp71922_mgc_verify_ack -> ok" 8557 "~n CH: ~p" 8558 "~n", [CH]), 8559 {ok, CH, ok}; 8560otp71922_mgc_verify_ack(Else) -> 8561 io:format("otp71922_mgc_verify_ack -> unknown" 8562 "~n Else: ~p~n", [Else]), 8563 {error, Else, ok}. 8564 8565otp71922_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 8566 io:format("otp71922_mgc_verify_handle_disconnect -> ok" 8567 "~n CH: ~p" 8568 "~n R: ~p" 8569 "~n", [CH, R]), 8570 {ok, CH, ok}; 8571otp71922_mgc_verify_handle_disconnect(Else) -> 8572 io:format("otp71922_mgc_verify_handle_disconnect -> unknown" 8573 "~n Else: ~p~n", [Else]), 8574 {error, Else, ok}. 8575 8576 8577otp71922_mgc_service_change_reply_ar(Mid, Cid) -> 8578 SCRP = cre_serviceChangeResParm(Mid), 8579 SCRes = cre_serviceChangeResult(SCRP), 8580 Root = #megaco_term_id{id = ["root"]}, 8581 SCR = cre_serviceChangeReply([Root], SCRes), 8582 CR = cre_cmdReply(SCR), 8583 cre_actionReply(Cid, [CR]). 8584 8585%% otp71922_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 8586%% AR = otp71922_mgc_service_change_reply_ar(Mid, Cid), 8587%% TRes = cre_transResult([AR]), 8588%% TR = cre_transReply(TransId, TRes), 8589%% Trans = cre_transaction(TR), 8590%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8591%% cre_megacoMessage(Mess). 8592 8593otp71922_mgc_notify_request_ar(Rid, Tid, Cid) -> 8594 TT = cre_timeNotation("19990729", "44000000"), 8595 Ev = cre_obsEvent("al/of", TT), 8596 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 8597 NR = cre_notifyReq([Tid], EvsDesc), 8598 CMD = cre_command(NR), 8599 CR = cre_cmdReq(CMD), 8600 cre_actionReq(Cid, [CR]). 8601 8602otp71922_mgc_notify_reply_ar(Cid, TermId) -> 8603 NR = cre_notifyReply([TermId]), 8604 CR = cre_cmdReply(NR), 8605 cre_actionReply(Cid, [CR]). 8606 8607%% otp71922_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 8608%% AR = otp71922_mgc_notify_reply_ar(Cid, TermId), 8609%% TRes = cre_transResult([AR]), 8610%% TR = cre_transReply(TransId, TRes), 8611%% Trans = cre_transaction(TR), 8612%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8613%% cre_megacoMessage(Mess). 8614 8615 8616%% 8617%% MG generator stuff 8618%% 8619-ifdef(megaco_hipe_special). 8620-define(otp71922_mg_verify_handle_connect_fun(), 8621 {?MODULE, otp71922_mg_verify_handle_connect, []}). 8622-define(otp71922_mg_verify_service_change_reply_fun(), 8623 {?MODULE, otp71922_mg_verify_service_change_reply, []}). 8624-define(otp71922_mg_verify_notify_req_fun(), 8625 {?MODULE, otp71922_mgc_verify_notify_request, []}). 8626-define(otp71922_mg_verify_notify_reply_fun(), 8627 {?MODULE, otp71922_mg_verify_notify_reply, []}). 8628-else. 8629-define(otp71922_mg_verify_handle_connect_fun(), 8630 fun otp71922_mg_verify_handle_connect/1). 8631-define(otp71922_mg_verify_service_change_reply_fun(), 8632 fun otp71922_mg_verify_service_change_reply/1). 8633-define(otp71922_mg_verify_notify_req_fun(), 8634 otp71922_mgc_verify_notify_request_fun()). 8635-define(otp71922_mg_verify_notify_reply_fun(), 8636 fun otp71922_mg_verify_notify_reply/1). 8637-endif. 8638 8639otp71922_mg_event_sequence(text, tcp, Mid) -> 8640 RI = [ 8641 {port, 2944}, 8642 {encoding_module, megaco_pretty_text_encoder}, 8643 {encoding_config, []}, 8644 {transport_module, megaco_tcp} 8645 ], 8646 ServiceChangeReq = [otp71922_mg_service_change_request_ar(Mid, 1)], 8647 %% This is so that we can match notify request and reply 8648 Tid1 = #megaco_term_id{id = ["00000000","00000001","01101101"]}, 8649 Tid2 = #megaco_term_id{id = ["00000000","00000010","01101101"]}, 8650 Tid3 = #megaco_term_id{id = ["00000000","00000011","01101101"]}, 8651 NR = fun(Cid, Rid, Tid) -> 8652 [otp71922_mg_notify_request_ar(Rid, Tid, Cid)] 8653 end, 8654 ConnectVerify = ?otp71922_mg_verify_handle_connect_fun(), 8655 ServiceChangeReplyVerify = ?otp71922_mg_verify_service_change_reply_fun(), 8656 NotifyReqVerify = ?otp71922_mg_verify_notify_req_fun(), 8657 NotifyReplyVerify = ?otp71922_mg_verify_notify_reply_fun(), 8658 EvSeq = [ 8659 {debug, true}, 8660 megaco_start, 8661 {megaco_start_user, Mid, RI, []}, 8662 start_transport, 8663 %% {megaco_trace, max}, 8664 {megaco_trace, disable}, 8665 {megaco_system_info, users}, 8666 {megaco_system_info, connections}, 8667 connect, 8668 {megaco_callback, handle_connect, ConnectVerify}, 8669 megaco_connect, 8670 {megaco_cast, ServiceChangeReq, []}, 8671 {megaco_callback, handle_connect, ConnectVerify}, 8672 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 8673 {sleep, 1000}, 8674 {megaco_system_info, users}, 8675 {megaco_system_info, connections}, 8676 {sleep, 1000}, 8677 {megaco_update_conn_info, auto_ack, true}, 8678 {megaco_update_conn_info, trans_ack_maxcount, 10}, 8679 {megaco_update_conn_info, trans_req_maxcount, 10}, 8680 {megaco_update_conn_info, trans_timer, 1000}, 8681 {megaco_update_conn_info, trans_ack, true}, 8682 {megaco_update_conn_info, trans_req, true}, 8683 {megaco_conn_info, all}, 8684 {megaco_cast, NR(1,1,Tid1), []}, 8685 {megaco_cast, NR(1,2,Tid2), []}, 8686 {megaco_cast, NR(1,3,Tid3), []}, 8687 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8688 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8689 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8690 {megaco_update_conn_info, trans_timer, 120000}, 8691 {megaco_cast, NR(2,1,Tid1), []}, 8692 {megaco_cast, NR(2,2,Tid2), []}, 8693 {megaco_cast, NR(2,3,Tid3), []}, 8694 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8695 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8696 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8697 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8698 {sleep, 3000}, 8699 megaco_stop_user, 8700 megaco_stop, 8701 {sleep, 1000} 8702 ], 8703 EvSeq. 8704 8705otp71922_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 8706 i("received expected handle_connect:" 8707 "~n CH: ~p", [CH]), 8708 {ok, CH, ok}; 8709otp71922_mg_verify_handle_connect(Else) -> 8710 e("otp71922_mg_verify_handle_connect -> received unexpected:" 8711 "~n Expected: handle_connect" 8712 "~n Received: ~p", [Else]), 8713 {error, Else, ok}. 8714 8715otp71922_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 8716 {ok, [AR]}, _}) -> 8717 case AR of 8718 #'ActionReply'{commandReply = [SCR]} -> 8719 case SCR of 8720 {serviceChangeReply, 8721 #'ServiceChangeReply'{terminationID = [Tid], 8722 serviceChangeResult = Res}} -> 8723 case Tid of 8724 #megaco_term_id{contains_wildcards = false, 8725 id = ["root"]} -> 8726 case Res of 8727 {serviceChangeResParms, 8728 #'ServiceChangeResParm'{ 8729 serviceChangeMgcId = _RemoteMid}} -> 8730 i("received expected handle_trans_reply " 8731 "(service change) with ok" 8732 "~n AR: ~p", [AR]), 8733 {ok, AR, ok}; 8734 {Tag, Val} -> 8735 e("received expected handle_trans_reply " 8736 "(service change) with error" 8737 "~n Tag: ~p" 8738 "~n Val: ~p", [Tag, Val]), 8739 Err = {invalid_service_change_result, 8740 Tag, Val}, 8741 {error, Err, ok} 8742 end; 8743 _ -> 8744 e("received expected handle_trans_reply " 8745 "(service change) with error" 8746 "~n Tid: ~p", [Tid]), 8747 Err = {invalid_termination_id, Tid}, 8748 {error, Err, ok} 8749 end; 8750 {Tag, Val} -> 8751 e("received expected handle_trans_reply " 8752 "(action reply) with error" 8753 "~n Tag: ~p" 8754 "~n Val: ~p", [Tag, Val]), 8755 Err = {invalid_command_reply, Tag, Val}, 8756 {error, Err, ok} 8757 end; 8758 _ -> 8759 e("received expected handle_trans_reply with error" 8760 "~n AR: ~p", [AR]), 8761 Err = {invalid_action_reply, AR}, 8762 {error, Err, ok} 8763 end; 8764otp71922_mg_verify_service_change_reply(Else) -> 8765 e("invalid service change reply:" 8766 "~n Expected: handle_trans_reply" 8767 "~n Received: ~p", [Else]), 8768 {error, Else, ok}. 8769 8770otp71922_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 8771 {ok, [AR]}, _}) -> 8772 i("received expected handle_notify_reply -> ok" 8773 "~n AR: ~p", [AR]), 8774 {ok, AR, ok}; 8775otp71922_mg_verify_notify_reply(Else) -> 8776 e("otp71922_mg_verify_notify_reply -> invalid notify reply" 8777 "~n Expected: handle_trans_reply with ok" 8778 "~n Received: ~p", [Else]), 8779 {error, Else, ok}. 8780 8781otp71922_mg_service_change_request_ar(_Mid, Cid) -> 8782 Prof = cre_serviceChangeProf("resgw", 1), 8783 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 8784 Root = #megaco_term_id{id = ["root"]}, 8785 SCR = cre_serviceChangeReq([Root], SCP), 8786 CMD = cre_command(SCR), 8787 CR = cre_cmdReq(CMD), 8788 cre_actionReq(Cid, [CR]). 8789 8790otp71922_mg_notify_request_ar(Rid, Tid, Cid) -> 8791 TT = cre_timeNotation("19990729", "22000000"), 8792 Ev = cre_obsEvent("al/of", TT), 8793 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 8794 NR = cre_notifyReq([Tid], EvsDesc), 8795 CMD = cre_command(NR), 8796 CR = cre_cmdReq(CMD), 8797 cre_actionReq(Cid, [CR]). 8798 8799 8800%% 8801%% Common functions for the multi_trans_req_timeout test case 8802%% 8803 8804otp71922_err_desc(T) -> 8805 cre_ErrDesc(T). 8806 8807 8808%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 8809 8810otp_7192_3(suite) -> 8811 []; 8812otp_7192_3(doc) -> 8813 ["Same as otp_7192_2 but transport is UDP instead of TCP"]; 8814otp_7192_3(Config) when is_list(Config) -> 8815 Pre = fun() -> 8816 MgcNode = make_node_name(mgc), 8817 MgNode = make_node_name(mg), 8818 d("start nodes: " 8819 "~n MGC Node: ~p" 8820 "~n MG Node: ~p", 8821 [MgcNode, MgNode]), 8822 Nodes = [MgcNode, MgNode], 8823 ok = ?START_NODES(Nodes), 8824 Nodes 8825 end, 8826 Case = fun do_otp_7192_3/1, 8827 Post = fun(Nodes) -> 8828 d("stop nodes"), 8829 ?STOP_NODES(lists:reverse(Nodes)) 8830 end, 8831 try_tc(otp_7192_3, Pre, Case, Post). 8832 8833do_otp_7192_3([MgcNode, MgNode]) -> 8834 8835 MgMid = {deviceName,"mg"}, 8836 8837 d("[MGC] start the simulator "), 8838 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 8839 8840 d("[MGC] create the event sequence"), 8841 MgcEvSeq = otp72923_mgc_event_sequence(text, udp, MgMid), 8842 8843 i("wait some time before starting the MGC simulation"), 8844 sleep(1000), 8845 8846 d("[MGC] start the simulation"), 8847 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 8848 8849 i("wait some time before starting the MG simulator"), 8850 sleep(1000), 8851 8852 d("[MG] start the simulator (generator)"), 8853 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 8854 8855 d("[MG] create the event sequence"), 8856 MgEvSeq = otp72923_mg_event_sequence(text, udp, MgMid), 8857 8858 i("wait some time before starting the MG simulation"), 8859 sleep(1000), 8860 8861 d("[MG] start the simulation"), 8862 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 8863 8864 d("await the generator(s) completion"), 8865 await_completion([MgcId, MgId], 60000), 8866 8867 %% Tell Mgc to stop 8868 i("[MGC] stop generator"), 8869 megaco_test_megaco_generator:stop(Mgc), 8870 8871 %% Tell Mg to stop 8872 i("[MG] stop generator"), 8873 megaco_test_megaco_generator:stop(Mg), 8874 8875 i("done", []), 8876 ok. 8877 8878 8879%% 8880%% MGC generator stuff 8881%% 8882-ifdef(megaco_hipe_special). 8883-define(otp72923_mgc_verify_handle_connect_fun(), 8884 {?MODULE, otp72923_mgc_verify_handle_connect, []}). 8885-define(otp72923_mgc_verify_service_change_req_fun(Mid), 8886 {?MODULE, otp72923_mgc_verify_service_change_req, [Mid]}). 8887-define(otp72923_mgc_verify_notify_req_fun(), 8888 {?MODULE, otp72923_mgc_verify_notify_request, []}). 8889-define(otp72923_mgc_verify_notify_reply_fun(), 8890 {?MODULE, otp72923_mgc_verify_notify_reply, []}). 8891-define(otp72923_mgc_verify_ack_fun(), 8892 {?MODULE, otp72923_mgc_verify_ack, []}). 8893-define(otp72923_mgc_verify_handle_disconnect_fun(), 8894 {?MODULE, otp72923_mgc_verify_handle_disconnect, []}). 8895-else. 8896-define(otp72923_mgc_verify_handle_connect_fun(), 8897 fun otp72923_mgc_verify_handle_connect/1). 8898-define(otp72923_mgc_verify_service_change_req_fun(Mid), 8899 otp72923_mgc_verify_service_change_req_fun(Mid)). 8900-define(otp72923_mgc_verify_notify_req_fun(), 8901 otp72923_mgc_verify_notify_request_fun()). 8902-define(otp72923_mgc_verify_notify_reply_fun(), 8903 fun otp72923_mgc_verify_notify_reply/1). 8904-define(otp72923_mgc_verify_ack_fun(), 8905 fun otp72923_mgc_verify_ack/1). 8906-define(otp72923_mgc_verify_handle_disconnect_fun(), 8907 fun otp72923_mgc_verify_handle_disconnect/1). 8908-endif. 8909 8910otp72923_mgc_event_sequence(text, udp, MgMid) -> 8911 CTRL = self(), 8912 Mid = {deviceName, "ctrl"}, 8913 RI = [ 8914 {port, 2944}, 8915 {encoding_module, megaco_pretty_text_encoder}, 8916 {encoding_config, []}, 8917 {transport_module, megaco_udp} 8918 ], 8919 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 8920 NR = fun(Cid, Rid) -> 8921 [otp72923_mgc_notify_request_ar(Rid, Tid, Cid)] 8922 end, 8923 LocalConnectVerify = ?otp72923_mgc_verify_handle_connect_fun(), 8924 ServiceChangeReqVerify = ?otp72923_mgc_verify_service_change_req_fun(Mid), 8925 NotifyReqVerify = ?otp72923_mgc_verify_notify_req_fun(), 8926 NotifyReplyVerify = ?otp72923_mgc_verify_notify_reply_fun(), 8927 AckVerify = ?otp72923_mgc_verify_ack_fun(), 8928 %% DiscoVerify = ?otp72923_mgc_verify_handle_disconnect_fun(), 8929 EvSeq = [ 8930 {debug, true}, 8931 {megaco_trace, max}, 8932 %% {megaco_trace, disable}, 8933 megaco_start, 8934 {megaco_start_user, Mid, RI, []}, 8935 start_transport, 8936 listen, 8937 8938 %% ANNOUNCE READY 8939 {trigger, fun() -> CTRL ! announce_mgc end}, 8940 8941 {megaco_connect, MgMid}, 8942 {megaco_callback, handle_connect, LocalConnectVerify}, 8943 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 8944 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8945 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8946 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8947 {megaco_update_conn_info, request_timer, 1000}, 8948 {megaco_cast, NR(1,1), []}, 8949 8950 {megaco_callback, [{handle_trans_ack, 3, AckVerify}, 8951 {handle_trans_request, 3, NotifyReqVerify}, 8952 {handle_trans_reply, 1, NotifyReplyVerify}]}, 8953 %% {megaco_callback, handle_disconnect, DiscoVerify}, 8954 {sleep, 1000}, 8955 megaco_stop_user, 8956 megaco_stop 8957 ], 8958 EvSeq. 8959 8960 8961otp72923_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 8962 io:format("otp72923_mgc_verify_handle_connect -> ok" 8963 "~n CH: ~p~n", [CH]), 8964 {ok, timer:seconds(2), CH, ok}; 8965otp72923_mgc_verify_handle_connect(Else) -> 8966 io:format("otp72923_mgc_verify_handle_connect -> unknown" 8967 "~n Else: ~p~n", [Else]), 8968 {error, Else, ok}. 8969 8970otp72923_mgc_verify_service_change_req_fun(Mid) -> 8971 fun(Ev) -> 8972 otp72923_mgc_verify_service_change_req(Ev, Mid) 8973 end. 8974 8975otp72923_mgc_verify_service_change_req( 8976 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 8977 io:format("otp72923_mgc_verify_service_change_req -> ok" 8978 "~n AR: ~p~n", [AR]), 8979 case AR of 8980 #'ActionRequest'{commandRequests = [CR]} -> 8981 case CR of 8982 #'CommandRequest'{command = Cmd} -> 8983 case Cmd of 8984 {serviceChangeReq, 8985 #'ServiceChangeRequest'{terminationID = [Tid], 8986 serviceChangeParms = Parms}} -> 8987 case Tid of 8988 #megaco_term_id{contains_wildcards = false, 8989 id = ["root"]} -> 8990 case Parms of 8991 #'ServiceChangeParm'{ 8992 serviceChangeMethod = restart, 8993 serviceChangeReason = [[$9,$0,$1|_]]} -> 8994 Reply = 8995 {discard_ack, 8996 [otp72923_mgc_service_change_reply_ar(Mid, 1)]}, 8997 {ok, AR, Reply}; 8998 _ -> 8999 Err = {invalid_SCP, Parms}, 9000 ED = otp72923_err_desc(Parms), 9001 ErrReply = {discard_ack, 9002 ED}, 9003 {error, Err, ErrReply} 9004 end; 9005 _ -> 9006 Err = {invalid_termination_id, Tid}, 9007 ED = otp72923_err_desc(Tid), 9008 ErrReply = {discard_ack, ED}, 9009 {error, Err, ErrReply} 9010 end; 9011 _ -> 9012 Err = {invalid_command, Cmd}, 9013 ED = otp72923_err_desc(Cmd), 9014 ErrReply = {discard_ack, ED}, 9015 {error, Err, ErrReply} 9016 end; 9017 _ -> 9018 Err = {invalid_command_request, CR}, 9019 ED = otp72923_err_desc(CR), 9020 ErrReply = {discard_ack, ED}, 9021 {error, Err, ErrReply} 9022 end; 9023 _ -> 9024 Err = {invalid_action_request, AR}, 9025 ED = otp72923_err_desc(AR), 9026 ErrReply = {discard_ack, ED}, 9027 {error, Err, ErrReply} 9028 end; 9029otp72923_mgc_verify_service_change_req(Else, _Mid) -> 9030 io:format("otp72923_mgc_verify_service_change_req -> unknown" 9031 "~n Else: ~p~n", [Else]), 9032 ED = otp72923_err_desc(Else), 9033 ErrReply = {discard_ack, ED}, 9034 {error, Else, ErrReply}. 9035 9036otp72923_mgc_verify_notify_request_fun() -> 9037 fun(Ev) -> 9038 otp72923_mgc_verify_notify_request(Ev) 9039 end. 9040 9041otp72923_mgc_verify_notify_request( 9042 {handle_trans_request, _, ?VERSION, [AR]}) -> 9043 io:format("otp72923_mgc_verify_notify_request -> ok" 9044 "~n AR: ~p~n", [AR]), 9045 case AR of 9046 #'ActionRequest'{contextId = 1 = Cid, 9047 commandRequests = [CR]} -> 9048 #'CommandRequest'{command = Cmd} = CR, 9049 {notifyReq, NR} = Cmd, 9050 #'NotifyRequest'{terminationID = [Tid], 9051 observedEventsDescriptor = OED, 9052 errorDescriptor = asn1_NOVALUE} = NR, 9053 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 9054 #'ObservedEvent'{eventName = "al/of"} = OE, 9055 HandleAck = {handle_sloppy_ack, kalle}, 9056 Reply = {HandleAck, 9057 [otp72923_mgc_notify_reply_ar(Cid, Tid)]}, 9058 {ok, AR, Reply}; 9059 #'ActionRequest'{contextId = 2 = Cid, 9060 commandRequests = [CR]} -> 9061 #'CommandRequest'{command = Cmd} = CR, 9062 {notifyReq, NR} = Cmd, 9063 #'NotifyRequest'{terminationID = [Tid], 9064 observedEventsDescriptor = OED, 9065 errorDescriptor = asn1_NOVALUE} = NR, 9066 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 9067 #'ObservedEvent'{eventName = "al/of"} = OE, 9068 Reply = {discard_ack, [otp72923_mgc_notify_reply_ar(Cid, Tid)]}, 9069 {ok, AR, Reply}; 9070 _ -> 9071 ED = otp72923_err_desc(AR), 9072 ErrReply = {discard_ack, ED}, 9073 {error, AR, ErrReply} 9074 end; 9075otp72923_mgc_verify_notify_request(Else) -> 9076 io:format("otp72923_mgc_verify_notify_request -> unknown" 9077 "~n Else: ~p~n", [Else]), 9078 ED = otp72923_err_desc(Else), 9079 ErrReply = {discard_ack, ED}, 9080 {error, Else, ErrReply}. 9081 9082otp72923_mgc_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 9083 {ok, [AR]}, _}) -> 9084 io:format("otp72923_mgc_verify_notify_reply -> ok" 9085 "~n AR: ~p~n", [AR]), 9086 {ok, AR, ok}; 9087otp72923_mgc_verify_notify_reply({handle_trans_reply, CH, ?VERSION, 9088 UnknownResult, _}) -> 9089 io:format("otp72923_mgc_verify_notify_reply -> unknown result" 9090 "~n UnknownResult: ~p~n", [UnknownResult]), 9091 {error, {unknown_reply_result, UnknownResult, CH}, ok}; 9092otp72923_mgc_verify_notify_reply(Else) -> 9093 io:format("otp72923_mgc_verify_notify_reply -> unknown" 9094 "~n Else: ~p~n", [Else]), 9095 {error, {unknown_reply, Else}, ok}. 9096 9097otp72923_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 9098 io:format("otp72923_mgc_verify_ack -> ok" 9099 "~n CH: ~p" 9100 "~n", [CH]), 9101 {ok, CH, ok}; 9102otp72923_mgc_verify_ack(Else) -> 9103 io:format("otp72923_mgc_verify_ack -> unknown" 9104 "~n Else: ~p~n", [Else]), 9105 {error, Else, ok}. 9106 9107%% otp72923_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 9108%% io:format("otp72923_mgc_verify_handle_disconnect -> ok" 9109%% "~n CH: ~p" 9110%% "~n R: ~p" 9111%% "~n", [CH, R]), 9112%% {ok, CH, ok}; 9113%% otp72923_mgc_verify_handle_disconnect(Else) -> 9114%% io:format("otp72923_mgc_verify_handle_disconnect -> unknown" 9115%% "~n Else: ~p~n", [Else]), 9116%% {error, Else, ok}. 9117 9118 9119otp72923_mgc_service_change_reply_ar(Mid, Cid) -> 9120 SCRP = cre_serviceChangeResParm(Mid), 9121 SCRes = cre_serviceChangeResult(SCRP), 9122 Root = #megaco_term_id{id = ["root"]}, 9123 SCR = cre_serviceChangeReply([Root], SCRes), 9124 CR = cre_cmdReply(SCR), 9125 cre_actionReply(Cid, [CR]). 9126 9127%% otp72923_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 9128%% AR = otp72923_mgc_service_change_reply_ar(Mid, Cid), 9129%% TRes = cre_transResult([AR]), 9130%% TR = cre_transReply(TransId, TRes), 9131%% Trans = cre_transaction(TR), 9132%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 9133%% cre_megacoMessage(Mess). 9134 9135otp72923_mgc_notify_request_ar(Rid, Tid, Cid) -> 9136 TT = cre_timeNotation("19990729", "44000000"), 9137 Ev = cre_obsEvent("al/of", TT), 9138 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 9139 NR = cre_notifyReq([Tid], EvsDesc), 9140 CMD = cre_command(NR), 9141 CR = cre_cmdReq(CMD), 9142 cre_actionReq(Cid, [CR]). 9143 9144otp72923_mgc_notify_reply_ar(Cid, TermId) -> 9145 NR = cre_notifyReply([TermId]), 9146 CR = cre_cmdReply(NR), 9147 cre_actionReply(Cid, [CR]). 9148 9149%% otp72923_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 9150%% AR = otp72923_mgc_notify_reply_ar(Cid, TermId), 9151%% TRes = cre_transResult([AR]), 9152%% TR = cre_transReply(TransId, TRes), 9153%% Trans = cre_transaction(TR), 9154%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 9155%% cre_megacoMessage(Mess). 9156 9157 9158%% 9159%% MG generator stuff 9160%% 9161-ifdef(megaco_hipe_special). 9162-define(otp72923_mg_verify_handle_connect_fun(), 9163 {?MODULE, otp72923_mg_verify_handle_connect, []}). 9164-define(otp72923_mg_verify_service_change_reply_fun(), 9165 {?MODULE, otp72923_mg_verify_service_change_reply, []}). 9166-define(otp72923_mg_verify_notify_req_fun(), 9167 {?MODULE, otp72923_mgc_verify_notify_request, []}). 9168-define(otp72923_mg_verify_notify_reply_fun(), 9169 {?MODULE, otp72923_mg_verify_notify_reply, []}). 9170-else. 9171-define(otp72923_mg_verify_handle_connect_fun(), 9172 fun otp72923_mg_verify_handle_connect/1). 9173-define(otp72923_mg_verify_service_change_reply_fun(), 9174 fun otp72923_mg_verify_service_change_reply/1). 9175-define(otp72923_mg_verify_notify_req_fun(), 9176 otp72923_mgc_verify_notify_request_fun()). 9177-define(otp72923_mg_verify_notify_reply_fun(), 9178 fun otp72923_mg_verify_notify_reply/1). 9179-endif. 9180 9181otp72923_mg_event_sequence(text, udp, Mid) -> 9182 RI = [ 9183 {port, 2944}, 9184 {encoding_module, megaco_pretty_text_encoder}, 9185 {encoding_config, []}, 9186 {transport_module, megaco_udp} 9187 ], 9188 ServiceChangeReq = [otp72923_mg_service_change_request_ar(Mid, 1)], 9189 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 9190 NR = fun(Cid, Rid) -> 9191 [otp72923_mg_notify_request_ar(Rid, Tid, Cid)] 9192 end, 9193 ConnectVerify = ?otp72923_mg_verify_handle_connect_fun(), 9194 ServiceChangeReplyVerify = ?otp72923_mg_verify_service_change_reply_fun(), 9195 NotifyReqVerify = ?otp72923_mg_verify_notify_req_fun(), 9196 NotifyReplyVerify = ?otp72923_mg_verify_notify_reply_fun(), 9197 EvSeq = [ 9198 %% {debug, true}, 9199 {debug, false}, 9200 megaco_start, 9201 {megaco_start_user, Mid, RI, []}, 9202 start_transport, 9203 %% {megaco_trace, max}, 9204 {megaco_trace, disable}, 9205 {megaco_system_info, users}, 9206 {megaco_system_info, connections}, 9207 connect, 9208 {megaco_callback, handle_connect, ConnectVerify}, 9209 megaco_connect, 9210 {megaco_cast, ServiceChangeReq, []}, 9211 {megaco_callback, handle_connect, ConnectVerify}, 9212 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 9213 {sleep, 1000}, 9214 {megaco_system_info, users}, 9215 {megaco_system_info, connections}, 9216 {sleep, 1000}, 9217 {megaco_update_conn_info, auto_ack, true}, 9218 {megaco_update_conn_info, trans_ack_maxcount, 10}, 9219 {megaco_update_conn_info, trans_req_maxcount, 10}, 9220 {megaco_update_conn_info, trans_timer, 1000}, 9221 {megaco_update_conn_info, trans_ack, true}, 9222 {megaco_update_conn_info, trans_req, true}, 9223 {megaco_conn_info, all}, 9224 {megaco_cast, NR(1,1), []}, 9225 {megaco_cast, NR(1,2), []}, 9226 {megaco_cast, NR(1,3), []}, 9227 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9228 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9229 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9230 {megaco_update_conn_info, trans_timer, 120000}, 9231 {megaco_cast, NR(2,1), []}, 9232 {megaco_cast, NR(2,2), []}, 9233 {megaco_cast, NR(2,3), []}, 9234 {megaco_callback, handle_trans_request, NotifyReqVerify}, 9235 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9236 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9237 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9238 {sleep, 3000}, 9239 megaco_stop_user, 9240 megaco_stop, 9241 {sleep, 1000} 9242 ], 9243 EvSeq. 9244 9245otp72923_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 9246 io:format("otp72923_mg_verify_handle_connect -> ok" 9247 "~n CH: ~p~n", [CH]), 9248 {ok, CH, ok}; 9249otp72923_mg_verify_handle_connect(Else) -> 9250 io:format("otp72923_mg_verify_handle_connect -> unknown" 9251 "~n Else: ~p~n", [Else]), 9252 {error, Else, ok}. 9253 9254otp72923_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 9255 {ok, [AR]}, _}) -> 9256 io:format("otp72923_mg_verify_service_change_reply -> ok" 9257 "~n AR: ~p~n", [AR]), 9258 case AR of 9259 #'ActionReply'{commandReply = [SCR]} -> 9260 case SCR of 9261 {serviceChangeReply, 9262 #'ServiceChangeReply'{terminationID = [Tid], 9263 serviceChangeResult = Res}} -> 9264 case Tid of 9265 #megaco_term_id{contains_wildcards = false, 9266 id = ["root"]} -> 9267 case Res of 9268 {serviceChangeResParms, 9269 #'ServiceChangeResParm'{ 9270 serviceChangeMgcId = _RemoteMid}} -> 9271 {ok, AR, ok}; 9272 {Tag, Val} -> 9273 Err = {invalid_service_change_result, 9274 Tag, Val}, 9275 {error, Err, ok} 9276 end; 9277 _ -> 9278 Err = {invalid_termination_id, Tid}, 9279 {error, Err, ok} 9280 end; 9281 {Tag, Val} -> 9282 Err = {invalid_command_reply, Tag, Val}, 9283 {error, Err, ok} 9284 end; 9285 _ -> 9286 Err = {invalid_action_reply, AR}, 9287 {error, Err, ok} 9288 end; 9289otp72923_mg_verify_service_change_reply(Else) -> 9290 io:format("otp72923_mg_verify_service_change_reply -> unknown" 9291 "~n Else: ~p~n", [Else]), 9292 {error, Else, ok}. 9293 9294%% otp72923_mg_verify_notify_request_fun() -> 9295%% fun(Ev) -> 9296%% otp72923_mg_verify_notify_request(Ev) 9297%% end. 9298 9299%% otp72923_mg_verify_notify_request( 9300%% {handle_trans_request, _, ?VERSION, [AR]}) -> 9301%% io:format("otp72923_mg_verify_notify_request -> ok" 9302%% "~n AR: ~p~n", [AR]), 9303%% case AR of 9304%% #'ActionRequest'{contextId = 1 = Cid, 9305%% commandRequests = [CR]} -> 9306%% #'CommandRequest'{command = Cmd} = CR, 9307%% {notifyReq, NR} = Cmd, 9308%% #'NotifyRequest'{terminationID = [Tid], 9309%% observedEventsDescriptor = OED, 9310%% errorDescriptor = asn1_NOVALUE} = NR, 9311%% #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 9312%% #'ObservedEvent'{eventName = "al/of"} = OE, 9313%% Reply = {discard_ack, [otp72923_mg_notify_reply_ar(Cid, Tid)]}, 9314%% {ok, AR, Reply}; 9315%% _ -> 9316%% ED = otp72923_err_desc(AR), 9317%% ErrReply = {discard_ack, ED}, 9318%% {error, AR, ErrReply} 9319%% end; 9320%% otp72923_mg_verify_notify_request(Else) -> 9321%% io:format("otp72923_mg_verify_notify_request -> unknown" 9322%% "~n Else: ~p~n", [Else]), 9323%% ED = otp72923_err_desc(Else), 9324%% ErrReply = {discard_ack, ED}, 9325%% {error, Else, ErrReply}. 9326 9327otp72923_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 9328 {ok, [AR]}, _}) -> 9329 io:format("otp72923_mg_verify_notify_reply -> ok" 9330 "~n AR: ~p~n", [AR]), 9331 {ok, AR, ok}; 9332otp72923_mg_verify_notify_reply(Else) -> 9333 io:format("otp72923_mg_verify_notify_reply -> unknown" 9334 "~n Else: ~p~n", [Else]), 9335 {error, Else, ok}. 9336 9337otp72923_mg_service_change_request_ar(_Mid, Cid) -> 9338 Prof = cre_serviceChangeProf("resgw", 1), 9339 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 9340 Root = #megaco_term_id{id = ["root"]}, 9341 SCR = cre_serviceChangeReq([Root], SCP), 9342 CMD = cre_command(SCR), 9343 CR = cre_cmdReq(CMD), 9344 cre_actionReq(Cid, [CR]). 9345 9346%% otp72923_mg_service_change_request_msg(Mid, TransId, Cid) -> 9347%% AR = otp72923_mg_service_change_request_ar(Mid, Cid), 9348%% TR = cre_transReq(TransId, [AR]), 9349%% Trans = cre_transaction(TR), 9350%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 9351%% cre_megacoMessage(Mess). 9352 9353%% otp72923_mg_notify_reply_ar(Cid, TermId) -> 9354%% NR = cre_notifyReply([TermId]), 9355%% CR = cre_cmdReply(NR), 9356%% cre_actionReply(Cid, [CR]). 9357 9358otp72923_mg_notify_request_ar(Rid, Tid, Cid) -> 9359 TT = cre_timeNotation("19990729", "22000000"), 9360 Ev = cre_obsEvent("al/of", TT), 9361 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 9362 NR = cre_notifyReq([Tid], EvsDesc), 9363 CMD = cre_command(NR), 9364 CR = cre_cmdReq(CMD), 9365 cre_actionReq(Cid, [CR]). 9366 9367%% otp72923_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 9368%% AR = otp72923_mg_notify_request_ar(Rid, TermId, Cid), 9369%% TR = cre_transReq(TransId, [AR]), 9370%% Trans = cre_transaction(TR), 9371%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 9372%% cre_megacoMessage(Mess). 9373 9374 9375%% 9376%% Common functions for the multi_trans_req_timeout test case 9377%% 9378 9379otp72923_err_desc(T) -> 9380 cre_ErrDesc(T). 9381 9382 9383%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9384 9385%% 9386%% Common message creation functions 9387%% 9388 9389cre_ErrDesc(T) -> 9390 cre_ErrDesc(?megaco_internal_gateway_error, T). 9391 9392cre_ErrDesc(EC, T) -> 9393 ET = lists:flatten(io_lib:format("~w",[T])), 9394 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 9395 9396cre_serviceChangeParm(M,R,P) -> 9397 #'ServiceChangeParm'{serviceChangeMethod = M, 9398 serviceChangeReason = R, 9399 serviceChangeProfile = P}. 9400 9401cre_serviceChangeReq(Tid, Parms) -> 9402 #'ServiceChangeRequest'{terminationID = Tid, 9403 serviceChangeParms = Parms}. 9404 9405cre_timeNotation(D,T) -> 9406 #'TimeNotation'{date = D, time = T}. 9407 9408cre_obsEvent(Name, Not) -> 9409 #'ObservedEvent'{eventName = Name, 9410 timeNotation = Not}. 9411%% cre_obsEvent(Name, Not, Par) -> 9412%% #'ObservedEvent'{eventName = Name, 9413%% timeNotation = Not, 9414%% eventParList = Par}. 9415 9416cre_obsEvsDesc(Id, EvList) -> 9417 #'ObservedEventsDescriptor'{requestId = Id, 9418 observedEventLst = EvList}. 9419 9420cre_notifyReq(Tid, EvsDesc) -> 9421 #'NotifyRequest'{terminationID = Tid, 9422 observedEventsDescriptor = EvsDesc}. 9423 9424cre_command(R) when is_record(R, 'NotifyRequest') -> 9425 {notifyReq, R}; 9426cre_command(R) when is_record(R, 'ServiceChangeRequest') -> 9427 {serviceChangeReq, R}. 9428 9429cre_cmdReq(Cmd) -> 9430 #'CommandRequest'{command = Cmd}. 9431 9432cre_actionReq(CtxId, CmdReqs) when is_list(CmdReqs) -> 9433 #'ActionRequest'{contextId = CtxId, 9434 commandRequests = CmdReqs}. 9435 9436%% cre_transReq(TransId, ARs) when is_list(ARs) -> 9437%% #'TransactionRequest'{transactionId = TransId, 9438%% actions = ARs}. 9439 9440%% -- 9441 9442cre_serviceChangeResParm(Mid) -> 9443 #'ServiceChangeResParm'{serviceChangeMgcId = Mid}. 9444 9445cre_serviceChangeResult(SCRP) when is_record(SCRP, 'ServiceChangeResParm') -> 9446 {serviceChangeResParms, SCRP}; 9447cre_serviceChangeResult(ED) when is_record(ED, 'ErrorDescriptor') -> 9448 {errorDescriptor, ED}. 9449 9450cre_serviceChangeReply(Tid, Res) -> 9451 #'ServiceChangeReply'{terminationID = Tid, 9452 serviceChangeResult = Res}. 9453 9454cre_cmdReply(R) when is_record(R, 'NotifyReply') -> 9455 {notifyReply, R}; 9456cre_cmdReply(R) when is_record(R, 'ServiceChangeReply') -> 9457 {serviceChangeReply, R}. 9458 9459cre_notifyReply(Tid) -> 9460 #'NotifyReply'{terminationID = Tid}. 9461 9462cre_actionReply(CtxId, CmdRep) -> 9463 #'ActionReply'{contextId = CtxId, 9464 commandReply = CmdRep}. 9465 9466%% cre_transResult(ED) when is_record(ED, 'ErrorDescriptor') -> 9467%% {transactionError, ED}; 9468%% cre_transResult([AR|_] = ARs) when is_record(AR, 'ActionReply') -> 9469%% {actionReplies, ARs}. 9470 9471%% cre_transReply(TransId, Res) -> 9472%% #'TransactionReply'{transactionId = TransId, 9473%% transactionResult = Res}. 9474 9475 9476%% -- 9477 9478cre_serviceChangeProf(Name, Ver) when is_list(Name) andalso is_integer(Ver) -> 9479 #'ServiceChangeProfile'{profileName = Name, 9480 version = Ver}. 9481 9482%% cre_transaction(Trans) when is_record(Trans, 'TransactionRequest') -> 9483%% {transactionRequest, Trans}; 9484%% cre_transaction(Trans) when is_record(Trans, 'TransactionPending') -> 9485%% {transactionPending, Trans}; 9486%% cre_transaction(Trans) when is_record(Trans, 'TransactionReply') -> 9487%% {transactionReply, Trans}; 9488%% cre_transaction(Trans) when is_record(Trans, 'TransactionAck') -> 9489%% {transactionResponseAck, Trans}. 9490 9491%% cre_transactions(Trans) when is_list(Trans) -> 9492%% {transactions, Trans}. 9493 9494%% cre_message(Version, Mid, Body) -> 9495%% #'Message'{version = Version, 9496%% mId = Mid, 9497%% messageBody = Body}. 9498 9499%% cre_megacoMessage(Mess) -> 9500%% #'MegacoMessage'{mess = Mess}. 9501 9502 9503%% 9504%% Common functions 9505%% 9506 9507%% encode_msg_fun(Mod, Conf) -> 9508%% fun(M) -> 9509%% Mod:encode_message(Conf, M) 9510%% end. 9511%% encode_msg_fun(Mod, Conf, Ver) -> 9512%% fun(M) -> 9513%% Mod:encode_message(Conf, Ver, M) 9514%% end. 9515 9516%% decode_msg_fun(Mod, Conf) -> 9517%% fun(M) -> 9518%% Mod:decode_message(Conf, M) 9519%% end. 9520%% decode_msg_fun(Mod, Conf, Ver) -> 9521%% fun(M) -> 9522%% Mod:decode_message(Conf, Ver, M) 9523%% end. 9524 9525 9526%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9527 9528await_ack(_User, 0, Timeout, _Expected) -> 9529 d("await_ack -> done when Timeout = ~p", [Timeout]), 9530 ok; 9531await_ack(User, N, Timeout, Expected) when (N > 0) andalso is_integer(Timeout) -> 9532 d("await_ack -> entry with N: ~p, Timeout: ~p", [N,Timeout]), 9533 T = tim(), 9534 receive 9535 {ack_received, User, Expected} -> 9536 d("await_ack -> received another expected ack"), 9537 await_ack(User, N-1, Timeout - (tim() - T), Expected); 9538 {ack_received, User, UnExpected} -> 9539 e("await_ack -> received unexpected ack result: ~p", [UnExpected]), 9540 exit({unexpected_ack_result, UnExpected, Expected}) 9541 after Timeout -> 9542 exit({await_ack_timeout, N}) 9543 end; 9544await_ack(User, N, infinity, Expected) when N > 0 -> 9545 d("await_ack -> entry with N: ~p", [N]), 9546 receive 9547 {ack_received, User, Expected} -> 9548 d("await_ack -> received another ack"), 9549 await_ack(User, N-1, infinity, Expected); 9550 {ack_received, User, UnExpected} -> 9551 e("await_ack -> unexpected ack result: ~p", [UnExpected]), 9552 exit({unexpected_ack_result, UnExpected, Expected}) 9553 end. 9554 9555 9556tim() -> 9557 {A,B,C} = erlang:timestamp(), 9558 A*1000000000+B*1000+(C div 1000). 9559 9560 9561make_node_name(Name) -> 9562 case string:tokens(atom_to_list(node()), [$@]) of 9563 [_,Host] -> 9564 list_to_atom(lists:concat([atom_to_list(Name) ++ "@" ++ Host])); 9565 _ -> 9566 exit("Test node must be started with '-sname'") 9567 end. 9568 9569 9570%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9571 9572await_completion(Ids) -> 9573 case megaco_test_generator_lib:await_completion(Ids) of 9574 {ok, Reply} -> 9575 d("OK => Reply: ~n~p", [Reply]), 9576 ok; 9577 {error, Reply} -> 9578 e("await completion failed: " 9579 "~n ~p", [Reply]), 9580 ?ERROR({failed, Reply}) 9581 end. 9582 9583await_completion(Ids, Timeout) -> 9584 case megaco_test_generator_lib:await_completion(Ids, Timeout) of 9585 {ok, Reply} -> 9586 d("OK => Reply: ~n~p", [Reply]), 9587 ok; 9588 {error, Reply} -> 9589 e("await completion failed: " 9590 "~n ~p" 9591 "~n ~p", [Timeout, Reply]), 9592 ?ERROR({failed, Reply}) 9593 end. 9594 9595 9596%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9597 9598try_tc(TCName, Pre, Case, Post) -> 9599 try_tc(TCName, "TEST", ?TEST_VERBOSITY, Pre, Case, Post). 9600 9601try_tc(TCName, Name, Verbosity, Pre, Case, Post) -> 9602 ?TRY_TC(TCName, Name, Verbosity, Pre, Case, Post). 9603 9604 9605 9606%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9607 9608sleep(X) -> receive after X -> ok end. 9609 9610%% error_msg(F,A) -> error_logger:error_msg(F ++ "~n",A). 9611 9612 9613%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9614 9615p(F, A) -> 9616 io:format("*** [~s] ~p ***" 9617 "~n " ++ F ++ "~n", 9618 [?FTS(), self() | A]). 9619 9620%% e(F) -> 9621%% e(F, []). 9622 9623e(F, A) -> 9624 print(error, "ERROR", F, A). 9625 9626 9627i(F) -> 9628 i(F, []). 9629 9630i(F, A) -> 9631 print(info, "INFO", F, A). 9632 9633 9634d(F) -> 9635 d(F, []). 9636 9637d(F, A) -> 9638 print(debug, "DBG", F, A). 9639 9640 9641print(Severity, P, F, A) -> 9642 print2(printable(Severity), P, F, A). 9643 9644printable(Sev) -> 9645 printable(Sev, get(verbosity)). 9646 9647printable(_, debug) -> true; 9648printable(info, info) -> true; 9649printable(error, _) -> true; 9650printable(_,_) -> false. 9651 9652print2(true, P, F, A) -> 9653 S = ?F("*** [~s] ~s ~p~s ***" 9654 "~n " ++ F ++ "~n" 9655 "~n", [?FTS(), P, self(), case get(tc) of 9656 undefined -> ""; 9657 TC -> " " ++ atom_to_list(TC) 9658 end | A]), 9659 io:format("~s", [S]); 9660print2(_, _, _, _) -> 9661 ok. 9662 9663 9664