function_test/Config_Parser/OrderedInclude.script

   1 .******************************************************************************
   2 .* Copyright (c) 2000-2014 Ericsson Telecom AB
   3 .* All rights reserved. This program and the accompanying materials
   4 .* are made available under the terms of the Eclipse Public License v1.0
   5 .* which accompanies this distribution, and is available at
   6 .* http://www.eclipse.org/legal/epl-v10.html
   7 .******************************************************************************/
   8 :text.
   9 :lang eng.
  10
  11 .* EDML webpage:       http://cpi.ericsson.se/dwaxe/
  12 .* EDML2PDF converter: http://dwaxe.ericsson.se/x2pdf
  13 .* EDML user guide:    http://www.lmc.ericsson.se/~lmcmarg/isit/edml_ug.html
  14
  15 .* Document header information
  16 :docname.Test Description
  17 :docno.xx/152 91-CRL 113 200/3 Uen
  18 :rev.C
  19 :date.2015-04-27
  20
  21 :prep.ETH/XZR Jeno Balasko
  22 :appr.ETH/XZR (Elemer Lelik)
  23 :checked.ESZABRE
  24
  25 :title.Test description of the TTCN-3 config files
  26 :contents level=2.
  27 .*---------------------------------------------------------------------*
  28 :h1.Introduction
  29 .*---------------------------------------------------------------------*
  30 .*---------------------------------------------------------------------*
  31 :h2.Revision history
  32 .*---------------------------------------------------------------------*
  33 :xmp tab=2.
  34 REV   DATE         PREPARED   CHANGE
  35 __________________________________________________
  36 PA1   2013-03-01   ETHBAAT     New document for TITAN CRL 113 200/3
  37
  38 :exmp.
  39 .*---------------------------------------------------------------------*
  40 :h2.Purpose
  41 .*---------------------------------------------------------------------*
  42 The purpose of this Test Description is to define and describe the function
  43 test activity for the listed functionality of the TTCN-3 executor including
  44 the relevant configuration options and the configuration file parser as follows:
  45 :li D='1.'Ordered Include
  46
  47 :nl.SA-1/x: Unknown object.
  48 :p.The specification of the test cases can be found in this document.
  49 .*---------------------------------------------------------------------*
  50 :h1.Test environment
  51 .*---------------------------------------------------------------------*
  52 .*---------------------------------------------------------------------*
  53 :h2.Hardware
  54 .*---------------------------------------------------------------------*
  55 No specific hardware requirement.
  56 .*---------------------------------------------------------------------*
  57 :h2.Software
  58 .*---------------------------------------------------------------------*
  59 Tests shall be carried out on the following platforms:
  60 :list.
  61 :li D='1.'.Solaris 8 (Sun OS 5.8) (gcc 3.0.4)
  62 :li D='2.'.SUSE Linux Enterprise server 8 (2.4.19-4GB) (gcc 3.2)
  63 :li D='3.'.CYGWIN_NT-5.0 (Cygwin DLL: 1.5.12) on Windows 2000 (gcc 3.3.3)
  64 :elist.
  65 .*---------------------------------------------------------------------*
  66 :h2.Configuration
  67 .*---------------------------------------------------------------------*
  68 The test environment had been setup in CVS. The tester program is stored in:
  69 :nl.TTCNv3/function_test/Tools/SAtester.pl
  70 :nl.Test cases are stored with extension .script in the directory:
  71 :nl.TTCNv3/function_test/Semantic_Analyser/
  72 .*---------------------------------------------------------------------*
  73 :h2.Installation
  74 .*---------------------------------------------------------------------*
  75 Install proper TITAN binaries on the used platforms and make sure that
  76 your environment settings are correct:
  77 :list.
  78 :li D='1.'.TTCN3_DIR is set
  79 :li D='2.'.$TTCN3_DIR/bin is added to the PATH variable
  80 :li D='3.'.$TTCN3_DIR/lib is added to the LD_LIBRARY_PATH variable
  81 :li D='4.'.Perl 5.6.0 or higher is available on the platform
  82 :li D='5.'.Create a symlink to your Perl binary into the directory where the
  83 test cases are stored:
  84 :nl.ln -s <your Perl> perl
  85 :elist.
  86 .*---------------------------------------------------------------------*
  87 :h2.Test Tools
  88 .*---------------------------------------------------------------------*
  89 A tester program had been written in Perl especially for the Semantic Analyser
  90 tests. For the list of command line parameters, type 'SAtester.pl -help', for the
  91 complete documentation, type 'SAtester.pl -doc'.
  92 :p.Test cases are specified in the Test Description documents in EDML format.
  93 The tester program parses these files and generates the TTCN-3/ASN.1 modules, then
  94 calls the compiler to compile them. The result printout is then matched against
  95 different patterns to be able to set the verdict. Test cases contain not only
  96 the source modules, but the patterns as well.
  97 :p.The tester program allows one-by-one execution of test cases and batched
  98 execution as well.
  99 :p.NOTE: the tester program requires Perl 5.6.0 or higher.
 100 .*---------------------------------------------------------------------*
 101 :h2.Test scope
 102 .*---------------------------------------------------------------------*
 103 Ref [1]: SA-1/x: Unknown object
 104 :nl.Explanation: all unknown objects shall be detected by SA.
 105 .*---------------------------------------------------------------------*
 106 :h2.Test strategy
 107 .*---------------------------------------------------------------------*
 108 Test cases are based on TTCN-3 BNF according to the followings:
 109 :list.
 110 :li D='1.'.For each 'basic' definition a complete coverage is done (e.g. for
 111 expressions, assignments, etc.). 'Basic' means that the definition is
 112 used in several places.
 113 :li D='2.'.For each definition a complete coverage is done, except for basic
 114 definitions, in which case only 1-2 examples are covered, not the
 115 whole basic definition. This is to avoid testing all possible subcases
 116 for all possible places it may appear.
 117 :nl.NOTE: a complete coverage means that all occurances are tested where
 118 the specific definition may occur. This is however not complete. Only
 119 one occurance is tested for each construct.
 120 :li D='3.'.Test case names are contsructed following the path in the BNF in TTCN-3
 121 and following the possible notations/subtyping in ASN.1.
 122 :elist.
 123 .*---------------------------------------------------------------------*
 124 :h2.Status
 125 .*---------------------------------------------------------------------*
 126 The following structures are not covered:
 127 :list.
 128 :li D='-'.sub-structures that causes parse error due to limited support of that
 129 part of the language (e.g. interleave construct)
 130 :elist.
 131 .*---------------------------------------------------------------------*
 132 :h1.Test cases
 133 .*---------------------------------------------------------------------*
 134 .*---------------------------------------------------------------------*
 135 :h2.Ordered include - Positive tests
 136 .*---------------------------------------------------------------------*
 137 .*---------------------------------------------------------------------*
 138 :h3. Positive Testcase - single mode
 139 .*---------------------------------------------------------------------*
 140 :xmp tab=0.
 141
 142 <TC - Positive Testcase - single mode>
 143
 144 <EXECUTE>
 145
 146 <MODULE TTCN Temp Temp.ttcn>
 147 module Temp{
 148
 149 modulepar {
 150   charstring tsp_c :="tsp_c_default";
 151   charstring tsp_c0:="tsp_c_default0";
 152   charstring tsp_c1:="tsp_c_default1";
 153   charstring tsp_c2:="tsp_c_default2";
 154 }
 155
 156 type component MyComp {}
 157
 158 function f_setverdict_C(in charstring pl_value,in charstring pl_expected){
 159    if(pl_value == pl_expected) { setverdict(pass) } else{ setverdict(fail,match(pl_value,pl_expected)) };
 160 }
 161 with { extension "transparent" }
 162
 163 testcase tc_1() runs on MyComp{
 164   f_setverdict_C(tsp_c,"0");
 165   f_setverdict_C(tsp_c0,"0");
 166   f_setverdict_C(tsp_c1,"1");
 167   f_setverdict_C(tsp_c2,"2");
 168 }
 169
 170 control{ execute(tc_1()); }
 171
 172 }
 173
 174 <END_MODULE>
 175
 176
 177 <RESULT>
 178 Overall verdict: pass
 179 <END_RESULT>
 180
 181 <MODULE CFG oi1_before1 oi1_before1.cfg>
 182 [DEFINE]
 183 MACRO1=1
 184
 185 [ORDERED_INCLUDE]
 186 "oi2.cfg"
 187 [MODULE_PARAMETERS]
 188 tsp_c=$MACRO1
 189 tsp_c1=$MACRO1
 190 <END_MODULE>
 191
 192 <MODULE CFG oi2 oi2.cfg>
 193 [DEFINE]
 194 MACRO2:=2
 195 [MODULE_PARAMETERS]
 196 tsp_c=$MACRO2
 197 tsp_c2=$MACRO2
 198 <END_MODULE>
 199
 200
 201 <MODULE CFG oi oi.cfg>
 202 [LOGGING]
 203 LogSourceInfo := Stack
 204 ConsoleMask:= LOG_ALL
 205 [DEFINE]
 206 MACRO:=0
 207 [ORDERED_INCLUDE]
 208 "oi1_before1.cfg"
 209 [MODULE_PARAMETERS]
 210 tsp_c:=$MACRO
 211 tsp_c0:=$MACRO
 212 [EXECUTE]
 213 Temp.tc_1
 214
 215 <END_MODULE>
 216
 217 <END_TC>
 218
 219 :exmp.
 220
 221 .*---------------------------------------------------------------------*
 222 :h3. Positive Testcase - parallel mode
 223 .*---------------------------------------------------------------------*
 224 :xmp tab=0.
 225
 226 <TC - Positive Testcase - parallel mode>
 227
 228 <EXECUTE_PARALLEL>
 229
 230 <MODULE TTCN Temp Temp.ttcn>
 231 module Temp{
 232
 233 modulepar {
 234   charstring tsp_c :="tsp_c_default";
 235   charstring tsp_c0:="tsp_c_default0";
 236   charstring tsp_c1:="tsp_c_default1";
 237   charstring tsp_c2:="tsp_c_default2";
 238 }
 239
 240 type component MyComp {}
 241
 242 function f_setverdict_C(in charstring pl_value,in charstring pl_expected){
 243    if(pl_value == pl_expected) { setverdict(pass) } else{ setverdict(fail,match(pl_value,pl_expected)) };
 244 }
 245 with { extension "transparent" }
 246
 247 testcase tc_1() runs on MyComp{
 248   f_setverdict_C(tsp_c,"0");
 249   f_setverdict_C(tsp_c0,"0");
 250   f_setverdict_C(tsp_c1,"1");
 251   f_setverdict_C(tsp_c2,"2");
 252 }
 253
 254 control{ execute(tc_1()); }
 255
 256 }
 257
 258 <END_MODULE>
 259
 260
 261 <MODULE CFG oi1_before1 oi1_before1.cfg>
 262 [DEFINE]
 263 MACRO1=1
 264
 265 [ORDERED_INCLUDE]
 266 "oi2.cfg"
 267 [MODULE_PARAMETERS]
 268 tsp_c=$MACRO1
 269 tsp_c1=$MACRO1
 270 <END_MODULE>
 271
 272 <MODULE CFG oi2 oi2.cfg>
 273 [DEFINE]
 274 MACRO2:=2
 275 [MODULE_PARAMETERS]
 276 tsp_c=$MACRO2
 277 tsp_c2=$MACRO2
 278 <END_MODULE>
 279
 280 <MODULE CFG oi oi.cfg>
 281 [LOGGING]
 282 LogSourceInfo := Stack
 283 ConsoleMask:= LOG_ALL
 284 [DEFINE]
 285 MACRO:=0
 286 [ORDERED_INCLUDE]
 287 "oi1_before1.cfg"
 288 [MODULE_PARAMETERS]
 289 tsp_c:=$MACRO
 290 tsp_c0:=$MACRO
 291 [EXECUTE]
 292 Temp.tc_1
 293
 294 <END_MODULE>
 295
 296
 297 <RESULT>
 298 Overall verdict: pass
 299 <END_RESULT>
 300
 301 <END_TC>
 302
 303 :exmp.
 304
 305
 306
 307 .*---------------------------------------------------------------------*
 308 :h3. Ordered include - double import - single mode
 309 .*---------------------------------------------------------------------*
 310 :xmp tab=0.
 311
 312 <TC - Ordered include - double import - single mode>
 313
 314 <EXECUTE>
 315
 316 <MODULE TTCN Temp Temp.ttcn>
 317 module Temp{
 318
 319 modulepar {
 320   charstring tsp_c :="tsp_c_default";
 321   charstring tsp_c0:="tsp_c_default0";
 322   charstring tsp_c1:="tsp_c_default1";
 323   charstring tsp_c2:="tsp_c_default2";
 324 }
 325
 326 type component MyComp {}
 327
 328 function f_setverdict_C(in charstring pl_value,in charstring pl_expected){
 329    if(pl_value == pl_expected) { setverdict(pass) } else{ setverdict(fail,match(pl_value,pl_expected)) };
 330 }
 331 with { extension "transparent" }
 332
 333 testcase tc_1() runs on MyComp{
 334   f_setverdict_C(tsp_c,"0");
 335   f_setverdict_C(tsp_c0,"0");
 336   f_setverdict_C(tsp_c1,"1");
 337   f_setverdict_C(tsp_c2,"2");
 338 }
 339
 340 control{ execute(tc_1()); }
 341
 342 }
 343
 344 <END_MODULE>
 345
 346
 347 <RESULT>
 348 Overall verdict: pass
 349 <END_RESULT>
 350
 351 <MODULE CFG oi1_before1 oi1_before1.cfg>
 352
 353 [ORDERED_INCLUDE]
 354 "oi2.cfg"
 355 [MODULE_PARAMETERS]
 356 tsp_c="1"
 357 tsp_c1="1"
 358 <END_MODULE>
 359
 360 <MODULE CFG oi2 oi2.cfg>
 361 [DEFINE]
 362 [MODULE_PARAMETERS]
 363 tsp_c="2"
 364 tsp_c2="2"
 365 <END_MODULE>
 366
 367
 368 <MODULE CFG oi oi.cfg>
 369 [LOGGING]
 370 LogSourceInfo := Stack
 371 ConsoleMask:= LOG_ALL
 372 [DEFINE]
 373 MACRO:=0
 374 [ORDERED_INCLUDE]
 375 "oi1_before1.cfg"
 376 "oi1_before1.cfg"
 377 [MODULE_PARAMETERS]
 378 tsp_c:=$MACRO
 379 tsp_c0:=$MACRO
 380 [EXECUTE]
 381 Temp.tc_1
 382
 383 <END_MODULE>
 384
 385 <END_TC>
 386
 387 :exmp.
 388
 389 .*---------------------------------------------------------------------*
 390 :h3. Ordered include - double import - parallel mode
 391 .*---------------------------------------------------------------------*
 392 :xmp tab=0.
 393
 394 <TC - Ordered include - double import - parallel mode>
 395
 396 <EXECUTE_PARALLEL>
 397
 398 <MODULE TTCN Temp Temp.ttcn>
 399 module Temp{
 400
 401 modulepar {
 402   charstring tsp_c :="tsp_c_default";
 403   charstring tsp_c0:="tsp_c_default0";
 404   charstring tsp_c1:="tsp_c_default1";
 405   charstring tsp_c2:="tsp_c_default2";
 406 }
 407
 408 type component MyComp {}
 409
 410 function f_setverdict_C(in charstring pl_value,in charstring pl_expected){
 411    if(pl_value == pl_expected) { setverdict(pass) } else{ setverdict(fail,match(pl_value,pl_expected)) };
 412 }
 413 with { extension "transparent" }
 414
 415 testcase tc_1() runs on MyComp{
 416   f_setverdict_C(tsp_c,"0");
 417   f_setverdict_C(tsp_c0,"0");
 418   f_setverdict_C(tsp_c1,"1");
 419   f_setverdict_C(tsp_c2,"2");
 420 }
 421
 422 control{ execute(tc_1()); }
 423
 424 }
 425
 426 <END_MODULE>
 427
 428
 429 <MODULE CFG oi1_before1 oi1_before1.cfg>
 430 [ORDERED_INCLUDE]
 431 "oi2.cfg"
 432 [MODULE_PARAMETERS]
 433 tsp_c="1"
 434 tsp_c1="1"
 435 <END_MODULE>
 436
 437 <MODULE CFG oi2 oi2.cfg>
 438 [MODULE_PARAMETERS]
 439 tsp_c="2"
 440 tsp_c2="2"
 441 <END_MODULE>
 442
 443 <MODULE CFG oi oi.cfg>
 444 [LOGGING]
 445 LogSourceInfo := Stack
 446 ConsoleMask:= LOG_ALL
 447 [DEFINE]
 448 MACRO:=0
 449 [ORDERED_INCLUDE]
 450 "oi1_before1.cfg"
 451 "oi1_before1.cfg"
 452 [MODULE_PARAMETERS]
 453 tsp_c:=$MACRO
 454 tsp_c0:=$MACRO
 455 [EXECUTE]
 456 Temp.tc_1
 457
 458 <END_MODULE>
 459
 460
 461 <RESULT IF_FAIL COUNT 1>
 462 Overall verdict: pass
 463 <END_RESULT>
 464
 465 <END_TC>
 466
 467 :exmp.
 468
 469
 470 .*---------------------------------------------------------------------*
 471 :h2.Ordered include - Negative tests
 472 .*---------------------------------------------------------------------*
 473 .*---------------------------------------------------------------------*
 474 :h3.  Cyclic ordered import - single mode
 475 .*---------------------------------------------------------------------*
 476 :xmp tab=0.
 477
 478 <TC - Cyclic ordered import - single mode>
 479
 480 <EXECUTE>
 481
 482 <MODULE TTCN Temp Temp.ttcn>
 483 module Temp{
 484
 485 modulepar {
 486   charstring tsp_c :="tsp_c_default";
 487 }
 488
 489 type component MyComp {}
 490
 491 function f_setverdict_C(in charstring pl_value,in charstring pl_expected){
 492    if(pl_value == pl_expected) { setverdict(pass) } else{ setverdict(fail,match(pl_value,pl_expected)) };
 493 }
 494 with { extension "transparent" }
 495
 496 testcase tc_1() runs on MyComp{
 497   f_setverdict_C(tsp_c,"0");
 498 }
 499
 500 control{ execute(tc_1()); }
 501
 502 }
 503
 504 <END_MODULE>
 505
 506 <MODULE CFG oi1 oi1.cfg>
 507 [DEFINE]
 508 MACRO1=1
 509
 510 [ORDERED_INCLUDE]
 511 "oi2.cfg"
 512 [MODULE_PARAMETERS]
 513 tsp_c=$MACRO1
 514 <END_MODULE>
 515
 516 <MODULE CFG oi2 oi2.cfg>
 517 [DEFINE]
 518 MACRO2:=2
 519 [MODULE_PARAMETERS]
 520 tsp_c=$MACRO2
 521 [ORDERED_INCLUDE]
 522 "oi.cfg"
 523 <END_MODULE>
 524
 525
 526 <MODULE CFG oi oi.cfg>
 527 [LOGGING]
 528 LogSourceInfo := Stack
 529 ConsoleMask:= LOG_ALL
 530 [DEFINE]
 531 MACRO:=0
 532 [ORDERED_INCLUDE]
 533 "oi1.cfg"
 534 [MODULE_PARAMETERS]
 535 tsp_c:=$MACRO
 536 [EXECUTE]
 537 Temp.tc_1
 538
 539 <END_MODULE>
 540
 541 <RESULT>
 542 Parse error while pre-processing configuration file.*Circular import chain detected:
 543 <END_RESULT>
 544
 545 <END_TC>
 546
 547 :exmp.
 548
 549 .*---------------------------------------------------------------------*
 550 :h3. Cyclic ordered import  - parallel mode
 551 .*---------------------------------------------------------------------*
 552 :xmp tab=0.
 553
 554 <TC - Cyclic ordered import  - parallel mode>
 555
 556 <EXECUTE_PARALLEL>
 557
 558 <MODULE TTCN Temp Temp.ttcn>
 559 module Temp{
 560
 561 modulepar {
 562   charstring tsp_c :="tsp_c_default";
 563 }
 564
 565 type component MyComp {}
 566
 567 function f_setverdict_C(in charstring pl_value,in charstring pl_expected){
 568    if(pl_value == pl_expected) { setverdict(pass) } else{ setverdict(fail,match(pl_value,pl_expected)) };
 569 }
 570 with { extension "transparent" }
 571
 572 testcase tc_1() runs on MyComp{
 573   f_setverdict_C(tsp_c,"0");
 574 }
 575
 576 control{ execute(tc_1()); }
 577
 578 }
 579
 580 <END_MODULE>
 581
 582 <MODULE CFG oi1_before1 oi1_before1.cfg>
 583 [DEFINE]
 584 MACRO1=1
 585
 586 [ORDERED_INCLUDE]
 587 "oi2.cfg"
 588 [MODULE_PARAMETERS]
 589 tsp_c=$MACRO1
 590 <END_MODULE>
 591
 592 <MODULE CFG oi2 oi2.cfg>
 593 [ORDERED_INCLUDE]
 594 "oi.cfg"
 595
 596 [DEFINE]
 597 MACRO2:=2
 598 [MODULE_PARAMETERS]
 599 tsp_c=$MACRO2
 600 <END_MODULE>
 601
 602 <MODULE CFG oi oi.cfg>
 603 [LOGGING]
 604 LogSourceInfo := Stack
 605 ConsoleMask:= LOG_ALL
 606 [DEFINE]
 607 MACRO:=0
 608 [ORDERED_INCLUDE]
 609 "oi1_before1.cfg"
 610 [MODULE_PARAMETERS]
 611 tsp_c:=$MACRO
 612 [EXECUTE]
 613 Temp.tc_1
 614
 615 <END_MODULE>
 616
 617 <RESULT>
 618 Parse error while pre-processing configuration file.*Circular import chain detected:
 619 <END_RESULT>
 620
 621 <END_TC>
 622
 623 :exmp.
 624
 625 .*---------------------------------------------------------------------*
 626 :h3. Ordered import of empty filename - single mode
 627 .*---------------------------------------------------------------------*
 628 :xmp tab=0.
 629
 630 <TC - Ordered import of empty filename - single mode>
 631
 632 <EXECUTE>
 633
 634 <MODULE TTCN Temp Temp.ttcn>
 635 module Temp{
 636
 637 modulepar {
 638   charstring tsp_c :="tsp_c_default";
 639 }
 640
 641 type component MyComp {}
 642
 643 function f_setverdict_C(in charstring pl_value,in charstring pl_expected){
 644    if(pl_value == pl_expected) { setverdict(pass) } else{ setverdict(fail,match(pl_value,pl_expected)) };
 645 }
 646 with { extension "transparent" }
 647
 648 testcase tc_1() runs on MyComp{
 649   f_setverdict_C(tsp_c,"0");
 650 }
 651
 652 control{ execute(tc_1()); }
 653
 654 }
 655
 656 <END_MODULE>
 657
 658 <MODULE CFG oi1 oi1.cfg>
 659 [DEFINE]
 660 MACRO1=1
 661
 662 [ORDERED_INCLUDE]
 663 "oi2.cfg"
 664 [MODULE_PARAMETERS]
 665 tsp_c=$MACRO1
 666 <END_MODULE>
 667
 668 <MODULE CFG oi2 oi2.cfg>
 669 [DEFINE]
 670 MACRO2:=2
 671 [MODULE_PARAMETERS]
 672 tsp_c=$MACRO2
 673 [ORDERED_INCLUDE]
 674 ""
 675 <END_MODULE>
 676
 677
 678 <MODULE CFG oi oi.cfg>
 679 [LOGGING]
 680 LogSourceInfo := Stack
 681 ConsoleMask:= LOG_ALL
 682 [DEFINE]
 683 MACRO:=0
 684 [ORDERED_INCLUDE]
 685 "oi1.cfg"
 686 [MODULE_PARAMETERS]
 687 tsp_c:=$MACRO
 688 [EXECUTE]
 689 Temp.tc_1
 690
 691 <END_MODULE>
 692
 693 <RESULT>
 694 Parse error while pre-processing configuration file.*Empty file name
 695 <END_RESULT>
 696
 697 <END_TC>
 698
 699 :exmp.
 700
 701 .*---------------------------------------------------------------------*
 702 :h3. Ordered import of empty filename - parallel mode
 703 .*---------------------------------------------------------------------*
 704 :xmp tab=0.
 705
 706 <TC - Ordered import of empty filename  - parallel mode>
 707
 708 <EXECUTE_PARALLEL>
 709
 710 <MODULE TTCN Temp Temp.ttcn>
 711 module Temp{
 712
 713 modulepar {
 714   charstring tsp_c :="tsp_c_default";
 715 }
 716
 717 type component MyComp {}
 718
 719 function f_setverdict_C(in charstring pl_value,in charstring pl_expected){
 720    if(pl_value == pl_expected) { setverdict(pass) } else{ setverdict(fail,match(pl_value,pl_expected)) };
 721 }
 722 with { extension "transparent" }
 723
 724 testcase tc_1() runs on MyComp{
 725   f_setverdict_C(tsp_c,"0");  //pass
 726 }
 727
 728 control{ execute(tc_1()); }
 729
 730 }
 731
 732 <END_MODULE>
 733
 734 <MODULE CFG oi1_before1 oi1_before1.cfg>
 735 [DEFINE]
 736 MACRO1=1
 737
 738 [ORDERED_INCLUDE]
 739 "oi2.cfg"
 740 [MODULE_PARAMETERS]
 741 tsp_c=$MACRO1
 742 <END_MODULE>
 743
 744 <MODULE CFG oi2 oi2.cfg>
 745 [ORDERED_INCLUDE]
 746 ""
 747
 748 [DEFINE]
 749 MACRO2:=2
 750 [MODULE_PARAMETERS]
 751 tsp_c=$MACRO2
 752 <END_MODULE>
 753
 754 <MODULE CFG oi oi.cfg>
 755 [LOGGING]
 756 LogSourceInfo := Stack
 757 ConsoleMask:= LOG_ALL
 758 [DEFINE]
 759 MACRO:=0
 760 [ORDERED_INCLUDE]
 761 "oi1_before1.cfg"
 762 [MODULE_PARAMETERS]
 763 tsp_c:=$MACRO
 764 [EXECUTE]
 765 Temp.tc_1
 766
 767 <END_MODULE>
 768
 769 <RESULT>
 770 Parse error while pre-processing configuration file.*Empty file name
 771 <END_RESULT>
 772
 773 <END_TC>
 774
 775 :exmp.
 776
 777 .*---------------------------------------------------------------------*
 778 :h3. Ordered import of not existing filename - single mode
 779 .*---------------------------------------------------------------------*
 780 :xmp tab=0.
 781
 782 <TC - Ordered import of not existing filename - single mode>
 783
 784 <EXECUTE>
 785
 786 <MODULE TTCN Temp Temp.ttcn>
 787 module Temp{
 788
 789 modulepar {
 790   charstring tsp_c :="tsp_c_default";
 791 }
 792
 793 type component MyComp {}
 794
 795 function f_setverdict_C(in charstring pl_value,in charstring pl_expected){
 796    if(pl_value == pl_expected) { setverdict(pass) } else{ setverdict(fail,match(pl_value,pl_expected)) };
 797 }
 798 with { extension "transparent" }
 799
 800 testcase tc_1() runs on MyComp{
 801   f_setverdict_C(tsp_c,"0");
 802 }
 803
 804 control{ execute(tc_1()); }
 805
 806 }
 807
 808 <END_MODULE>
 809
 810 <MODULE CFG oi1 oi1.cfg>
 811 [DEFINE]
 812 MACRO1=1
 813
 814 [ORDERED_INCLUDE]
 815 "oi2.cfg"
 816 [MODULE_PARAMETERS]
 817 tsp_c=$MACRO1
 818 <END_MODULE>
 819
 820 <MODULE CFG oi2 oi2.cfg>
 821 [DEFINE]
 822 MACRO2:=2
 823 [MODULE_PARAMETERS]
 824 tsp_c=$MACRO2
 825 [ORDERED_INCLUDE]
 826 "Subidubi.cfg"
 827 <END_MODULE>
 828
 829
 830 <MODULE CFG oi oi.cfg>
 831 [LOGGING]
 832 LogSourceInfo := Stack
 833 ConsoleMask:= LOG_ALL
 834 [DEFINE]
 835 MACRO:=0
 836 [ORDERED_INCLUDE]
 837 "oi1.cfg"
 838 [MODULE_PARAMETERS]
 839 tsp_c:=$MACRO
 840 [EXECUTE]
 841 Temp.tc_1
 842
 843 <END_MODULE>
 844
 845 <RESULT>
 846 Parse error while pre-processing configuration file.*File not found:.*Config_Parser\/Subidubi.cfg
 847 <END_RESULT>
 848 <RESULT>
 849 Parse error in configuration file .*Config_Parser\/oi2.cfg.*File not found:.*Config_Parser\/Subidubi.cfg
 850 <END_RESULT>
 851
 852
 853 <END_TC>
 854
 855 :exmp.
 856
 857 .*---------------------------------------------------------------------*
 858 :h3. Ordered import of not existing filename - parallel mode
 859 .*---------------------------------------------------------------------*
 860 :xmp tab=0.
 861
 862 <TC - Ordered import of not existing filename  - parallel mode>
 863
 864 <EXECUTE_PARALLEL>
 865
 866 <MODULE TTCN Temp Temp.ttcn>
 867 module Temp{
 868
 869 modulepar {
 870   charstring tsp_c :="tsp_c_default";
 871 }
 872
 873 type component MyComp {}
 874
 875 function f_setverdict_C(in charstring pl_value,in charstring pl_expected){
 876    if(pl_value == pl_expected) { setverdict(pass) } else{ setverdict(fail,match(pl_value,pl_expected)) };
 877 }
 878 with { extension "transparent" }
 879
 880 testcase tc_1() runs on MyComp{
 881   f_setverdict_C(tsp_c,"0");  //pass
 882 }
 883
 884 control{ execute(tc_1()); }
 885
 886 }
 887
 888 <END_MODULE>
 889
 890 <MODULE CFG oi1_before1 oi1_before1.cfg>
 891 [DEFINE]
 892 MACRO1=1
 893
 894 [ORDERED_INCLUDE]
 895 "oi2.cfg"
 896 [MODULE_PARAMETERS]
 897 tsp_c=$MACRO1
 898 <END_MODULE>
 899
 900 <MODULE CFG oi2 oi2.cfg>
 901 [ORDERED_INCLUDE]
 902 "Subidubi.cfg"
 903
 904 [DEFINE]
 905 MACRO2:=2
 906 [MODULE_PARAMETERS]
 907 tsp_c=$MACRO2
 908 <END_MODULE>
 909
 910 <MODULE CFG oi oi.cfg>
 911 [LOGGING]
 912 LogSourceInfo := Stack
 913 ConsoleMask:= LOG_ALL
 914 [DEFINE]
 915 MACRO:=0
 916 [ORDERED_INCLUDE]
 917 "oi1_before1.cfg"
 918 [MODULE_PARAMETERS]
 919 tsp_c:=$MACRO
 920 [EXECUTE]
 921 Temp.tc_1
 922
 923 <END_MODULE>
 924
 925 <RESULT>
 926 Parse error while pre-processing configuration file.*File not found:.*Config_Parser\/Subidubi.cfg
 927 <END_RESULT>
 928 <RESULT>
 929 Parse error in configuration file .*Config_Parser\/oi2.cfg.*File not found:.*Config_Parser\/Subidubi.cfg
 930 <END_RESULT>
 931
 932 <END_TC>
 933
 934 :exmp.
 935 *---------------------------------------------------------------------*
 936 :h1.Abbreviations
 937 .*---------------------------------------------------------------------*
 938 :list.
 939 :li D='ASN.1'.Abstract Syntax Notation 1
 940 :li D='EDML'.Ericsson Document Markup Language
 941 :li D='SA'.Semantic Analyser
 942 :li D='TTCN-3'.Test and Test Control Notation version 3
 943 :elist.
 944
 945 .*---------------------------------------------------------------------*
 946 :h1.References
 947 .*---------------------------------------------------------------------*
 948 :list.
 949 :li D='[1]'.ETH/RZ-2005:0120 Uen
 950 :nl.Requirement Specification for the TITAN TTCN-3 Executor
 951 :li D='[2]'.1/174 02-FCPCA 101 42 Uen
 952 :nl.Statement of Compliance for TITAN project
 953 :li D='[3]'.ETSI ES 201 873-1, v3.0.0 Mockup v1 (2004-03):
 954 :nl.Testing and Test Control Notation version 3.,
 955 :nl.Part 1: TTCN-3 Core Language
 956 :elist.
 957
 958 .*---------------------------------------------------------------------*
 959 :h1.Terminology
 960 .*---------------------------------------------------------------------*
 961 :list.
 962 :li D='TITAN'.Ericsson's TTCN-3 Test Environment
 963 :elist.
 964
 965 :etext.