function_test/Semantic_Analyser/SA_6_TD.script

   1 .******************************************************************************
   2 .* Copyright (c) 2000-2015 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.
  18 :rev.
  19 :date.2010.07.02.
  20
  21 :prep.ETH/RZX Ferenc Kovacs
  22 :appr.ETH/RZ (Gyula Koos)
  23 :checked.ETHGRY
  24
  25 :title.Test description of the Semantic Analyzer: Old test cases
  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        2010-07-02  EKRISZA      support for non-complete record/record ofs.
  37 -     2005-02-19   ESNDPAL     New document for TITAN R6
  38 :exmp.
  39 .*---------------------------------------------------------------------*
  40 :h2.Purpose
  41 .*---------------------------------------------------------------------*
  42 This document contains old test cases from the previous TITAN project
  43 for TTCN-3 Semantic Analyser. These test cases shall be moved to
  44 different test descriptions in forthcoming projects.
  45
  46 .*---------------------------------------------------------------------*
  47 :h2.Positive test cases for Compound types
  48 .*---------------------------------------------------------------------*
  49
  50 .*---------------------------------------------------------------------*
  51 :h3.Positive test cases regarding value list notation - constant
  52 .*---------------------------------------------------------------------*
  53 :xmp tab=0.
  54
  55 <TC -  Positive test cases regarding value list notation - constant>
  56
  57 <COMPILEGCC>
  58 <VERDICT_LEAF PASS>
  59 <MODULE TTCN Temp Temp.ttcn>
  60 module Temp {
  61
  62
  63 type record aTest  {integer i, charstring c, bTest r optional}
  64 type record bTest  {integer i , charstring c optional}
  65
  66 type union uTest {aTest a, bTest b}
  67
  68 const aTest c1 := {1, "a", {2, "b"}}
  69 const aTest c2 := {1, "a", {2, omit}}
  70 const aTest c3 := {1, "a", omit}
  71
  72 const aTest c4 := {1, "a", {i := 2, c := "b"}}
  73 const aTest c5 := {i := 1, c := "a", r := {2, omit}}
  74
  75 const bTest c6 := {2, "b"}
  76 const aTest c7 := {1, "a", c6}
  77
  78 const uTest u1 := {a := {1, "a", {2, "b"}}}
  79 const uTest u2 := {a := {1, "a", {i := 2, c := "b"}}}
  80 const uTest u3 := {a := {i := 1, c := "a", r := {2, omit}}}
  81 const uTest u4 := {a := {1, "a", c6}}
  82
  83 }
  84 <END_MODULE>
  85 <RESULT IF_PASS NEGATIVE>
  86 (?is)\berror:
  87 <END_RESULT>
  88 <END_TC>
  89
  90 :exmp.
  91
  92 .*---------------------------------------------------------------------*
  93 :h3.Positive test cases regarding value list notation - template
  94 .*---------------------------------------------------------------------*
  95 :xmp tab=0.
  96
  97 <TC -  Positive test cases regarding value list notation - template>
  98
  99 <COMPILEGCC>
 100 <VERDICT_LEAF PASS>
 101 <MODULE TTCN Temp Temp.ttcn>
 102 module Temp {
 103
 104
 105 type record aTest  {integer i, charstring c, bTest r optional}
 106 type record bTest  {integer i , charstring c optional}
 107
 108 type union uTest {aTest a, bTest b}
 109
 110 template aTest c1 := {1, "a", {2, "b"}}
 111 template aTest c2 := {1, "a", {2, omit}}
 112 template aTest c3 := {1, "a", omit}
 113
 114 template aTest c4 := {1, "a", {i := 2, c := "b"}}
 115 template aTest c5 := {i := 1, c := "a", r := {2, omit}}
 116
 117 template bTest c6 := {2, "b"}
 118 template aTest c7 := {1, "a", c6}
 119
 120 template uTest u1 := {a := {1, "a", {2, "b"}}}
 121 template uTest u2 := {a := {1, "a", {i := 2, c := "b"}}}
 122 template uTest u3 := {a := {i := 1, c := "a", r := {2, omit}}}
 123 template uTest u4 := {a := {1, "a", c6}}
 124
 125
 126
 127 }
 128 <END_MODULE>
 129 <RESULT IF_PASS NEGATIVE>
 130 (?is)\berror:
 131 <END_RESULT>
 132 <END_TC>
 133
 134 :exmp.
 135
 136
 137 .*---------------------------------------------------------------------*
 138 :h2.Wrong order in value list notation (type)
 139 .*---------------------------------------------------------------------*
 140
 141 .*---------------------------------------------------------------------*
 142 :h3.Record fields in wrong order - constant
 143 .*---------------------------------------------------------------------*
 144 :xmp tab=0.
 145
 146 <TC -  Record fields in wrong order - constant>
 147
 148 <COMPILE>
 149 <VERDICT_LEAF PASS>
 150 <MODULE TTCN Temp Temp.ttcn>
 151 module Temp {
 152
 153
 154 type record aTest  {integer i, charstring c, bTest r}
 155 type record bTest  {integer i , charstring c}
 156
 157 const aTest con := {{2, "bTest"},"aTest", 1}
 158
 159 }
 160 <END_MODULE>
 161 <RESULT IF_PASS COUNT 1>
 162 (?im)error.+?integer.+?value.+?expected
 163 <END_RESULT>
 164 <RESULT IF_PASS COUNT 1>
 165 (?im)error.+?Record.+?value.+?expected
 166 <END_RESULT>
 167 <RESULT IF_PASS COUNT 2>
 168 (?is)\berror:
 169 <END_RESULT>
 170 <END_TC>
 171
 172 :exmp.
 173
 174 .*---------------------------------------------------------------------*
 175 :h3.Contained record fields in wrong order - constant
 176 .*---------------------------------------------------------------------*
 177 :xmp tab=0.
 178
 179 <TC -  Contained record fields in wrong order - constant>
 180
 181 <COMPILE>
 182 <VERDICT_LEAF PASS>
 183 <MODULE TTCN Temp Temp.ttcn>
 184 module Temp {
 185
 186
 187 type record aTest  {integer i, charstring c, bTest r}
 188 type record bTest  {integer i, charstring c}
 189
 190 const aTest con := {1, "aTest",{"bTest",3}}
 191
 192
 193 }
 194 <END_MODULE>
 195 <RESULT IF_PASS COUNT 1>
 196 (?im)error.+?integer.+?value.+?expected
 197 <END_RESULT>
 198 <RESULT IF_PASS COUNT 1>
 199 (?im)error.+?character.+?string.+?value.+?expected
 200 <END_RESULT>
 201 <RESULT IF_PASS COUNT 2>
 202 (?is)\berror:
 203 <END_RESULT>
 204 <END_TC>
 205
 206 :exmp.
 207
 208 .*---------------------------------------------------------------------*
 209 :h3.Omitted field in wrong place - constant
 210 .*---------------------------------------------------------------------*
 211 :xmp tab=0.
 212
 213 <TC -  Omitted field in wrong place - constant>
 214
 215 <COMPILE>
 216 <VERDICT_LEAF PASS>
 217 <MODULE TTCN Temp Temp.ttcn>
 218 module Temp {
 219
 220
 221 type record aTest  {integer i, charstring c, bTest r}
 222 type record bTest  {integer i optional, charstring c}
 223
 224 const aTest con := {1, "aTest", {"bTest", omit}}
 225
 226
 227 }
 228 <END_MODULE>
 229 <RESULT IF_PASS COUNT 1>
 230 (?im)error.+?integer.+?value.+?expected
 231 <END_RESULT>
 232 <RESULT IF_PASS COUNT 1>
 233 (?im)error.+?omit.+?not.+?allowed
 234 <END_RESULT>
 235 <RESULT IF_PASS COUNT 2>
 236 (?is)\berror:
 237 <END_RESULT>
 238 <END_TC>
 239
 240 :exmp.
 241
 242 .*---------------------------------------------------------------------*
 243 :h3.Contained record fields in wrong order inside record of - constant
 244 .*---------------------------------------------------------------------*
 245 :xmp tab=0.
 246
 247 <TC -  Contained record fields in wrong order inside record of - constant>
 248
 249 <COMPILE>
 250 <VERDICT_LEAF PASS>
 251 <MODULE TTCN Temp Temp.ttcn>
 252 module Temp {
 253
 254
 255 type record of bTest aTest;
 256 type record bTest  {integer i , charstring c}
 257
 258 const aTest con := {{1, "aTest"}, {"bTest",2}}
 259
 260 }
 261 <END_MODULE>
 262 <RESULT IF_PASS COUNT 1>
 263 (?im)error.+?integer.+?value.+?expected
 264 <END_RESULT>
 265 <RESULT IF_PASS COUNT 1>
 266 (?im)error.+?character.+?string.+?value.+?expected
 267 <END_RESULT>
 268 <RESULT IF_PASS COUNT 2>
 269 (?is)\berror:
 270 <END_RESULT>
 271 <END_TC>
 272
 273 :exmp.
 274
 275 .*---------------------------------------------------------------------*
 276 :h3.Contained record fields in wrong order inside union - constant
 277 .*---------------------------------------------------------------------*
 278 :xmp tab=0.
 279
 280 <TC -  Contained record fields in wrong order inside union - constant>
 281
 282 <COMPILE>
 283 <VERDICT_LEAF PASS>
 284 <MODULE TTCN Temp Temp.ttcn>
 285 module Temp {
 286
 287
 288 type record aTest  {integer i, charstring c, bTest r}
 289 type record bTest  {integer i , charstring c}
 290
 291 type union cTest {aTest a, bTest b}
 292
 293 const cTest con := {b := {1, 2}}
 294
 295 }
 296 <END_MODULE>
 297 <RESULT IF_PASS COUNT 1>
 298 (?im)error.+?character.+?string.+?value.+?expected
 299 <END_RESULT>
 300 <RESULT IF_PASS COUNT 1>
 301 (?is)\berror:
 302 <END_RESULT>
 303 <END_TC>
 304
 305 :exmp.
 306
 307 .*---------------------------------------------------------------------*
 308 :h3.Wrong value in record of - constant
 309 .*---------------------------------------------------------------------*
 310 :xmp tab=0.
 311
 312 <TC -  Wrong value in record of - constant>
 313
 314 <COMPILE>
 315 <VERDICT_LEAF PASS>
 316 <MODULE TTCN Temp Temp.ttcn>
 317 module Temp {
 318
 319
 320 type record of bTest aTest;
 321 type set bTest  {integer i, boolean b}
 322 const aTest con := {1, {b := true, i := 1}}
 323
 324 }
 325 <END_MODULE>
 326 <RESULT IF_PASS COUNT 1>
 327 (?im)error.+?Set.+?value.+?expected
 328 <END_RESULT>
 329 <RESULT IF_PASS COUNT 1>
 330 (?is)\berror:
 331 <END_RESULT>
 332 <END_TC>
 333
 334 :exmp.
 335
 336 .*---------------------------------------------------------------------*
 337 :h3.Wrong value in contained record inside union - constant
 338 .*---------------------------------------------------------------------*
 339 :xmp tab=0.
 340
 341 <TC -  Wrong value in contained record inside union - constant>
 342
 343 <COMPILE>
 344 <VERDICT_LEAF PASS>
 345 <MODULE TTCN Temp Temp.ttcn>
 346 module Temp {
 347
 348
 349 type record bTest  {integer i , charstring c}
 350 type union cTest {integer i, bTest b}
 351
 352 const cTest con := {b := {"aTest", "bTest"}}
 353
 354
 355 }
 356 <END_MODULE>
 357 <RESULT IF_PASS COUNT 1>
 358 (?im)error.+?integer.+?value.+?expected
 359 <END_RESULT>
 360 <RESULT IF_PASS COUNT 1>
 361 (?is)\berror:
 362 <END_RESULT>
 363 <END_TC>
 364
 365 :exmp.
 366
 367 .*---------------------------------------------------------------------*
 368 :h3.Wrong values in record - constant
 369 .*---------------------------------------------------------------------*
 370 :xmp tab=0.
 371
 372 <TC -  Wrong values in record - constant>
 373
 374 <COMPILE>
 375 <VERDICT_LEAF PASS>
 376 <MODULE TTCN Temp Temp.ttcn>
 377 module Temp {
 378
 379
 380 type record bTest  {integer i , cTest u}
 381 type union cTest {integer i, boolean b}
 382
 383 const bTest con := {1, 2}
 384
 385 }
 386 <END_MODULE>
 387 <RESULT IF_PASS COUNT 1>
 388 (?im)error.+?union.+?value.+?expected
 389 <END_RESULT>
 390 <RESULT IF_PASS COUNT 1>
 391 (?is)\berror:
 392 <END_RESULT>
 393 <END_TC>
 394
 395 :exmp.
 396
 397 .*---------------------------------------------------------------------*
 398 :h3.Value with wrong type in record - constant1
 399 .*---------------------------------------------------------------------*
 400 :xmp tab=0.
 401
 402 <TC -  Value with wrong type in record - constant1>
 403
 404 <COMPILE>
 405 <VERDICT_LEAF PASS>
 406 <MODULE TTCN Temp Temp.ttcn>
 407 module Temp {
 408
 409
 410 type integer iType (1, 2, 3, 4)
 411 type record bTest  {iType i}
 412
 413 const bTest con := {true}
 414
 415 }
 416 <END_MODULE>
 417 <RESULT IF_PASS COUNT 1>
 418 (?im)error.+?integer.+?value.+?expected
 419 <END_RESULT>
 420 <RESULT IF_PASS COUNT 1>
 421 (?is)\berror:
 422 <END_RESULT>
 423 <END_TC>
 424
 425 :exmp.
 426
 427 .*---------------------------------------------------------------------*
 428 :h3.Value with wrong type in record - constant2
 429 .*---------------------------------------------------------------------*
 430 :xmp tab=0.
 431
 432 <TC -  Value with wrong type in record - constant2>
 433
 434 <COMPILE>
 435 <VERDICT_LEAF PASS>
 436 <MODULE TTCN Temp Temp.ttcn>
 437 module Temp {
 438
 439
 440 type integer iType (1, 2, 3, 4)
 441 type record bTest  {iType i}
 442
 443 const bTest con := {str2int("6")}
 444
 445 }
 446 <END_MODULE>
 447 <RESULT IF_PASS COUNT 1>
 448 (?im)error.+?not.+?valid.+?value.+?for.+?subtype
 449 <END_RESULT>
 450 <RESULT IF_PASS COUNT 1>
 451 (?is)\berror:
 452 <END_RESULT>
 453 <END_TC>
 454
 455 :exmp.
 456
 457 .*---------------------------------------------------------------------*
 458 :h3.Wrong value in contained record, bitstring - constant
 459 .*---------------------------------------------------------------------*
 460 :xmp tab=0.
 461
 462 <TC -  Wrong value in contained record, bitstring - constant>
 463
 464 <COMPILE>
 465 <VERDICT_LEAF PASS>
 466 <MODULE TTCN Temp Temp.ttcn>
 467 module Temp {
 468
 469
 470 type record aTest  {integer i, bTest r}
 471 type record bTest  {integer i , bitstring b}
 472
 473 const aTest con := {1, {2, 1}}
 474
 475
 476 }
 477 <END_MODULE>
 478 <RESULT IF_PASS COUNT 1>
 479 (?im)error.+?bitstring.+?value.+?expected
 480 <END_RESULT>
 481 <RESULT IF_PASS COUNT 1>
 482 (?is)\berror:
 483 <END_RESULT>
 484 <END_TC>
 485
 486 :exmp.
 487
 488 .*---------------------------------------------------------------------*
 489 :h3.Wrong value in contained record, hexstring - constant
 490 .*---------------------------------------------------------------------*
 491 :xmp tab=0.
 492
 493 <TC -  Wrong value in contained record, hexstring - constant>
 494
 495 <COMPILE>
 496 <VERDICT_LEAF PASS>
 497 <MODULE TTCN Temp Temp.ttcn>
 498 module Temp {
 499
 500
 501 type record aTest  {integer i, bTest r}
 502 type record bTest  {integer i , hexstring h}
 503
 504 const aTest con := {1, {2, 1}}
 505
 506
 507 }
 508 <END_MODULE>
 509 <RESULT IF_PASS COUNT 1>
 510 (?im)error.+?hexstring.+?value.+?expected
 511 <END_RESULT>
 512 <RESULT IF_PASS COUNT 1>
 513 (?is)\berror:
 514 <END_RESULT>
 515 <END_TC>
 516
 517 :exmp.
 518
 519 .*---------------------------------------------------------------------*
 520 :h3.Wrong value in contained record, octetstring - constant
 521 .*---------------------------------------------------------------------*
 522 :xmp tab=0.
 523
 524 <TC -  Wrong value in contained record, octetstring - constant>
 525
 526 <COMPILE>
 527 <VERDICT_LEAF PASS>
 528 <MODULE TTCN Temp Temp.ttcn>
 529 module Temp {
 530
 531
 532 type record aTest  {integer i, bTest r}
 533 type record bTest  {integer i , octetstring o}
 534
 535 const aTest con := {1, {2, 1}}
 536
 537 }
 538 <END_MODULE>
 539 <RESULT IF_PASS COUNT 1>
 540 (?im)error.+?octetstring.+?value.+?expected
 541 <END_RESULT>
 542 <RESULT IF_PASS COUNT 1>
 543 (?is)\berror:
 544 <END_RESULT>
 545 <END_TC>
 546
 547 :exmp.
 548
 549 .*---------------------------------------------------------------------*
 550 :h3.Wrong value in contained record, boolean - constant
 551 .*---------------------------------------------------------------------*
 552 :xmp tab=0.
 553
 554 <TC -  Wrong value in contained record, boolean - constant>
 555
 556 <COMPILE>
 557 <VERDICT_LEAF PASS>
 558 <MODULE TTCN Temp Temp.ttcn>
 559 module Temp {
 560
 561
 562 type record aTest  {integer i, bTest r}
 563 type record bTest  {integer i , boolean b}
 564
 565 const aTest con := {1, {2, 1}}
 566
 567 }
 568 <END_MODULE>
 569 <RESULT IF_PASS COUNT 1>
 570 (?im)error.+?boolean.+?value.+?expected
 571 <END_RESULT>
 572 <RESULT IF_PASS COUNT 1>
 573 (?is)\berror:
 574 <END_RESULT>
 575 <END_TC>
 576
 577 :exmp.
 578
 579 .*---------------------------------------------------------------------*
 580 :h3.Record fields in wrong order - template
 581 .*---------------------------------------------------------------------*
 582 :xmp tab=0.
 583
 584 <TC -  Record fields in wrong order - template>
 585
 586 <COMPILE>
 587 <VERDICT_LEAF PASS>
 588 <MODULE TTCN Temp Temp.ttcn>
 589 module Temp {
 590
 591
 592 type record aTest  {integer i, charstring c, bTest r}
 593 type record bTest  {integer i , charstring c}
 594
 595 template aTest con := {{2, "bTest"},"aTest", 1}
 596
 597 }
 598 <END_MODULE>
 599 <RESULT IF_PASS COUNT 1>
 600 (?im)error.+?value.+?list.+?notation.+?cannot.+?used.+?for.+?type.+?integer
 601 <END_RESULT>
 602 <RESULT IF_PASS COUNT 1>
 603 (?im)error.+?Record.+?value.+?expected
 604 <END_RESULT>
 605 <RESULT IF_PASS COUNT 2>
 606 (?is)\berror:
 607 <END_RESULT>
 608 <END_TC>
 609
 610 :exmp.
 611
 612 .*---------------------------------------------------------------------*
 613 :h3.Contained record fields in wrong order - template
 614 .*---------------------------------------------------------------------*
 615 :xmp tab=0.
 616
 617 <TC -  Contained record fields in wrong order - template>
 618
 619 <COMPILE>
 620 <VERDICT_LEAF PASS>
 621 <MODULE TTCN Temp Temp.ttcn>
 622 module Temp {
 623
 624
 625 type record aTest  {integer i, charstring c, bTest r}
 626 type record bTest  {integer i, charstring c}
 627
 628 template aTest con := {1, "aTest",{"bTest",3}}
 629
 630
 631 }
 632 <END_MODULE>
 633 <RESULT IF_PASS COUNT 1>
 634 (?im)error.+?integer.+?value.+?expected
 635 <END_RESULT>
 636 <RESULT IF_PASS COUNT 1>
 637 (?im)error.+?character.+?string.+?value.+?expected
 638 <END_RESULT>
 639 <RESULT IF_PASS COUNT 2>
 640 (?is)\berror:
 641 <END_RESULT>
 642 <END_TC>
 643
 644 :exmp.
 645
 646 .*---------------------------------------------------------------------*
 647 :h3.Omitted field in wrong place - template
 648 .*---------------------------------------------------------------------*
 649 :xmp tab=0.
 650
 651 <TC -  Omitted field in wrong place - template>
 652
 653 <COMPILE>
 654 <VERDICT_LEAF PASS>
 655 <MODULE TTCN Temp Temp.ttcn>
 656 module Temp {
 657
 658
 659 type record aTest  {integer i, charstring c, bTest r}
 660 type record bTest  {integer i optional, charstring c}
 661
 662 template aTest con := {1, "aTest", {"bTest", omit}}
 663
 664
 665 }
 666 <END_MODULE>
 667 <RESULT IF_PASS COUNT 1>
 668 (?im)error.+?integer.+?value.+?expected
 669 <END_RESULT>
 670 <RESULT IF_PASS COUNT 1>
 671 (?im)error.+?omit.+?not.+?allowed.+?context
 672 <END_RESULT>
 673 <RESULT IF_PASS COUNT 2>
 674 (?is)\berror:
 675 <END_RESULT>
 676 <END_TC>
 677
 678 :exmp.
 679
 680 .*---------------------------------------------------------------------*
 681 :h3.Contained record fields in wrong order inside record of - template
 682 .*---------------------------------------------------------------------*
 683 :xmp tab=0.
 684
 685 <TC -  Contained record fields in wrong order inside record of - template>
 686
 687 <COMPILE>
 688 <VERDICT_LEAF PASS>
 689 <MODULE TTCN Temp Temp.ttcn>
 690 module Temp {
 691
 692
 693 type record of bTest aTest;
 694 type record bTest  {integer i , charstring c}
 695
 696 template aTest con := {{1, "aTest"}, {"bTest",2}}
 697
 698 }
 699 <END_MODULE>
 700 <RESULT IF_PASS COUNT 1>
 701 (?im)error.+?integer.+?value.+?expected
 702 <END_RESULT>
 703 <RESULT IF_PASS COUNT 1>
 704 (?im)error.+?character.+?string.+?value.+?expected
 705 <END_RESULT>
 706 <RESULT IF_PASS COUNT 2>
 707 (?is)\berror:
 708 <END_RESULT>
 709 <END_TC>
 710
 711 :exmp.
 712
 713 .*---------------------------------------------------------------------*
 714 :h3.Contained record fields in wrong order inside union - template
 715 .*---------------------------------------------------------------------*
 716 :xmp tab=0.
 717
 718 <TC -  Contained record fields in wrong order inside union - template>
 719
 720 <COMPILE>
 721 <VERDICT_LEAF PASS>
 722 <MODULE TTCN Temp Temp.ttcn>
 723 module Temp {
 724
 725
 726 type record aTest  {integer i, charstring c, bTest r}
 727 type record bTest  {integer i , charstring c}
 728
 729 type union cTest {aTest a, bTest b}
 730
 731 template cTest con := {b := {1, 2}}
 732
 733 }
 734 <END_MODULE>
 735 <RESULT IF_PASS COUNT 1>
 736 (?im)error.+?character.+?string.+?value.+?expected
 737 <END_RESULT>
 738 <RESULT IF_PASS COUNT 1>
 739 (?is)\berror:
 740 <END_RESULT>
 741 <END_TC>
 742
 743 :exmp.
 744
 745 .*---------------------------------------------------------------------*
 746 :h3.Wrong value in record of - template
 747 .*---------------------------------------------------------------------*
 748 :xmp tab=0.
 749
 750 <TC -  Wrong value in record of - template>
 751
 752 <COMPILE>
 753 <VERDICT_LEAF PASS>
 754 <MODULE TTCN Temp Temp.ttcn>
 755 module Temp {
 756
 757
 758 type record of bTest aTest;
 759 type set bTest  {integer i, boolean b}
 760 template aTest con := {1, {b := true, i := 1}}
 761
 762 }
 763 <END_MODULE>
 764 <RESULT IF_PASS COUNT 1>
 765 (?im)error.+?Set.+?value.+?expected
 766 <END_RESULT>
 767 <RESULT IF_PASS COUNT 1>
 768 (?is)\berror:
 769 <END_RESULT>
 770 <END_TC>
 771
 772 :exmp.
 773
 774 .*---------------------------------------------------------------------*
 775 :h3.Wrong value in contained record inside union - template
 776 .*---------------------------------------------------------------------*
 777 :xmp tab=0.
 778
 779 <TC -  Wrong value in contained record inside union - template>
 780
 781 <COMPILE>
 782 <VERDICT_LEAF PASS>
 783 <MODULE TTCN Temp Temp.ttcn>
 784 module Temp {
 785
 786
 787 type record bTest  {integer i , charstring c}
 788 type union cTest {integer i, bTest b}
 789
 790 template cTest con := {b := {"aTest", "bTest"}}
 791
 792
 793 }
 794 <END_MODULE>
 795 <RESULT IF_PASS COUNT 1>
 796 (?im)error.+?integer.+?value.+?expected
 797 <END_RESULT>
 798 <RESULT IF_PASS COUNT 1>
 799 (?is)\berror:
 800 <END_RESULT>
 801 <END_TC>
 802
 803 :exmp.
 804
 805 .*---------------------------------------------------------------------*
 806 :h3.Wrong values in record - template
 807 .*---------------------------------------------------------------------*
 808 :xmp tab=0.
 809
 810 <TC -  Wrong values in record - template>
 811
 812 <COMPILE>
 813 <VERDICT_LEAF PASS>
 814 <MODULE TTCN Temp Temp.ttcn>
 815 module Temp {
 816
 817
 818 type record bTest  {integer i , cTest u}
 819 type union cTest {integer i, boolean b}
 820
 821 template bTest con := {1, 2}
 822
 823 }
 824 <END_MODULE>
 825 <RESULT IF_PASS COUNT 1>
 826 (?im)error.+?union.+?value.+?expected
 827 <END_RESULT>
 828 <RESULT IF_PASS COUNT 1>
 829 (?is)\berror:
 830 <END_RESULT>
 831 <END_TC>
 832
 833 :exmp.
 834
 835 .*---------------------------------------------------------------------*
 836 :h3.Value with wrong type in record - template1
 837 .*---------------------------------------------------------------------*
 838 :xmp tab=0.
 839
 840 <TC -  Value with wrong type in record - template1>
 841
 842 <COMPILE>
 843 <VERDICT_LEAF PASS>
 844 <MODULE TTCN Temp Temp.ttcn>
 845 module Temp {
 846
 847
 848 type integer iType (1, 2, 3, 4)
 849 type record bTest  {iType i}
 850
 851 template bTest con := {true}
 852
 853 }
 854 <END_MODULE>
 855 <RESULT IF_PASS COUNT 1>
 856 (?im)error.+?integer.+?value.+?expected
 857 <END_RESULT>
 858 <RESULT IF_PASS COUNT 1>
 859 (?is)\berror:
 860 <END_RESULT>
 861 <END_TC>
 862
 863 :exmp.
 864
 865 .*---------------------------------------------------------------------*
 866 :h3.Value with wrong type in record - template2
 867 .*---------------------------------------------------------------------*
 868 :xmp tab=0.
 869
 870 <TC -  Value with wrong type in record - template2>
 871
 872 <COMPILE>
 873 <VERDICT_LEAF PASS>
 874 <MODULE TTCN Temp Temp.ttcn>
 875 module Temp {
 876
 877
 878 type integer iType (1, 2, 3, 4)
 879 type record bTest  {iType i}
 880
 881 template bTest con := {str2int("6")}
 882
 883 }
 884 <END_MODULE>
 885 <RESULT IF_PASS COUNT 1>
 886 (?im)error.+?not.+?valid.+?value.+?for.+?subtype
 887 <END_RESULT>
 888 <RESULT IF_PASS COUNT 1>
 889 (?is)\berror:
 890 <END_RESULT>
 891 <END_TC>
 892
 893 :exmp.
 894
 895 .*---------------------------------------------------------------------*
 896 :h3.Wrong value in contained record, bitstring - template
 897 .*---------------------------------------------------------------------*
 898 :xmp tab=0.
 899
 900 <TC -  Wrong value in contained record, bitstring - template>
 901
 902 <COMPILE>
 903 <VERDICT_LEAF PASS>
 904 <MODULE TTCN Temp Temp.ttcn>
 905 module Temp {
 906
 907
 908 type record aTest  {integer i, bTest r}
 909 type record bTest  {integer i , bitstring b}
 910
 911 template aTest con := {1, {2, 1}}
 912
 913
 914 }
 915 <END_MODULE>
 916 <RESULT IF_PASS COUNT 1>
 917 (?im)error.+?bitstring.+?value.+?expected
 918 <END_RESULT>
 919 <RESULT IF_PASS COUNT 1>
 920 (?is)\berror:
 921 <END_RESULT>
 922 <END_TC>
 923
 924 :exmp.
 925
 926 .*---------------------------------------------------------------------*
 927 :h3.Wrong value in contained record, hexstring - template
 928 .*---------------------------------------------------------------------*
 929 :xmp tab=0.
 930
 931 <TC -  Wrong value in contained record, hexstring - template>
 932
 933 <COMPILE>
 934 <VERDICT_LEAF PASS>
 935 <MODULE TTCN Temp Temp.ttcn>
 936 module Temp {
 937
 938
 939 type record aTest  {integer i, bTest r}
 940 type record bTest  {integer i , hexstring h}
 941
 942 template aTest con := {1, {2, 1}}
 943
 944
 945 }
 946 <END_MODULE>
 947 <RESULT IF_PASS COUNT 1>
 948 (?im)error.+?hexstring.+?value.+?expected
 949 <END_RESULT>
 950 <RESULT IF_PASS COUNT 1>
 951 (?is)\berror:
 952 <END_RESULT>
 953 <END_TC>
 954
 955 :exmp.
 956
 957 .*---------------------------------------------------------------------*
 958 :h3.Wrong value in contained record, octetstring - template
 959 .*---------------------------------------------------------------------*
 960 :xmp tab=0.
 961
 962 <TC -  Wrong value in contained record, octetstring - template>
 963
 964 <COMPILE>
 965 <VERDICT_LEAF PASS>
 966 <MODULE TTCN Temp Temp.ttcn>
 967 module Temp {
 968
 969
 970 type record aTest  {integer i, bTest r}
 971 type record bTest  {integer i , octetstring o}
 972
 973 template aTest con := {1, {2, 1}}
 974
 975 }
 976 <END_MODULE>
 977 <RESULT IF_PASS COUNT 1>
 978 (?im)error.+?octetstring.+?value.+?expected
 979 <END_RESULT>
 980 <RESULT IF_PASS COUNT 1>
 981 (?is)\berror:
 982 <END_RESULT>
 983 <END_TC>
 984
 985 :exmp.
 986
 987 .*---------------------------------------------------------------------*
 988 :h3.Wrong value in contained record, boolean - template
 989 .*---------------------------------------------------------------------*
 990 :xmp tab=0.
 991
 992 <TC -  Wrong value in contained record, boolean - template>
 993
 994 <COMPILE>
 995 <VERDICT_LEAF PASS>
 996 <MODULE TTCN Temp Temp.ttcn>
 997 module Temp {
 998
 999
1000 type record aTest  {integer i, bTest r}
1001 type record bTest  {integer i , boolean b}
1002
1003 template aTest con := {1, {2, 1}}
1004
1005 }
1006 <END_MODULE>
1007 <RESULT IF_PASS COUNT 1>
1008 (?im)error.+?boolean.+?value.+?expected
1009 <END_RESULT>
1010 <RESULT IF_PASS COUNT 1>
1011 (?is)\berror:
1012 <END_RESULT>
1013 <END_TC>
1014
1015 :exmp.
1016
1017 .*---------------------------------------------------------------------*
1018 :h2.Wrong order in value list notation (number)
1019 .*---------------------------------------------------------------------*
1020
1021 .*---------------------------------------------------------------------*
1022 :h3.Extra value at the end of value list in record - constant
1023 .*---------------------------------------------------------------------*
1024 :xmp tab=0.
1025
1026 <TC -  Extra value at the end of value list in record - constant>
1027
1028 <COMPILE>
1029 <VERDICT_LEAF PASS>
1030 <MODULE TTCN Temp Temp.ttcn>
1031 module Temp {
1032
1033
1034 type record aTest  {integer i, charstring c, bTest r}
1035 type record bTest  {integer i , charstring c}
1036 const aTest con := {2, "aTest", {1, "bTest"}, 1}
1037
1038
1039 }
1040 <END_MODULE>
1041 <RESULT IF_PASS COUNT 1>
1042 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1043 <END_RESULT>
1044 <RESULT IF_PASS COUNT 1>
1045 (?is)\berror:
1046 <END_RESULT>
1047 <END_TC>
1048
1049 :exmp.
1050
1051 .*---------------------------------------------------------------------*
1052 :h3.Extra value at the beginning of value list in record - constant
1053 .*---------------------------------------------------------------------*
1054 :xmp tab=0.
1055
1056 <TC -  Extra value at the beginning of value list in record - constant>
1057
1058 <COMPILE>
1059 <VERDICT_LEAF PASS>
1060 <MODULE TTCN Temp Temp.ttcn>
1061 module Temp {
1062
1063
1064 type record aTest  {integer i, charstring c, bTest r}
1065 type record bTest  {integer i , charstring c}
1066 const aTest con := {1, 2, "aTest", {3, "bTest"}}
1067
1068
1069 }
1070 <END_MODULE>
1071 <RESULT IF_PASS COUNT 1>
1072 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1073 <END_RESULT>
1074 <RESULT IF_PASS COUNT 1>
1075 (?im)error.+?character.+?string.+?value.+?expected
1076 <END_RESULT>
1077 <RESULT IF_PASS COUNT 1>
1078 (?im)error.+?record.+?value.+?expected
1079 <END_RESULT>
1080 <RESULT IF_PASS COUNT 3>
1081 (?is)\berror:
1082 <END_RESULT>
1083 <END_TC>
1084
1085 :exmp.
1086
1087 .*---------------------------------------------------------------------*
1088 :h3.Extra value in contained record - constant
1089 .*---------------------------------------------------------------------*
1090 :xmp tab=0.
1091
1092 <TC -  Extra value in contained record - constant>
1093
1094 <COMPILE>
1095 <VERDICT_LEAF PASS>
1096 <MODULE TTCN Temp Temp.ttcn>
1097 module Temp {
1098
1099
1100 type record aTest  {integer i, charstring c, bTest r}
1101 type record bTest  {integer i , charstring c}
1102 const aTest con := {2, "aTest", {3, "bTest", '0010010'B}}
1103
1104
1105 }
1106 <END_MODULE>
1107 <RESULT IF_PASS COUNT 1>
1108 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1109 <END_RESULT>
1110 <RESULT IF_PASS COUNT 1>
1111 (?is)\berror:
1112 <END_RESULT>
1113 <END_TC>
1114
1115 :exmp.
1116
1117 .*---------------------------------------------------------------------*
1118 :h3.Extra value in record defined empty - constant
1119 .*---------------------------------------------------------------------*
1120 :xmp tab=0.
1121
1122 <TC -  Extra value in record defined empty - constant>
1123
1124 <COMPILE>
1125 <VERDICT_LEAF PASS>
1126 <MODULE TTCN Temp Temp.ttcn>
1127 module Temp {
1128
1129
1130 type record aTest  {}
1131 const aTest con := {1}
1132
1133
1134 }
1135 <END_MODULE>
1136 <RESULT IF_PASS COUNT 1>
1137 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1138 <END_RESULT>
1139 <RESULT IF_PASS COUNT 1>
1140 (?is)\berror:
1141 <END_RESULT>
1142 <END_TC>
1143
1144 :exmp.
1145
1146 .*---------------------------------------------------------------------*
1147 :h3.Extra value in contained record defined empty - constant
1148 .*---------------------------------------------------------------------*
1149 :xmp tab=0.
1150
1151 <TC -  Extra value in contained record defined empty - constant>
1152
1153 <COMPILE>
1154 <VERDICT_LEAF PASS>
1155 <MODULE TTCN Temp Temp.ttcn>
1156 module Temp {
1157
1158
1159 type record aTest {integer i, bTest b}
1160 type record bTest  {}
1161 const aTest con := {2, {2}}
1162
1163
1164 }
1165 <END_MODULE>
1166 <RESULT IF_PASS COUNT 1>
1167 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1168 <END_RESULT>
1169 <RESULT IF_PASS COUNT 1>
1170 (?is)\berror:
1171 <END_RESULT>
1172 <END_TC>
1173
1174 :exmp.
1175
1176 .*---------------------------------------------------------------------*
1177 :h3.Missing value in contained record - constant
1178 .*---------------------------------------------------------------------*
1179 :xmp tab=0.
1180
1181 <TC -  Missing value in contained record - constant>
1182
1183 <COMPILE>
1184 <VERDICT_LEAF PASS>
1185 <MODULE TTCN Temp Temp.ttcn>
1186 module Temp {
1187
1188
1189 type record aTest  {integer i, charstring c, bTest r}
1190 type record bTest  {integer i , charstring c optional}
1191 const aTest con := {2, "aTest", {3}}
1192
1193
1194 }
1195 <END_MODULE>
1196 <RESULT IF_PASS NEGATIVE>
1197 (?is)\berror:
1198 <END_RESULT>
1199 <END_TC>
1200
1201 :exmp.
1202
1203 .*---------------------------------------------------------------------*
1204 :h3.Missing value in record - constant
1205 .*---------------------------------------------------------------------*
1206 :xmp tab=0.
1207
1208 <TC -  Missing value in record - constant>
1209
1210 <COMPILE>
1211 <VERDICT_LEAF PASS>
1212 <MODULE TTCN Temp Temp.ttcn>
1213 module Temp {
1214
1215
1216 type record aTest  {integer i, charstring c, bTest r optional}
1217 type record bTest  {integer i , charstring c optional}
1218 const aTest con := {2, "aTest"}
1219
1220
1221 }
1222 <END_MODULE>
1223 <RESULT IF_PASS NEGATIVE>
1224 (?is)\berror:
1225 <END_RESULT>
1226 <END_TC>
1227
1228 :exmp.
1229
1230 .*---------------------------------------------------------------------*
1231 :h3.Extra value in record of with length restriction - constant1
1232 .*---------------------------------------------------------------------*
1233 :xmp tab=0.
1234
1235 <TC -  Extra value in record of with length restriction - constant1>
1236
1237 <COMPILE>
1238 <VERDICT_LEAF PASS>
1239 <MODULE TTCN Temp Temp.ttcn>
1240 module Temp {
1241
1242
1243 type record aTest  {integer i, bTest r optional}
1244 type record length (0) of integer bTest;
1245 const aTest con := {1, {1}}
1246
1247
1248 }
1249 <END_MODULE>
1250 <RESULT IF_PASS COUNT 1>
1251 (?im)error: \{ 1 \} is not a valid value for type `\@Temp.bTest' which has subtype length\(0\)
1252 <END_RESULT>
1253 <RESULT IF_PASS COUNT 1>
1254 (?is)\berror:
1255 <END_RESULT>
1256 <END_TC>
1257
1258 :exmp.
1259
1260 .*---------------------------------------------------------------------*
1261 :h3.Extra value in record of with length restriction - constant2
1262 .*---------------------------------------------------------------------*
1263 :xmp tab=0.
1264
1265 <TC -  Extra value in record of with length restriction - constant2>
1266
1267 <COMPILE>
1268 <VERDICT_LEAF PASS>
1269 <MODULE TTCN Temp Temp.ttcn>
1270 module Temp {
1271
1272
1273 type record aTest  {integer i, bTest r optional}
1274 type record length (2) of integer bTest;
1275 const aTest con := {1, {1, 1, 1}}
1276
1277
1278 }
1279 <END_MODULE>
1280 <RESULT IF_PASS COUNT 1>
1281 (?im)error: \{ 1, 1, 1 \} is not a valid value for type `\@Temp.bTest' which has subtype length\(2\)
1282 <END_RESULT>
1283 <RESULT IF_PASS COUNT 1>
1284 (?is)\berror:
1285 <END_RESULT>
1286 <END_TC>
1287
1288 :exmp.
1289
1290 .*---------------------------------------------------------------------*
1291 :h3.Missing value in record of with length restriction - constant
1292 .*---------------------------------------------------------------------*
1293 :xmp tab=0.
1294
1295 <TC -  Missing value in record of with length restriction - constant>
1296
1297 <COMPILE>
1298 <VERDICT_LEAF PASS>
1299 <MODULE TTCN Temp Temp.ttcn>
1300 module Temp {
1301
1302
1303 type record aTest  {integer i, bTest r optional}
1304 type record length (2) of integer bTest;
1305 const aTest con := {1, {1}}
1306
1307
1308 }
1309 <END_MODULE>
1310 <RESULT IF_PASS COUNT 1>
1311 (?im)error: \{ 1 \} is not a valid value for type `\@Temp.bTest' which has subtype length\(2\)
1312 <END_RESULT>
1313 <RESULT IF_PASS COUNT 1>
1314 (?is)\berror:
1315 <END_RESULT>
1316 <END_TC>
1317
1318 :exmp.
1319
1320 .*---------------------------------------------------------------------*
1321 :h3.Extra value in set of with length restriction - constant
1322 .*---------------------------------------------------------------------*
1323 :xmp tab=0.
1324
1325 <TC -  Extra value in set of with length restriction - constant>
1326
1327 <COMPILE>
1328 <VERDICT_LEAF PASS>
1329 <MODULE TTCN Temp Temp.ttcn>
1330 module Temp {
1331
1332
1333 type record aTest  {integer i, bTest s optional}
1334 type set length (2) of integer bTest;
1335 const aTest con := {1, {1,1,1}}
1336
1337
1338 }
1339 <END_MODULE>
1340 <RESULT IF_PASS COUNT 1>
1341 (?im)error: \{ 1, 1, 1 \} is not a valid value for type `\@Temp.bTest' which has subtype length\(2\)
1342 <END_RESULT>
1343 <RESULT IF_PASS COUNT 1>
1344 (?is)\berror:
1345 <END_RESULT>
1346 <END_TC>
1347
1348 :exmp.
1349
1350 .*---------------------------------------------------------------------*
1351 :h3.Missing value in set of with length restriction - constant
1352 .*---------------------------------------------------------------------*
1353 :xmp tab=0.
1354
1355 <TC -  Missing value in set of with length restriction - constant>
1356
1357 <COMPILE>
1358 <VERDICT_LEAF PASS>
1359 <MODULE TTCN Temp Temp.ttcn>
1360 module Temp {
1361
1362
1363 type record aTest  {integer i, bTest s optional}
1364 type set length (2) of integer bTest;
1365 const aTest con := {1, {1}}
1366
1367
1368 }
1369 <END_MODULE>
1370 <RESULT IF_PASS COUNT 1>
1371 (?im)error: \{ 1 \} is not a valid value for type `\@Temp.bTest' which has subtype length\(2\)
1372 <END_RESULT>
1373 <RESULT IF_PASS COUNT 1>
1374 (?is)\berror:
1375 <END_RESULT>
1376 <END_TC>
1377
1378 :exmp.
1379
1380 .*---------------------------------------------------------------------*
1381 :h3.Extra values in set of with length restriction - constant
1382 .*---------------------------------------------------------------------*
1383 :xmp tab=0.
1384
1385 <TC -  Extra values in set of with length restriction - constant>
1386
1387 <COMPILE>
1388 <VERDICT_LEAF PASS>
1389 <MODULE TTCN Temp Temp.ttcn>
1390 module Temp {
1391
1392
1393 type set of bTest aTest
1394 type set length (0) of integer bTest;
1395 const aTest con := {{1}, {1,1}}
1396
1397
1398 }
1399 <END_MODULE>
1400 <RESULT IF_PASS COUNT 1>
1401 (?im)error: \{ 1 \} is not a valid value for type `\@Temp.bTest' which has subtype length\(0\)
1402 <END_RESULT>
1403 <RESULT IF_PASS COUNT 1>
1404 (?im)error: \{ 1, 1 \} is not a valid value for type `\@Temp.bTest' which has subtype length\(0\)
1405 <END_RESULT>
1406 <RESULT IF_PASS COUNT 2>
1407 (?is)\berror:
1408 <END_RESULT>
1409 <END_TC>
1410
1411 :exmp.
1412
1413 .*---------------------------------------------------------------------*
1414 :h3.Missing values in set of with length restriction - constant
1415 .*---------------------------------------------------------------------*
1416 :xmp tab=0.
1417
1418 <TC -  Missing values in set of with length restriction - constant>
1419
1420 <COMPILE>
1421 <VERDICT_LEAF PASS>
1422 <MODULE TTCN Temp Temp.ttcn>
1423 module Temp {
1424
1425
1426 type set of bTest aTest
1427 type set length (3) of integer bTest;
1428 const aTest con := {{}, {1}}
1429
1430
1431 }
1432 <END_MODULE>
1433 <RESULT IF_PASS COUNT 1>
1434 (?im)error: \{  \} is not a valid value for type `\@Temp.bTest' which has subtype length\(3\)
1435 <END_RESULT>
1436 <RESULT IF_PASS COUNT 1>
1437 (?im)error: \{ 1 \} is not a valid value for type `\@Temp.bTest' which has subtype length\(3\)
1438 <END_RESULT>
1439 <RESULT IF_PASS COUNT 2>
1440 (?is)\berror:
1441 <END_RESULT>
1442 <END_TC>
1443
1444 :exmp.
1445
1446 .*---------------------------------------------------------------------*
1447 :h3.Extra value in record inside union - constant
1448 .*---------------------------------------------------------------------*
1449 :xmp tab=0.
1450
1451 <TC -  Extra value in record inside union - constant>
1452
1453 <COMPILE>
1454 <VERDICT_LEAF PASS>
1455 <MODULE TTCN Temp Temp.ttcn>
1456 module Temp {
1457
1458
1459 type record bTest  {}
1460 type union cTest {integer i, bTest b}
1461 const cTest con := {b := {1, 2}}
1462
1463
1464 }
1465 <END_MODULE>
1466 <RESULT IF_PASS COUNT 1>
1467 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1468 <END_RESULT>
1469 <RESULT IF_PASS COUNT 1>
1470 (?is)\berror:
1471 <END_RESULT>
1472 <END_TC>
1473
1474 :exmp.
1475
1476 .*---------------------------------------------------------------------*
1477 :h3.Missing value in contained record inside union - constant
1478 .*---------------------------------------------------------------------*
1479 :xmp tab=0.
1480
1481 <TC -  Missing value in contained record inside union - constant>
1482
1483 <COMPILE>
1484 <VERDICT_LEAF PASS>
1485 <MODULE TTCN Temp Temp.ttcn>
1486 module Temp {
1487
1488
1489 type record aTest  {integer i, bTest r}
1490 type record bTest  {integer i , integer ii}
1491 type union cTest {aTest a, integer i}
1492 const cTest con := {a := {1, {1}}}
1493
1494
1495 }
1496 <END_MODULE>
1497 <RESULT IF_PASS NEGATIVE>
1498 (?is)\berror:
1499 <END_RESULT>
1500 <END_TC>
1501
1502 :exmp.
1503
1504 .*---------------------------------------------------------------------*
1505 :h3.Extra value at the end of value list in record - template
1506 .*---------------------------------------------------------------------*
1507 :xmp tab=0.
1508
1509 <TC -  Extra value at the end of value list in record - template>
1510
1511 <COMPILE>
1512 <VERDICT_LEAF PASS>
1513 <MODULE TTCN Temp Temp.ttcn>
1514 module Temp {
1515
1516
1517 type record aTest  {integer i, charstring c, bTest r}
1518 type record bTest  {integer i , charstring c}
1519 template aTest con := {2, "aTest", {1, "bTest"}, 1}
1520
1521
1522 }
1523 <END_MODULE>
1524 <RESULT IF_PASS COUNT 1>
1525 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1526 <END_RESULT>
1527 <RESULT IF_PASS COUNT 1>
1528 (?is)\berror:
1529 <END_RESULT>
1530 <END_TC>
1531
1532 :exmp.
1533
1534 .*---------------------------------------------------------------------*
1535 :h3.Extra value at the beginning of value list in record - template
1536 .*---------------------------------------------------------------------*
1537 :xmp tab=0.
1538
1539 <TC -  Extra value at the beginning of value list in record - template>
1540
1541 <COMPILE>
1542 <VERDICT_LEAF PASS>
1543 <MODULE TTCN Temp Temp.ttcn>
1544 module Temp {
1545
1546
1547 type record aTest  {integer i, charstring c, bTest r}
1548 type record bTest  {integer i , charstring c}
1549 template aTest con := {1, 2, "aTest", {3, "bTest"}}
1550
1551
1552 }
1553 <END_MODULE>
1554 <RESULT IF_PASS COUNT 1>
1555 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1556 <END_RESULT>
1557 <RESULT IF_PASS COUNT 1>
1558 (?im)error.+?character.+?string.+?value.+?expected
1559 <END_RESULT>
1560 <RESULT IF_PASS COUNT 1>
1561 (?im)error.+?Record.+?value.+?expected
1562 <END_RESULT>
1563 <RESULT IF_PASS COUNT 3>
1564 (?is)\berror:
1565 <END_RESULT>
1566 <END_TC>
1567
1568 :exmp.
1569
1570 .*---------------------------------------------------------------------*
1571 :h3.Extra value in contained record - template
1572 .*---------------------------------------------------------------------*
1573 :xmp tab=0.
1574
1575 <TC -  Extra value in contained record - template>
1576
1577 <COMPILE>
1578 <VERDICT_LEAF PASS>
1579 <MODULE TTCN Temp Temp.ttcn>
1580 module Temp {
1581
1582
1583 type record aTest  {integer i, charstring c, bTest r}
1584 type record bTest  {integer i , charstring c}
1585 template aTest con := {2, "aTest", {3, "bTest", '0010010'B}}
1586
1587
1588 }
1589 <END_MODULE>
1590 <RESULT IF_PASS COUNT 1>
1591 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1592 <END_RESULT>
1593 <RESULT IF_PASS COUNT 1>
1594 (?is)\berror:
1595 <END_RESULT>
1596 <END_TC>
1597
1598 :exmp.
1599
1600 .*---------------------------------------------------------------------*
1601 :h3.Extra value in record defined empty - template
1602 .*---------------------------------------------------------------------*
1603 :xmp tab=0.
1604
1605 <TC -  Extra value in record defined empty - template>
1606
1607 <COMPILE>
1608 <VERDICT_LEAF PASS>
1609 <MODULE TTCN Temp Temp.ttcn>
1610 module Temp {
1611
1612
1613 type record aTest  {}
1614 template aTest con := {1}
1615
1616
1617 }
1618 <END_MODULE>
1619 <RESULT IF_PASS COUNT 1>
1620 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1621 <END_RESULT>
1622 <RESULT IF_PASS COUNT 1>
1623 (?is)\berror:
1624 <END_RESULT>
1625 <END_TC>
1626
1627 :exmp.
1628
1629 .*---------------------------------------------------------------------*
1630 :h3.Extra value in contained record defined empty - template
1631 .*---------------------------------------------------------------------*
1632 :xmp tab=0.
1633
1634 <TC -  Extra value in contained record defined empty - template>
1635
1636 <COMPILE>
1637 <VERDICT_LEAF PASS>
1638 <MODULE TTCN Temp Temp.ttcn>
1639 module Temp {
1640
1641
1642 type record aTest {integer i, bTest b}
1643 type record bTest  {}
1644 template aTest con := {2, {2}}
1645
1646
1647 }
1648 <END_MODULE>
1649 <RESULT IF_PASS COUNT 1>
1650 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1651 <END_RESULT>
1652 <RESULT IF_PASS COUNT 1>
1653 (?is)\berror:
1654 <END_RESULT>
1655 <END_TC>
1656
1657 :exmp.
1658
1659 .*---------------------------------------------------------------------*
1660 :h3.Missing value in contained record - template
1661 .*---------------------------------------------------------------------*
1662 :xmp tab=0.
1663
1664 <TC -  Missing value in contained record - template>
1665
1666 <COMPILE>
1667 <VERDICT_LEAF PASS>
1668 <MODULE TTCN Temp Temp.ttcn>
1669 module Temp {
1670
1671
1672 type record aTest  {integer i, charstring c, bTest r}
1673 type record bTest  {integer i , charstring c optional}
1674 template aTest con := {2, "aTest", {3}}
1675
1676
1677 }
1678 <END_MODULE>
1679 <RESULT IF_PASS NEGATIVE>
1680 (?im)error.+?Too.+?few.+?elements.+?in.+?value.+?list.+?notation
1681 <END_RESULT>
1682 <RESULT IF_PASS NEGATIVE>
1683 (?is)\berror:
1684 <END_RESULT>
1685 <END_TC>
1686
1687 :exmp.
1688
1689 .*---------------------------------------------------------------------*
1690 :h3.Missing value in record - template
1691 .*---------------------------------------------------------------------*
1692 :xmp tab=0.
1693
1694 <TC -  Missing value in record - template>
1695
1696 <COMPILE>
1697 <VERDICT_LEAF PASS>
1698 <MODULE TTCN Temp Temp.ttcn>
1699 module Temp {
1700
1701
1702 type record aTest  {integer i, charstring c, bTest r optional}
1703 type record bTest  {integer i , charstring c optional}
1704 template aTest con := {2, "aTest"}
1705
1706
1707 }
1708 <END_MODULE>
1709 <RESULT IF_PASS NEGATIVE>
1710 (?im)error.+?Too.+?few.+?elements.+?in.+?value.+?list.+?notation
1711 <END_RESULT>
1712 <RESULT IF_PASS NEGATIVE>
1713 (?is)\berror:
1714 <END_RESULT>
1715 <END_TC>
1716
1717 :exmp.
1718
1719 .*---------------------------------------------------------------------*
1720 :h3.Extra value in record of with length restriction - template1
1721 .*---------------------------------------------------------------------*
1722 :xmp tab=0.
1723
1724 <TC -  Extra value in record of with length restriction - template1>
1725
1726 <COMPILE>
1727 <VERDICT_LEAF PASS>
1728 <MODULE TTCN Temp Temp.ttcn>
1729 module Temp {
1730
1731
1732 type record aTest  {integer i, bTest r optional}
1733 type record length (0) of integer bTest;
1734 template aTest con := {1, {1}}
1735
1736
1737 }
1738 <END_MODULE>
1739 <RESULT IF_PASS COUNT 1>
1740 (?im)\berror\b.+?There.+?must.+?not.+?be.+?than.+?0.+?elements
1741 <END_RESULT>
1742 <RESULT IF_PASS COUNT 1>
1743 (?is)\berror:
1744 <END_RESULT>
1745 <END_TC>
1746
1747 :exmp.
1748
1749 .*---------------------------------------------------------------------*
1750 :h3.Extra value in record of with length restriction - template2
1751 .*---------------------------------------------------------------------*
1752 :xmp tab=0.
1753
1754 <TC -  Extra value in record of with length restriction - template2>
1755
1756 <COMPILE>
1757 <VERDICT_LEAF PASS>
1758 <MODULE TTCN Temp Temp.ttcn>
1759 module Temp {
1760
1761
1762 type record aTest  {integer i, bTest r optional}
1763 type record length (2) of integer bTest;
1764 template aTest con := {1, {1, 1, 1}}
1765
1766
1767 }
1768 <END_MODULE>
1769 <RESULT IF_PASS COUNT 1>
1770 (?im)\berror\b.+?There.+?must.+?not.+?be.+?than.+?2.+?elements
1771 <END_RESULT>
1772 <RESULT IF_PASS COUNT 1>
1773 (?is)\berror:
1774 <END_RESULT>
1775 <END_TC>
1776
1777 :exmp.
1778
1779 .*---------------------------------------------------------------------*
1780 :h3.Missing value in record of with length restriction - template
1781 .*---------------------------------------------------------------------*
1782 :xmp tab=0.
1783
1784 <TC -  Missing value in record of with length restriction - template>
1785
1786 <COMPILE>
1787 <VERDICT_LEAF PASS>
1788 <MODULE TTCN Temp Temp.ttcn>
1789 module Temp {
1790
1791
1792 type record aTest  {integer i, bTest r optional}
1793 type record length (2) of integer bTest;
1794 template aTest con := {1, {1}}
1795
1796
1797 }
1798 <END_MODULE>
1799 <RESULT IF_PASS COUNT 1>
1800 (?im)\berror\b.+?At.+?least.+?2.+?elements.+?must.+?be.+?present
1801 <END_RESULT>
1802 <RESULT IF_PASS COUNT 1>
1803 (?is)\berror:
1804 <END_RESULT>
1805 <END_TC>
1806
1807 :exmp.
1808
1809 .*---------------------------------------------------------------------*
1810 :h3.Extra value in set of with length restriction - template
1811 .*---------------------------------------------------------------------*
1812 :xmp tab=0.
1813
1814 <TC -  Extra value in set of with length restriction - template>
1815
1816 <COMPILE>
1817 <VERDICT_LEAF PASS>
1818 <MODULE TTCN Temp Temp.ttcn>
1819 module Temp {
1820
1821
1822 type record aTest  {integer i, bTest s optional}
1823 type set length (2) of integer bTest;
1824 template aTest con := {1, {1,1,1}}
1825
1826
1827 }
1828 <END_MODULE>
1829 <RESULT IF_PASS COUNT 1>
1830 (?im)\berror\b.+?There.+?must.+?not.+?be.+?than.+?2.+?elements
1831 <END_RESULT>
1832 <RESULT IF_PASS COUNT 1>
1833 (?is)\berror:
1834 <END_RESULT>
1835 <END_TC>
1836
1837 :exmp.
1838
1839 .*---------------------------------------------------------------------*
1840 :h3.Missing value in set of with length restriction - template
1841 .*---------------------------------------------------------------------*
1842 :xmp tab=0.
1843
1844 <TC -  Missing value in set of with length restriction - template>
1845
1846 <COMPILE>
1847 <VERDICT_LEAF PASS>
1848 <MODULE TTCN Temp Temp.ttcn>
1849 module Temp {
1850
1851
1852 type record aTest  {integer i, bTest s optional}
1853 type set length (2) of integer bTest;
1854 template aTest con := {1, {1}}
1855
1856
1857 }
1858 <END_MODULE>
1859 <RESULT IF_PASS COUNT 1>
1860 (?im)\berror\b.+?At.+?least.+?2.+?elements.+?must.+?be.+?present
1861 <END_RESULT>
1862 <RESULT IF_PASS COUNT 1>
1863 (?is)\berror:
1864 <END_RESULT>
1865 <END_TC>
1866
1867 :exmp.
1868
1869 .*---------------------------------------------------------------------*
1870 :h3.Extra values in set of with length restriction - template
1871 .*---------------------------------------------------------------------*
1872 :xmp tab=0.
1873
1874 <TC -  Extra values in set of with length restriction - template>
1875
1876 <COMPILE>
1877 <VERDICT_LEAF PASS>
1878 <MODULE TTCN Temp Temp.ttcn>
1879 module Temp {
1880
1881
1882 type set of bTest aTest
1883 type set length (0) of integer bTest;
1884 template aTest con := {{1}, {1,1}}
1885
1886
1887 }
1888 <END_MODULE>
1889 <RESULT IF_PASS COUNT 2>
1890 (?im)\berror\b.+?There.+?must.+?not.+?be.+?than.+?0.+?elements
1891 <END_RESULT>
1892 <RESULT IF_PASS COUNT 2>
1893 (?is)\berror:
1894 <END_RESULT>
1895 <END_TC>
1896
1897 :exmp.
1898
1899 .*---------------------------------------------------------------------*
1900 :h3.Missing values in set of with length restriction - template
1901 .*---------------------------------------------------------------------*
1902 :xmp tab=0.
1903
1904 <TC -  Missing values in set of with length restriction - template>
1905
1906 <COMPILE>
1907 <VERDICT_LEAF PASS>
1908 <MODULE TTCN Temp Temp.ttcn>
1909 module Temp {
1910
1911
1912 type set of bTest aTest
1913 type set length (3) of integer bTest;
1914 template aTest con := {{}, {1}}
1915
1916
1917 }
1918 <END_MODULE>
1919 <RESULT IF_PASS COUNT 2>
1920 (?im)\berror\b.+?At.+?least.+?3.+?elements.+?must.+?be.+?present
1921 <END_RESULT>
1922 <RESULT IF_PASS COUNT 2>
1923 (?is)\berror:
1924 <END_RESULT>
1925 <END_TC>
1926
1927 :exmp.
1928
1929 .*---------------------------------------------------------------------*
1930 :h3.Extra value in record inside union - template
1931 .*---------------------------------------------------------------------*
1932 :xmp tab=0.
1933
1934 <TC -  Extra value in record inside union - template>
1935
1936 <COMPILE>
1937 <VERDICT_LEAF PASS>
1938 <MODULE TTCN Temp Temp.ttcn>
1939 module Temp {
1940
1941
1942 type record bTest  {}
1943 type union cTest {integer i, bTest b}
1944 template cTest con := {b := {1, 2}}
1945
1946
1947 }
1948 <END_MODULE>
1949 <RESULT IF_PASS COUNT 1>
1950 (?im)error.+?Too.+?many.+?elements.+?in.+?value.+?list.+?notation
1951 <END_RESULT>
1952 <RESULT IF_PASS COUNT 1>
1953 (?is)\berror:
1954 <END_RESULT>
1955 <END_TC>
1956
1957 :exmp.
1958
1959 .*---------------------------------------------------------------------*
1960 :h3.Missing value in contained record inside union - template
1961 .*---------------------------------------------------------------------*
1962 :xmp tab=0.
1963
1964 <TC -  Missing value in contained record inside union - template>
1965
1966 <COMPILE>
1967 <VERDICT_LEAF PASS>
1968 <MODULE TTCN Temp Temp.ttcn>
1969 module Temp {
1970
1971
1972 type record aTest  {integer i, bTest r}
1973 type record bTest  {integer i , integer ii}
1974 type union cTest {aTest a, integer i}
1975 template cTest con := {a := {1, {1}}}
1976
1977
1978 }
1979 <END_MODULE>
1980 <RESULT IF_PASS NEGATIVE>
1981 (?im)error.+?Too.+?few.+?elements.+?in.+?value.+?list.+?notation
1982 <END_RESULT>
1983 <RESULT IF_PASS NEGATIVE>
1984 (?is)\berror:
1985 <END_RESULT>
1986 <END_TC>
1987
1988 :exmp.
1989
1990 .*---------------------------------------------------------------------*
1991 :h2.Wrong order in assignment notation
1992 .*---------------------------------------------------------------------*
1993
1994 .*---------------------------------------------------------------------*
1995 :h3.Fields of record in wrong order - constant
1996 .*---------------------------------------------------------------------*
1997 :xmp tab=0.
1998
1999 <TC -  Fields of record in wrong order - constant>
2000
2001 <COMPILE>
2002 <VERDICT_LEAF PASS>
2003 <MODULE TTCN Temp Temp.ttcn>
2004 module Temp {
2005
2006
2007 type record aTest  {integer i, charstring c}
2008         const aTest con :=  {c := "aTest", i := 1}
2009
2010
2011 }
2012 <END_MODULE>
2013 <RESULT IF_PASS COUNT 1>
2014 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?record.+?value
2015 <END_RESULT>
2016 <RESULT IF_PASS COUNT 1>
2017 (?is)\berror:
2018 <END_RESULT>
2019 <END_TC>
2020
2021 :exmp.
2022
2023 .*---------------------------------------------------------------------*
2024 :h3.Fields of contained record in wrong order - constant
2025 .*---------------------------------------------------------------------*
2026 :xmp tab=0.
2027
2028 <TC -  Fields of contained record in wrong order - constant>
2029
2030 <COMPILE>
2031 <VERDICT_LEAF PASS>
2032 <MODULE TTCN Temp Temp.ttcn>
2033 module Temp {
2034
2035
2036 type record aTest  {integer i, bTest r}
2037 type record bTest  {integer i , charstring c}
2038         const aTest con :=  {i := 1, r := {c := "bTest",i := 2}}
2039
2040
2041 }
2042 <END_MODULE>
2043 <RESULT IF_PASS COUNT 1>
2044 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?record.+?value
2045 <END_RESULT>
2046 <RESULT IF_PASS COUNT 1>
2047 (?is)\berror:
2048 <END_RESULT>
2049 <END_TC>
2050
2051 :exmp.
2052
2053 .*---------------------------------------------------------------------*
2054 :h3.Fields in record inside union in wrong order - constant
2055 .*---------------------------------------------------------------------*
2056 :xmp tab=0.
2057
2058 <TC -  Fields in record inside union in wrong order - constant>
2059
2060 <COMPILE>
2061 <VERDICT_LEAF PASS>
2062 <MODULE TTCN Temp Temp.ttcn>
2063 module Temp {
2064
2065
2066 type record aTest  {integer i, charstring c, bTest r}
2067 type record bTest  {integer i , charstring c optional}
2068 type union cTest {aTest a, bTest b}
2069 const cTest con := {b := {c := "bTest", i := 1}}
2070
2071
2072 }
2073 <END_MODULE>
2074 <RESULT IF_PASS COUNT 1>
2075 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?record.+?value
2076 <END_RESULT>
2077 <RESULT IF_PASS COUNT 1>
2078 (?is)\berror:
2079 <END_RESULT>
2080 <END_TC>
2081
2082 :exmp.
2083
2084 .*---------------------------------------------------------------------*
2085 :h3.Fields in record inside union in wrong order - template
2086 .*---------------------------------------------------------------------*
2087 :xmp tab=0.
2088
2089 <TC -  Fields in record inside union in wrong order - template>
2090
2091 <COMPILE>
2092 <VERDICT_LEAF PASS>
2093 <MODULE TTCN Temp Temp.ttcn>
2094 module Temp {
2095
2096
2097 type record aTest  {integer i, charstring c, bTest r}
2098 type record bTest  {integer i , charstring c optional}
2099 type union cTest {aTest a, bTest b}
2100 template cTest tem := {a := { i := 1, c := "aTest", r := {c := "bTest", i:= 1}}}
2101
2102
2103 }
2104 <END_MODULE>
2105 <RESULT IF_PASS COUNT 1>
2106 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?template.+?record
2107 <END_RESULT>
2108 <RESULT IF_PASS COUNT 1>
2109 (?is)\berror:
2110 <END_RESULT>
2111 <END_TC>
2112
2113 :exmp.
2114
2115 .*---------------------------------------------------------------------*
2116 :h3.Fields of record in wrong order - template
2117 .*---------------------------------------------------------------------*
2118 :xmp tab=0.
2119
2120 <TC -  Fields of record in wrong order - template>
2121
2122 <COMPILE>
2123 <VERDICT_LEAF PASS>
2124 <MODULE TTCN Temp Temp.ttcn>
2125 module Temp {
2126
2127
2128 type record aTest  {integer i, charstring c}
2129         template aTest tem :=  {c := "aTest", i := 1}
2130
2131
2132 }
2133 <END_MODULE>
2134 <RESULT IF_PASS COUNT 1>
2135 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?template.+?record
2136 <END_RESULT>
2137 <RESULT IF_PASS COUNT 1>
2138 (?is)\berror:
2139 <END_RESULT>
2140 <END_TC>
2141
2142 :exmp.
2143
2144 .*---------------------------------------------------------------------*
2145 :h3.Fields of contained record in wrong order - template
2146 .*---------------------------------------------------------------------*
2147 :xmp tab=0.
2148
2149 <TC -  Fields of contained record in wrong order - template>
2150
2151 <COMPILE>
2152 <VERDICT_LEAF PASS>
2153 <MODULE TTCN Temp Temp.ttcn>
2154 module Temp {
2155
2156
2157 type record aTest  {integer i, bTest r}
2158 type record bTest  {integer i , charstring c}
2159         template aTest tem :=  {i := 1, r := {c := "bTest",i := 2}}
2160
2161
2162 }
2163 <END_MODULE>
2164 <RESULT IF_PASS COUNT 1>
2165 (?im)error.+?Field.+?cannot.+?appear.+?after.+?in.+?template.+?record
2166 <END_RESULT>
2167 <RESULT IF_PASS COUNT 1>
2168 (?is)\berror:
2169 <END_RESULT>
2170 <END_TC>
2171
2172 :exmp.
2173
2174 .*---------------------------------------------------------------------*
2175 :h2.Uninitialized field in record or set at declaration
2176 .*---------------------------------------------------------------------*
2177
2178 .*---------------------------------------------------------------------*
2179 :h3.Missing field from record - constant
2180 .*---------------------------------------------------------------------*
2181 :xmp tab=0.
2182
2183 <TC -  Missing field from record - constant>
2184
2185 <COMPILE>
2186 <VERDICT_LEAF PASS>
2187 <MODULE TTCN Temp Temp.ttcn>
2188 module Temp {
2189
2190
2191 type record aTest  {integer i, charstring c}
2192         const aTest con :=  {i := 1}
2193
2194
2195 }
2196 <END_MODULE>
2197 <RESULT IF_PASS COUNT 0>
2198 (?is)\berror:
2199 <END_RESULT>
2200 <END_TC>
2201
2202 :exmp.
2203
2204 .*---------------------------------------------------------------------*
2205 :h3.Missing field from contained record - constant
2206 .*---------------------------------------------------------------------*
2207 :xmp tab=0.
2208
2209 <TC -  Missing field from contained record - constant>
2210
2211 <COMPILE>
2212 <VERDICT_LEAF PASS>
2213 <MODULE TTCN Temp Temp.ttcn>
2214 module Temp {
2215
2216
2217 type record aTest  {integer i, bTest r}
2218 type record bTest  {integer i , charstring c}
2219         const aTest con :=  {i := 1, r := {c := "bTest"}}
2220
2221
2222 }
2223 <END_MODULE>
2224 <RESULT IF_PASS COUNT 0>
2225 (?is)\berror:
2226 <END_RESULT>
2227 <END_TC>
2228
2229 :exmp.
2230
2231 .*---------------------------------------------------------------------*
2232 :h3.Missing field from set - constant
2233 .*---------------------------------------------------------------------*
2234 :xmp tab=0.
2235
2236 <TC -  Missing field from set - constant>
2237
2238 <COMPILE>
2239 <VERDICT_LEAF PASS>
2240 <MODULE TTCN Temp Temp.ttcn>
2241 module Temp {
2242
2243
2244 type set aTest  {integer i, charstring c}
2245         const aTest con :=  {i := 1}
2246
2247
2248 }
2249 <END_MODULE>
2250 <RESULT IF_PASS COUNT 0>
2251 (?is)\berror:
2252 <END_RESULT>
2253 <END_TC>
2254
2255 :exmp.
2256
2257 .*---------------------------------------------------------------------*
2258 :h3.Missing field from contained set - constant
2259 .*---------------------------------------------------------------------*
2260 :xmp tab=0.
2261
2262 <TC -  Missing field from contained set - constant>
2263
2264 <COMPILE>
2265 <VERDICT_LEAF PASS>
2266 <MODULE TTCN Temp Temp.ttcn>
2267 module Temp {
2268
2269
2270 type set aTest  {integer i, bTest r}
2271 type set bTest  {integer i , charstring c}
2272         const aTest con :=  {i := 1, r := {i := 2}}
2273
2274
2275 }
2276 <END_MODULE>
2277 <RESULT IF_PASS COUNT 0>
2278 (?is)\berror:
2279 <END_RESULT>
2280 <END_TC>
2281
2282 :exmp.
2283
2284 .*---------------------------------------------------------------------*
2285 :h3.Missing optional field from record - constant
2286 .*---------------------------------------------------------------------*
2287 :xmp tab=0.
2288
2289 <TC -  Missing optional field from record - constant>
2290
2291 <COMPILE>
2292 <VERDICT_LEAF PASS>
2293 <MODULE TTCN Temp Temp.ttcn>
2294 module Temp {
2295
2296
2297 type record aTest  {integer i, bTest r optional}
2298 type set bTest  {integer i , charstring c}
2299
2300         const aTest con :=  {i := 1}
2301
2302
2303 }
2304 <END_MODULE>
2305 <RESULT IF_PASS COUNT 0>
2306 (?is)\berror:
2307 <END_RESULT>
2308 <END_TC>
2309
2310 :exmp.
2311
2312 .*---------------------------------------------------------------------*
2313 :h3.Missing optional field from set - constant
2314 .*---------------------------------------------------------------------*
2315 :xmp tab=0.
2316
2317 <TC -  Missing optional field from set - constant>
2318
2319 <COMPILE>
2320 <VERDICT_LEAF PASS>
2321 <MODULE TTCN Temp Temp.ttcn>
2322 module Temp {
2323
2324
2325 type set aTest  {integer i, bTest r optional}
2326 type set bTest  {integer i , charstring c}
2327
2328         const aTest con :=  {i := 1}
2329
2330
2331 }
2332 <END_MODULE>
2333 <RESULT IF_PASS COUNT 0>
2334 (?is)\berror:
2335 <END_RESULT>
2336 <END_TC>
2337
2338 :exmp.
2339
2340 .*---------------------------------------------------------------------*
2341 :h3.Uninitialised constant assigned to record field - constant
2342 .*---------------------------------------------------------------------*
2343 :xmp tab=0.
2344
2345 <TC -  Uninitialised constant assigned to record field - constant>
2346
2347 <COMPILE>
2348 <VERDICT_LEAF PASS>
2349 <MODULE TTCN Temp Temp.ttcn>
2350 module Temp {
2351
2352
2353 type record aTest  {integer i, bTest r optional}
2354 type set of integer bTest;
2355         const bTest con1 := {1,2, -}
2356         const aTest con :=  {i := con1[2], r := omit}
2357
2358
2359 }
2360 <END_MODULE>
2361 <RESULT IF_PASS COUNT 1>
2362 (?im)error.+?Not.+?used.+?symbol.+?is.+?not.+?allowed
2363 <END_RESULT>
2364 <RESULT IF_PASS COUNT 1>
2365 (?is)\berror:
2366 <END_RESULT>
2367 <END_TC>
2368
2369 :exmp.
2370
2371 .*---------------------------------------------------------------------*
2372 :h3.Missing field from record - template
2373 .*---------------------------------------------------------------------*
2374 :xmp tab=0.
2375
2376 <TC -  Missing field from record - template>
2377
2378 <COMPILE>
2379 <VERDICT_LEAF PASS>
2380 <MODULE TTCN Temp Temp.ttcn>
2381 module Temp {
2382
2383
2384 type record aTest  {integer i, charstring c}
2385         template aTest tem :=  {i := 1}
2386
2387
2388 }
2389 <END_MODULE>
2390 <RESULT IF_PASS COUNT 0>
2391 (?is)\berror:
2392 <END_RESULT>
2393 <END_TC>
2394
2395 :exmp.
2396
2397 .*---------------------------------------------------------------------*
2398 :h3.Missing field from contained record - template
2399 .*---------------------------------------------------------------------*
2400 :xmp tab=0.
2401
2402 <TC -  Missing field from contained record - template>
2403
2404 <COMPILE>
2405 <VERDICT_LEAF PASS>
2406 <MODULE TTCN Temp Temp.ttcn>
2407 module Temp {
2408
2409
2410 type record aTest  {integer i, bTest r}
2411 type record bTest  {integer i , charstring c}
2412         template aTest tem :=  {i := 1, r := {c := "bTest"}}
2413
2414
2415 }
2416 <END_MODULE>
2417 <RESULT IF_PASS COUNT 0>
2418 (?is)\berror:
2419 <END_RESULT>
2420 <END_TC>
2421
2422 :exmp.
2423
2424 .*---------------------------------------------------------------------*
2425 :h3.Missing field from set - template
2426 .*---------------------------------------------------------------------*
2427 :xmp tab=0.
2428
2429 <TC -  Missing field from set - template>
2430
2431 <COMPILE>
2432 <VERDICT_LEAF PASS>
2433 <MODULE TTCN Temp Temp.ttcn>
2434 module Temp {
2435
2436
2437 type set aTest  {integer i, charstring c}
2438         template aTest tem :=  {i := 1}
2439
2440
2441 }
2442 <END_MODULE>
2443 <RESULT IF_PASS COUNT 0>
2444 (?is)\berror:
2445 <END_RESULT>
2446 <END_TC>
2447
2448 :exmp.
2449
2450 .*---------------------------------------------------------------------*
2451 :h3.Missing field from contained set - template
2452 .*---------------------------------------------------------------------*
2453 :xmp tab=0.
2454
2455 <TC -  Missing field from contained set - template>
2456
2457 <COMPILE>
2458 <VERDICT_LEAF PASS>
2459 <MODULE TTCN Temp Temp.ttcn>
2460 module Temp {
2461
2462
2463 type set aTest  {integer i, bTest r}
2464 type set bTest  {integer i , charstring c}
2465         template aTest tem :=  {i := 1, r := {i := 2}}
2466
2467
2468 }
2469 <END_MODULE>
2470 <RESULT IF_PASS COUNT 0>
2471 (?is)\berror:
2472 <END_RESULT>
2473 <END_TC>
2474
2475 :exmp.
2476
2477 .*---------------------------------------------------------------------*
2478 :h3.Missing optional field from record - template
2479 .*---------------------------------------------------------------------*
2480 :xmp tab=0.
2481
2482 <TC -  Missing optional field from record - template>
2483
2484 <COMPILE>
2485 <VERDICT_LEAF PASS>
2486 <MODULE TTCN Temp Temp.ttcn>
2487 module Temp {
2488
2489
2490 type record aTest  {integer i, bTest r optional}
2491 type set bTest  {integer i , charstring c}
2492
2493         template aTest tem :=  {i := 1}
2494
2495
2496 }
2497 <END_MODULE>
2498 <RESULT IF_PASS COUNT 0>
2499 (?is)\berror:
2500 <END_RESULT>
2501 <END_TC>
2502
2503 :exmp.
2504
2505 .*---------------------------------------------------------------------*
2506 :h3.Missing optional field from set - template
2507 .*---------------------------------------------------------------------*
2508 :xmp tab=0.
2509
2510 <TC -  Missing optional field from set - template>
2511
2512 <COMPILE>
2513 <VERDICT_LEAF PASS>
2514 <MODULE TTCN Temp Temp.ttcn>
2515 module Temp {
2516
2517
2518 type set aTest  {integer i, bTest r optional}
2519 type set bTest  {integer i , charstring c}
2520
2521         template aTest tem :=  {i := 1}
2522
2523
2524 }
2525 <END_MODULE>
2526 <RESULT IF_PASS COUNT 0>
2527 (?is)\berror:
2528 <END_RESULT>
2529 <END_TC>
2530
2531 :exmp.
2532
2533 .*---------------------------------------------------------------------*
2534 :h3.Uninitialised constant assigned to record field - template
2535 .*---------------------------------------------------------------------*
2536 :xmp tab=0.
2537
2538 <TC -  Uninitialised constant assigned to record field - template>
2539
2540 <COMPILE>
2541 <VERDICT_LEAF PASS>
2542 <MODULE TTCN Temp Temp.ttcn>
2543 module Temp {
2544
2545
2546 type record aTest  {integer i, bTest r optional}
2547 type set of integer bTest;
2548         template bTest tem1 := {1,2, -}
2549         template aTest tem :=  {i := tem1[2], r := omit}
2550
2551
2552 }
2553 <END_MODULE>
2554 <RESULT IF_PASS COUNT 1>
2555 (?im)error.+?Not.+?used.+?symbol.+?is.+?not.+?allowed
2556 <END_RESULT>
2557 <RESULT IF_PASS COUNT 1>
2558 (?is)\berror:
2559 <END_RESULT>
2560 <END_TC>
2561
2562 :exmp.
2563
2564
2565 .*---------------------------------------------------------------------*
2566 :h2.Duplicate initialization of field in assigment notation
2567 .*---------------------------------------------------------------------*
2568
2569 .*---------------------------------------------------------------------*
2570 :h3.Duplicate field in record
2571 .*---------------------------------------------------------------------*
2572 :xmp tab=0.
2573
2574 <TC -  Duplicate field in record>
2575
2576 <COMPILE>
2577 <VERDICT_LEAF PASS>
2578 <MODULE TTCN Temp Temp.ttcn>
2579 module Temp {
2580
2581
2582 type record aTest  {integer i, charstring c}
2583         const aTest con :=  {i := 1, i := 2, c := "aTest"}
2584
2585
2586 }
2587 <END_MODULE>
2588 <RESULT IF_PASS COUNT 1>
2589 (?im)error.+?Duplicate.+?record.+?field
2590 <END_RESULT>
2591 <RESULT IF_PASS COUNT 1>
2592 (?im)note.+?Field.+?already.+?given.+?here
2593 <END_RESULT>
2594 <RESULT IF_PASS COUNT 1>
2595 (?is)\berror:
2596 <END_RESULT>
2597 <END_TC>
2598
2599 :exmp.
2600
2601 .*---------------------------------------------------------------------*
2602 :h3.Duplicate field in contained record
2603 .*---------------------------------------------------------------------*
2604 :xmp tab=0.
2605
2606 <TC -  Duplicate field in contained record>
2607
2608 <COMPILE>
2609 <VERDICT_LEAF PASS>
2610 <MODULE TTCN Temp Temp.ttcn>
2611 module Temp {
2612
2613
2614 type record aTest  {integer i, bTest r}
2615 type record bTest  {integer i , charstring c}
2616         const aTest con :=  {i := 1, r := {i := 2, i:= 3, c := "bTest"}}
2617
2618
2619 }
2620 <END_MODULE>
2621 <RESULT IF_PASS COUNT 1>
2622 (?im)error.+?Duplicate.+?record.+?field
2623 <END_RESULT>
2624 <RESULT IF_PASS COUNT 1>
2625 (?im)note.+?Field.+?already.+?given.+?here
2626 <END_RESULT>
2627 <RESULT IF_PASS COUNT 1>
2628 (?is)\berror:
2629 <END_RESULT>
2630 <END_TC>
2631
2632 :exmp.
2633
2634 .*---------------------------------------------------------------------*
2635 :h3.Duplicate field in set
2636 .*---------------------------------------------------------------------*
2637 :xmp tab=0.
2638
2639 <TC -  Duplicate field in set>
2640
2641 <COMPILE>
2642 <VERDICT_LEAF PASS>
2643 <MODULE TTCN Temp Temp.ttcn>
2644 module Temp {
2645
2646
2647 type set aTest  {integer i, bTest r}
2648 type set bTest  {integer i , charstring c}
2649         const aTest con :=  { r := {i:= 2, c := "bTest"}, i := 1, r := {i:= 3, c := "bTest"}}
2650
2651
2652 }
2653 <END_MODULE>
2654 <RESULT IF_PASS COUNT 1>
2655 (?im)error.+?Duplicate.+?set.+?field
2656 <END_RESULT>
2657 <RESULT IF_PASS COUNT 1>
2658 (?im)note.+?Field.+?already.+?given.+?here
2659 <END_RESULT>
2660 <RESULT IF_PASS COUNT 1>
2661 (?is)\berror:
2662 <END_RESULT>
2663 <END_TC>
2664
2665 :exmp.
2666
2667 .*---------------------------------------------------------------------*
2668 :h3.Duplicate field in contained set
2669 .*---------------------------------------------------------------------*
2670 :xmp tab=0.
2671
2672 <TC -  Duplicate field in contained set>
2673
2674 <COMPILE>
2675 <VERDICT_LEAF PASS>
2676 <MODULE TTCN Temp Temp.ttcn>
2677 module Temp {
2678
2679
2680 type set aTest  {integer i, bTest r}
2681 type set bTest  {integer i , charstring c}
2682         const aTest con :=  {i := 1, r := {i:= 3, c := "bTest", i:= 4}}
2683
2684
2685 }
2686 <END_MODULE>
2687 <RESULT IF_PASS COUNT 1>
2688 (?im)error.+?Duplicate.+?set.+?field
2689 <END_RESULT>
2690 <RESULT IF_PASS COUNT 1>
2691 (?im)note.+?Field.+?already.+?given.+?here
2692 <END_RESULT>
2693 <RESULT IF_PASS COUNT 1>
2694 (?is)\berror:
2695 <END_RESULT>
2696 <END_TC>
2697
2698 :exmp.
2699
2700 .*---------------------------------------------------------------------*
2701 :h3.Duplicate optional field in record
2702 .*---------------------------------------------------------------------*
2703 :xmp tab=0.
2704
2705 <TC -  Duplicate optional field in record>
2706
2707 <COMPILE>
2708 <VERDICT_LEAF PASS>
2709 <MODULE TTCN Temp Temp.ttcn>
2710 module Temp {
2711
2712
2713 type record aTest  {integer i, bTest r}
2714 type record bTest  {integer i , charstring c optional}
2715         const aTest con :=  {i := 1, r := {i := 3, c := omit, c := "bTest"}}
2716
2717
2718 }
2719 <END_MODULE>
2720 <RESULT IF_PASS COUNT 1>
2721 (?im)error.+?Duplicate.+?record.+?field
2722 <END_RESULT>
2723 <RESULT IF_PASS COUNT 1>
2724 (?im)note.+?Field.+?already.+?given.+?here
2725 <END_RESULT>
2726 <RESULT IF_PASS COUNT 1>
2727 (?is)\berror:
2728 <END_RESULT>
2729 <END_TC>
2730
2731 :exmp.
2732
2733 .*---------------------------------------------------------------------*
2734 :h3.Duplicate optional field in set
2735 .*---------------------------------------------------------------------*
2736 :xmp tab=0.
2737
2738 <TC -  Duplicate optional field in set>
2739
2740 <COMPILE>
2741 <VERDICT_LEAF PASS>
2742 <MODULE TTCN Temp Temp.ttcn>
2743 module Temp {
2744
2745
2746 type record aTest  {integer i, bTest r}
2747 type set bTest  {integer i , charstring c optional}
2748         const aTest con :=  {i := 1, r := {i := 3, c := omit, c := "bTest"}}
2749
2750
2751 }
2752 <END_MODULE>
2753 <RESULT IF_PASS COUNT 1>
2754 (?im)error.+?Duplicate.+?set.+?field
2755 <END_RESULT>
2756 <RESULT IF_PASS COUNT 1>
2757 (?im)note.+?Field.+?already.+?given.+?here
2758 <END_RESULT>
2759 <RESULT IF_PASS COUNT 1>
2760 (?is)\berror:
2761 <END_RESULT>
2762 <END_TC>
2763
2764 :exmp.
2765 .*---------------------------------------------------------------------*
2766 :h2.Reference to non-existent field in assignment notation
2767 .*---------------------------------------------------------------------*
2768
2769 .*---------------------------------------------------------------------*
2770 :h3.Reference to non-existent field in record
2771 .*---------------------------------------------------------------------*
2772 :xmp tab=0.
2773
2774 <TC -  Reference to non-existent field in record>
2775
2776 <COMPILE>
2777 <VERDICT_LEAF PASS>
2778 <MODULE TTCN Temp Temp.ttcn>
2779 module Temp {
2780
2781
2782 type record aTest  {integer i, charstring c}
2783
2784 const aTest con :=  {i := 1, b := 2, c := "aTest"}
2785
2786 }
2787 <END_MODULE>
2788 <RESULT IF_PASS COUNT 1>
2789 (?im)error.+?Reference.+?to.+?non-existent.+?field
2790 <END_RESULT>
2791 <RESULT IF_PASS COUNT 1>
2792 (?is)\berror:
2793 <END_RESULT>
2794 <END_TC>
2795
2796 :exmp.
2797
2798 .*---------------------------------------------------------------------*
2799 :h3.Reference to non-existent field in contained record
2800 .*---------------------------------------------------------------------*
2801 :xmp tab=0.
2802
2803 <TC -  Reference to non-existent field in contained record>
2804
2805 <COMPILE>
2806 <VERDICT_LEAF PASS>
2807 <MODULE TTCN Temp Temp.ttcn>
2808 module Temp {
2809
2810
2811 type record aTest  {integer i, bTest r}
2812 type record bTest  {integer i , charstring c}
2813
2814 const aTest con :=  {i := 1, r := {i := 2, b:= 3, c := "bTest"}}
2815
2816
2817 }
2818 <END_MODULE>
2819 <RESULT IF_PASS COUNT 1>
2820 (?im)error.+?Reference.+?to.+?non-existent.+?field
2821 <END_RESULT>
2822 <RESULT IF_PASS COUNT 1>
2823 (?is)\berror:
2824 <END_RESULT>
2825 <END_TC>
2826
2827 :exmp.
2828
2829 .*---------------------------------------------------------------------*
2830 :h3.Reference to non-existent field in set1
2831 .*---------------------------------------------------------------------*
2832 :xmp tab=0.
2833
2834 <TC -  Reference to non-existent field in set1>
2835
2836 <COMPILE>
2837 <VERDICT_LEAF PASS>
2838 <MODULE TTCN Temp Temp.ttcn>
2839 module Temp {
2840
2841
2842 type set aTest  {integer i, charstring c}
2843
2844 const aTest con :=  {i := 1, c := "aTest", b := 2}
2845
2846
2847 }
2848 <END_MODULE>
2849 <RESULT IF_PASS COUNT 1>
2850 (?im)error.+?Reference.+?to.+?non-existent.+?field
2851 <END_RESULT>
2852 <RESULT IF_PASS COUNT 1>
2853 (?is)\berror:
2854 <END_RESULT>
2855 <END_TC>
2856
2857 :exmp.
2858
2859 .*---------------------------------------------------------------------*
2860 :h3.Reference to non-existent field in set2
2861 .*---------------------------------------------------------------------*
2862 :xmp tab=0.
2863
2864 <TC -  Reference to non-existent field in set2>
2865
2866 <COMPILE>
2867 <VERDICT_LEAF PASS>
2868 <MODULE TTCN Temp Temp.ttcn>
2869 module Temp {
2870
2871
2872 type set aTest  {integer i, bTest r}
2873 type set bTest  {integer i , charstring c}
2874         const aTest con :=  {i := 1, r := {i:= 3, c := "bTest", b:= 4}}
2875
2876
2877 }
2878 <END_MODULE>
2879 <RESULT IF_PASS COUNT 1>
2880 (?im)error.+?Reference.+?to.+?non-existent.+?field
2881 <END_RESULT>
2882 <RESULT IF_PASS COUNT 1>
2883 (?is)\berror:
2884 <END_RESULT>
2885 <END_TC>
2886
2887 :exmp.
2888
2889 .*---------------------------------------------------------------------*
2890 :h3.Reference to non-existent field in union
2891 .*---------------------------------------------------------------------*
2892 :xmp tab=0.
2893
2894 <TC -  Reference to non-existent field in union>
2895
2896 <COMPILE>
2897 <VERDICT_LEAF PASS>
2898 <MODULE TTCN Temp Temp.ttcn>
2899 module Temp {
2900
2901
2902 type union cTest {integer i, boolean b}
2903 const cTest con := {c := "abc"}
2904
2905
2906 }
2907 <END_MODULE>
2908 <RESULT IF_PASS COUNT 1>
2909 (?im)error.+?Reference.+?to.+?non-existent.+?field
2910 <END_RESULT>
2911 <RESULT IF_PASS COUNT 1>
2912 (?is)\berror:
2913 <END_RESULT>
2914 <END_TC>
2915
2916 :exmp.
2917
2918 .*---------------------------------------------------------------------*
2919 :h3.Reference to non-existent field in record inside union
2920 .*---------------------------------------------------------------------*
2921 :xmp tab=0.
2922
2923 <TC -  Reference to non-existent field in record inside union>
2924
2925 <COMPILE>
2926 <VERDICT_LEAF PASS>
2927 <MODULE TTCN Temp Temp.ttcn>
2928 module Temp {
2929
2930
2931 type record bTest  {integer i , charstring c}
2932 type union cTest {integer i, bTest b}
2933 const cTest con := {b := {i :=1, c := "bTest", ii := 2}}
2934
2935
2936 }
2937 <END_MODULE>
2938 <RESULT IF_PASS COUNT 1>
2939 (?im)error.+?Reference.+?to.+?non-existent.+?field
2940 <END_RESULT>
2941 <RESULT IF_PASS COUNT 1>
2942 (?is)\berror:
2943 <END_RESULT>
2944 <END_TC>
2945
2946 :exmp.
2947
2948 .*---------------------------------------------------------------------*
2949 :h3.Reference to non-existent field in contained union
2950 .*---------------------------------------------------------------------*
2951 :xmp tab=0.
2952
2953 <TC -  Reference to non-existent field in contained union>
2954
2955 <COMPILE>
2956 <VERDICT_LEAF PASS>
2957 <MODULE TTCN Temp Temp.ttcn>
2958 module Temp {
2959
2960
2961 type union cTest {integer i, boolean b}
2962 type record of cTest bTest
2963
2964 const bTest con := {{c :=1}}
2965
2966
2967 }
2968 <END_MODULE>
2969 <RESULT IF_PASS COUNT 1>
2970 (?im)error.+?Reference.+?to.+?non-existent.+?field
2971 <END_RESULT>
2972 <RESULT IF_PASS COUNT 1>
2973 (?is)\berror:
2974 <END_RESULT>
2975 <END_TC>
2976
2977 :exmp.
2978
2979 .*---------------------------------------------------------------------*
2980 :h3.Reference to non-existent field in empty record
2981 .*---------------------------------------------------------------------*
2982 :xmp tab=0.
2983
2984 <TC -  Reference to non-existent field in empty record>
2985
2986 <COMPILE>
2987 <VERDICT_LEAF PASS>
2988 <MODULE TTCN Temp Temp.ttcn>
2989 module Temp {
2990
2991
2992 type record bTest {}
2993
2994 const bTest con := {c := 1}
2995
2996 }
2997 <END_MODULE>
2998 <RESULT IF_PASS COUNT 1>
2999 (?im)error.+?Reference.+?to.+?non-existent.+?field
3000 <END_RESULT>
3001 <RESULT IF_PASS COUNT 1>
3002 (?is)\berror:
3003 <END_RESULT>
3004 <END_TC>
3005
3006 :exmp.
3007
3008 .*---------------------------------------------------------------------*
3009 :h3.Reference to non-existent field in empty set
3010 .*---------------------------------------------------------------------*
3011 :xmp tab=0.
3012
3013 <TC -  Reference to non-existent field in empty set>
3014
3015 <COMPILE>
3016 <VERDICT_LEAF PASS>
3017 <MODULE TTCN Temp Temp.ttcn>
3018 module Temp {
3019
3020
3021 type set bTest {}
3022
3023 const bTest con := {c := 1}
3024
3025 }
3026 <END_MODULE>
3027 <RESULT IF_PASS COUNT 1>
3028 (?im)error.+?Reference.+?to.+?non-existent.+?field
3029 <END_RESULT>
3030 <RESULT IF_PASS COUNT 1>
3031 (?is)\berror:
3032 <END_RESULT>
3033 <END_TC>
3034
3035 :exmp.
3036 .*---------------------------------------------------------------------*
3037 :h2.Omit value in mandatory field
3038 .*---------------------------------------------------------------------*
3039
3040 .*---------------------------------------------------------------------*
3041 :h3.Omit value in mandatory field of set - constant
3042 .*---------------------------------------------------------------------*
3043 :xmp tab=0.
3044
3045 <TC -  Omit value in mandatory field of set - constant>
3046
3047 <COMPILE>
3048 <VERDICT_LEAF PASS>
3049 <MODULE TTCN Temp Temp.ttcn>
3050 module Temp {
3051
3052
3053 type set aTest  {integer i, charstring c}
3054
3055 const aTest con :=  {i := omit, c := "aTest"}
3056
3057
3058 }
3059 <END_MODULE>
3060 <RESULT IF_PASS COUNT 1>
3061 (?im)error.+?omit.+?not.+?allowed
3062 <END_RESULT>
3063 <RESULT IF_PASS COUNT 1>
3064 (?is)\berror:
3065 <END_RESULT>
3066 <END_TC>
3067
3068 :exmp.
3069
3070 .*---------------------------------------------------------------------*
3071 :h3.Omit value in mandatory field of record - constant
3072 .*---------------------------------------------------------------------*
3073 :xmp tab=0.
3074
3075 <TC -  Omit value in mandatory field of record - constant>
3076
3077 <COMPILE>
3078 <VERDICT_LEAF PASS>
3079 <MODULE TTCN Temp Temp.ttcn>
3080 module Temp {
3081
3082
3083 type record aTest  {integer i, charstring c}
3084
3085 const aTest con :=  {i := omit, c := "aTest"}
3086
3087
3088 }
3089 <END_MODULE>
3090 <RESULT IF_PASS COUNT 1>
3091 (?im)error.+?omit.+?not.+?allowed
3092 <END_RESULT>
3093 <RESULT IF_PASS COUNT 1>
3094 (?is)\berror:
3095 <END_RESULT>
3096 <END_TC>
3097
3098 :exmp.
3099
3100 .*---------------------------------------------------------------------*
3101 :h3.Omit value in mandatory field of contained set - constant
3102 .*---------------------------------------------------------------------*
3103 :xmp tab=0.
3104
3105 <TC -  Omit value in mandatory field of contained set - constant>
3106
3107 <COMPILE>
3108 <VERDICT_LEAF PASS>
3109 <MODULE TTCN Temp Temp.ttcn>
3110 module Temp {
3111
3112
3113 type record aTest  {integer i, bTest r optional}
3114 type set bTest  {integer i , charstring c}
3115 const aTest con :=  {i := 1, r := {i := 2, c := omit}}
3116
3117
3118 }
3119 <END_MODULE>
3120 <RESULT IF_PASS COUNT 1>
3121 (?im)error.+?omit.+?not.+?allowed
3122 <END_RESULT>
3123 <RESULT IF_PASS COUNT 1>
3124 (?is)\berror:
3125 <END_RESULT>
3126 <END_TC>
3127
3128 :exmp.
3129
3130 .*---------------------------------------------------------------------*
3131 :h3.Omit value in mandatory field of contained record - constant
3132 .*---------------------------------------------------------------------*
3133 :xmp tab=0.
3134
3135 <TC -  Omit value in mandatory field of contained record - constant>
3136
3137 <COMPILE>
3138 <VERDICT_LEAF PASS>
3139 <MODULE TTCN Temp Temp.ttcn>
3140 module Temp {
3141
3142
3143 type set aTest  {integer i, bTest r optional}
3144 type record bTest  {integer i , charstring c}
3145 const aTest con :=  {i := 1, r := {i := 2, c := omit}}
3146
3147
3148 }
3149 <END_MODULE>
3150 <RESULT IF_PASS COUNT 1>
3151 (?im)error.+?omit.+?not.+?allowed
3152 <END_RESULT>
3153 <RESULT IF_PASS COUNT 1>
3154 (?is)\berror:
3155 <END_RESULT>
3156 <END_TC>
3157
3158 .*---------------------------------------------------------------------*
3159 :h3.Omit value in mandatory field of contained record in union - constant
3160 .*---------------------------------------------------------------------*
3161 :xmp tab=0.
3162
3163 <TC -  Omit value in mandatory field of contained record in union - constant>
3164
3165 <COMPILE>
3166 <VERDICT_LEAF PASS>
3167 <MODULE TTCN Temp Temp.ttcn>
3168 module Temp {
3169
3170
3171 type record bTest  {charstring c}
3172 type union cTest {integer i, bTest b}
3173 const cTest con := {b := {omit}}
3174
3175
3176 }
3177 <END_MODULE>
3178 <RESULT IF_PASS COUNT 1>
3179 (?im)error.+?omit.+?not.+?allowed
3180 <END_RESULT>
3181 <RESULT IF_PASS COUNT 1>
3182 (?is)\berror:
3183 <END_RESULT>
3184 <END_TC>
3185
3186 :exmp.
3187
3188 .*---------------------------------------------------------------------*
3189 :h3.Omit value in mandatory field of set - template
3190 .*---------------------------------------------------------------------*
3191 :xmp tab=0.
3192
3193 <TC -  Omit value in mandatory field of set - template>
3194
3195 <COMPILE>
3196 <VERDICT_LEAF PASS>
3197 <MODULE TTCN Temp Temp.ttcn>
3198 module Temp {
3199
3200
3201 type set aTest  {integer i, charstring c}
3202
3203 template aTest tem :=  {i := omit, c := "aTest"}
3204
3205
3206 }
3207 <END_MODULE>
3208 <RESULT IF_PASS COUNT 1>
3209 (?im)error.+?omit.+?not.+?allowed.+?context
3210 <END_RESULT>
3211 <RESULT IF_PASS COUNT 1>
3212 (?is)\berror:
3213 <END_RESULT>
3214 <END_TC>
3215
3216 :exmp.
3217
3218 .*---------------------------------------------------------------------*
3219 :h3.Omit value in mandatory field of record - template
3220 .*---------------------------------------------------------------------*
3221 :xmp tab=0.
3222
3223 <TC -  Omit value in mandatory field of record - template>
3224
3225 <COMPILE>
3226 <VERDICT_LEAF PASS>
3227 <MODULE TTCN Temp Temp.ttcn>
3228 module Temp {
3229
3230
3231 type record aTest  {integer i, charstring c}
3232
3233 template aTest tem :=  {i := omit, c := "aTest"}
3234
3235
3236 }
3237 <END_MODULE>
3238 <RESULT IF_PASS COUNT 1>
3239 (?im)error.+?omit.+?not.+?allowed.+?context
3240 <END_RESULT>
3241 <RESULT IF_PASS COUNT 1>
3242 (?is)\berror:
3243 <END_RESULT>
3244 <END_TC>
3245
3246 :exmp.
3247
3248 .*---------------------------------------------------------------------*
3249 :h3.Omit value in mandatory field of contained set - template
3250 .*---------------------------------------------------------------------*
3251 :xmp tab=0.
3252
3253 <TC -  Omit value in mandatory field of contained set - template>
3254
3255 <COMPILE>
3256 <VERDICT_LEAF PASS>
3257 <MODULE TTCN Temp Temp.ttcn>
3258 module Temp {
3259
3260
3261 type record aTest  {integer i, bTest r optional}
3262 type set bTest  {integer i , charstring c}
3263
3264 template aTest tem :=  {i := 1, r := {i := 2, c := omit}}
3265
3266
3267 }
3268 <END_MODULE>
3269 <RESULT IF_PASS COUNT 1>
3270 (?im)error.+?omit.+?not.+?allowed.+?context
3271 <END_RESULT>
3272 <RESULT IF_PASS COUNT 1>
3273 (?is)\berror:
3274 <END_RESULT>
3275 <END_TC>
3276
3277 :exmp.
3278
3279 .*---------------------------------------------------------------------*
3280 :h3.Omit value in mandatory field of contained record - template
3281 .*---------------------------------------------------------------------*
3282 :xmp tab=0.
3283
3284 <TC -  Omit value in mandatory field of contained record - template>
3285
3286 <COMPILE>
3287 <VERDICT_LEAF PASS>
3288 <MODULE TTCN Temp Temp.ttcn>
3289 module Temp {
3290
3291
3292 type set aTest  {integer i, bTest r optional}
3293 type record bTest  {integer i , charstring c}
3294
3295 template aTest tem :=  {i := 1, r := {i := 2, c := omit}}
3296
3297
3298 }
3299 <END_MODULE>
3300 <RESULT IF_PASS COUNT 1>
3301 (?im)error.+?omit.+?not.+?allowed.+?context
3302 <END_RESULT>
3303 <RESULT IF_PASS COUNT 1>
3304 (?is)\berror:
3305 <END_RESULT>
3306 <END_TC>
3307
3308 :exmp.
3309
3310 .*---------------------------------------------------------------------*
3311 :h3.Omit value in mandatory field of contained record in union - template
3312 .*---------------------------------------------------------------------*
3313 :xmp tab=0.
3314
3315 <TC -  Omit value in mandatory field of contained record in union - template>
3316
3317 <COMPILE>
3318 <VERDICT_LEAF PASS>
3319 <MODULE TTCN Temp Temp.ttcn>
3320 module Temp {
3321
3322
3323 type record bTest  {charstring c}
3324 type union cTest {integer i, bTest b}
3325 template cTest tem := {b := {omit}}
3326
3327
3328 }
3329 <END_MODULE>
3330 <RESULT IF_PASS COUNT 1>
3331 (?im)error.+?omit.+?not.+?allowed.+?context
3332 <END_RESULT>
3333 <RESULT IF_PASS COUNT 1>
3334 (?is)\berror:
3335 <END_RESULT>
3336 <END_TC>
3337
3338 :exmp.
3339 .*---------------------------------------------------------------------*
3340 :h2.Missing optional field in assignment notation
3341 .*---------------------------------------------------------------------*
3342
3343 .*---------------------------------------------------------------------*
3344 :h3.Missing optional field in set - constant
3345 .*---------------------------------------------------------------------*
3346 :xmp tab=0.
3347
3348 <TC -  Missing optional field in set - constant>
3349
3350 <COMPILE>
3351 <VERDICT_LEAF PASS>
3352 <MODULE TTCN Temp Temp.ttcn>
3353 module Temp {
3354
3355
3356 type set aTest  {integer i, bTest r optional}
3357 type set bTest  {integer i , charstring c}
3358
3359 const aTest con :=  {i := 1}
3360
3361
3362 }
3363 <END_MODULE>
3364 <RESULT IF_PASS COUNT 0>
3365 (?is)\berror:
3366 <END_RESULT>
3367 <END_TC>
3368
3369 :exmp.
3370
3371 .*---------------------------------------------------------------------*
3372 :h3.Missing optional field in contained set - constant
3373 .*---------------------------------------------------------------------*
3374 :xmp tab=0.
3375
3376 <TC -  Missing optional field in contained set - constant>
3377
3378 <COMPILE>
3379 <VERDICT_LEAF PASS>
3380 <MODULE TTCN Temp Temp.ttcn>
3381 module Temp {
3382
3383
3384 type set aTest  {integer i, bTest r}
3385 type set bTest  {integer i , charstring c optional}
3386
3387 const aTest con :=  {i := 1, r := {i := 3}}
3388
3389
3390 }
3391 <END_MODULE>
3392 <RESULT IF_PASS COUNT 0>
3393 (?is)\berror:
3394 <END_RESULT>
3395 <END_TC>
3396
3397 :exmp.
3398
3399 .*---------------------------------------------------------------------*
3400 :h3.Missing optional field in record - constant
3401 .*---------------------------------------------------------------------*
3402 :xmp tab=0.
3403
3404 <TC -  Missing optional field in record - constant>
3405
3406 <COMPILE>
3407 <VERDICT_LEAF PASS>
3408 <MODULE TTCN Temp Temp.ttcn>
3409 module Temp {
3410
3411
3412 type record aTest  {integer i, bTest r optional}
3413 type set bTest  {integer i , charstring c}
3414
3415 const aTest con :=  {i := 1}
3416
3417
3418 }
3419 <END_MODULE>
3420 <RESULT IF_PASS COUNT 0>
3421 (?is)\berror:
3422 <END_RESULT>
3423 <END_TC>
3424
3425 :exmp.
3426
3427 .*---------------------------------------------------------------------*
3428 :h3.Missing optional field in contained record - constant
3429 .*---------------------------------------------------------------------*
3430 :xmp tab=0.
3431
3432 <TC -  Missing optional field in contained record - constant>
3433
3434 <COMPILE>
3435 <VERDICT_LEAF PASS>
3436 <MODULE TTCN Temp Temp.ttcn>
3437 module Temp {
3438
3439
3440 type record aTest  {integer i, bTest r}
3441 type record bTest  {integer i , charstring c optional}
3442
3443 const aTest con :=  {i := 1, r := {i := 3}}
3444
3445
3446 }
3447 <END_MODULE>
3448 <RESULT IF_PASS COUNT 0>
3449 (?is)\berror:
3450 <END_RESULT>
3451 <END_TC>
3452
3453 :exmp.
3454
3455 .*---------------------------------------------------------------------*
3456 :h3.Missing optional field in set - template
3457 .*---------------------------------------------------------------------*
3458 :xmp tab=0.
3459
3460 <TC -  Missing optional field in set - template>
3461
3462 <COMPILE>
3463 <VERDICT_LEAF PASS>
3464 <MODULE TTCN Temp Temp.ttcn>
3465 module Temp {
3466
3467
3468 type set aTest  {integer i, bTest r optional}
3469 type set bTest  {integer i , charstring c}
3470
3471 template aTest tem :=  {i := 1}
3472
3473
3474 }
3475 <END_MODULE>
3476 <RESULT IF_PASS COUNT 0>
3477 (?is)\berror:
3478 <END_RESULT>
3479 <END_TC>
3480
3481 :exmp.
3482
3483 .*---------------------------------------------------------------------*
3484 :h3.Missing optional field in contained set - template
3485 .*---------------------------------------------------------------------*
3486 :xmp tab=0.
3487
3488 <TC -  Missing optional field in contained set - template>
3489
3490 <COMPILE>
3491 <VERDICT_LEAF PASS>
3492 <MODULE TTCN Temp Temp.ttcn>
3493 module Temp {
3494
3495
3496 type set aTest  {integer i, bTest r}
3497 type set bTest  {integer i , charstring c optional}
3498
3499 template aTest tem :=  {i := 1, r := {i := 3}}
3500
3501
3502 }
3503 <END_MODULE>
3504 <RESULT IF_PASS COUNT 0>
3505 (?is)\berror:
3506 <END_RESULT>
3507 <END_TC>
3508
3509 :exmp.
3510
3511 .*---------------------------------------------------------------------*
3512 :h3.Missing optional field in record - template
3513 .*---------------------------------------------------------------------*
3514 :xmp tab=0.
3515
3516 <TC -  Missing optional field in record - template>
3517
3518 <COMPILE>
3519 <VERDICT_LEAF PASS>
3520 <MODULE TTCN Temp Temp.ttcn>
3521 module Temp {
3522
3523
3524 type record aTest  {integer i, bTest r optional}
3525 type set bTest  {integer i , charstring c}
3526
3527 template aTest tem :=  {i := 1}
3528
3529
3530 }
3531 <END_MODULE>
3532 <RESULT IF_PASS COUNT 0>
3533 (?is)\berror:
3534 <END_RESULT>
3535 <END_TC>
3536
3537 :exmp.
3538
3539 .*---------------------------------------------------------------------*
3540 :h3.Missing optional field in contained record - template
3541 .*---------------------------------------------------------------------*
3542 :xmp tab=0.
3543
3544 <TC -  Missing optional field in contained record - template>
3545
3546 <COMPILE>
3547 <VERDICT_LEAF PASS>
3548 <MODULE TTCN Temp Temp.ttcn>
3549 module Temp {
3550
3551
3552 type record aTest  {integer i, bTest r}
3553 type record bTest  {integer i , charstring c optional}
3554
3555 template aTest tem :=  {i := 1, r := {i := 3}}
3556
3557
3558 }
3559 <END_MODULE>
3560 <RESULT IF_PASS COUNT 0>
3561 (?is)\berror:
3562 <END_RESULT>
3563 <END_TC>
3564
3565 :exmp.
3566
3567 .*---------------------------------------------------------------------*
3568 :h3.Missing optional field in contained record inside union - constant
3569 .*---------------------------------------------------------------------*
3570 :xmp tab=0.
3571
3572 <TC -  Missing optional field in contained record inside union - constant>
3573
3574 <COMPILE>
3575 <VERDICT_LEAF PASS>
3576 <MODULE TTCN Temp Temp.ttcn>
3577 module Temp {
3578
3579
3580 type record aTest  {integer i, bTest r}
3581 type record bTest  {integer i , charstring c optional}
3582
3583 type union uType {aTest a, bTest b}
3584
3585 const uType u := {a := {i := 1, r := {i:=2}}}
3586
3587 }
3588 <END_MODULE>
3589 <RESULT IF_PASS COUNT 0>
3590 (?is)\berror:
3591 <END_RESULT>
3592 <END_TC>
3593
3594 :exmp.
3595
3596 .*---------------------------------------------------------------------*
3597 :h3.Missing optional field in contained record inside union - template
3598 .*---------------------------------------------------------------------*
3599 :xmp tab=0.
3600
3601 <TC -  Missing optional field in contained record inside union - template>
3602
3603 <COMPILE>
3604 <VERDICT_LEAF PASS>
3605 <MODULE TTCN Temp Temp.ttcn>
3606 module Temp {
3607
3608
3609 type record aTest  {integer i, bTest r}
3610 type record bTest  {integer i , charstring c optional}
3611
3612 type union uType {aTest a, bTest b}
3613
3614 template uType u := {a := {i := 1, r := {i:=2}}}
3615
3616 }
3617 <END_MODULE>
3618 <RESULT IF_PASS COUNT 0>
3619 (?is)\berror:
3620 <END_RESULT>
3621 <END_TC>
3622
3623 :exmp.
3624 .*---------------------------------------------------------------------*
3625 :h2.Value list notation for union and set
3626 .*---------------------------------------------------------------------*
3627
3628 .*---------------------------------------------------------------------*
3629 :h3.Value list notation for set - constant
3630 .*---------------------------------------------------------------------*
3631 :xmp tab=0.
3632
3633 <TC -  Value list notation for set - constant>
3634
3635 <COMPILE>
3636 <VERDICT_LEAF PASS>
3637 <MODULE TTCN Temp Temp.ttcn>
3638 module Temp {
3639
3640
3641 type set aTest  {integer i, bTest r}
3642 type set bTest  {integer i , charstring c optional}
3643
3644 const aTest con :=  {1, {i :=2, c := omit}}
3645
3646
3647 }
3648 <END_MODULE>
3649 <RESULT IF_PASS COUNT 1>
3650 (?im)error.+?Value.+?list.+?notation.+?cannot.+?be.+?used.+?for.+?set.+?type
3651 <END_RESULT>
3652 <RESULT IF_PASS COUNT 1>
3653 (?is)\berror:
3654 <END_RESULT>
3655 <END_TC>
3656
3657 :exmp.
3658
3659 .*---------------------------------------------------------------------*
3660 :h3.Value list notation for contained set - constant
3661 .*---------------------------------------------------------------------*
3662 :xmp tab=0.
3663
3664 <TC -  Value list notation for contained set - constant>
3665
3666 <COMPILE>
3667 <VERDICT_LEAF PASS>
3668 <MODULE TTCN Temp Temp.ttcn>
3669 module Temp {
3670
3671
3672 type record aTest  {integer i, bTest r}
3673 type set bTest  {integer i , charstring c optional}
3674
3675 const aTest con :=  {1, {2, omit}}
3676
3677
3678 }
3679 <END_MODULE>
3680 <RESULT IF_PASS COUNT 1>
3681 (?im)error.+?Value.+?list.+?notation.+?cannot.+?be.+?used.+?for.+?set.+?type
3682 <END_RESULT>
3683 <RESULT IF_PASS COUNT 1>
3684 (?is)\berror:
3685 <END_RESULT>
3686 <END_TC>
3687
3688 :exmp.
3689
3690 .*---------------------------------------------------------------------*
3691 :h3.Value list notation for contained set inside union - constant
3692 .*---------------------------------------------------------------------*
3693 :xmp tab=0.
3694
3695 <TC -  Value list notation for contained set inside union - constant>
3696
3697 <COMPILE>
3698 <VERDICT_LEAF PASS>
3699 <MODULE TTCN Temp Temp.ttcn>
3700 module Temp {
3701
3702 type set bTest  {integer i , charstring c optional}
3703 type union uTest {integer i, bTest b}
3704
3705 const uTest u :=  {b := {1, "bTest"}}
3706
3707
3708 }
3709 <END_MODULE>
3710 <RESULT IF_PASS COUNT 1>
3711 (?im)error.+?Value.+?list.+?notation.+?cannot.+?be.+?used.+?for.+?set.+?type
3712 <END_RESULT>
3713 <RESULT IF_PASS COUNT 1>
3714 (?is)\berror:
3715 <END_RESULT>
3716 <END_TC>
3717
3718 :exmp.
3719
3720 .*---------------------------------------------------------------------*
3721 :h3.Value list notation for set - template
3722 .*---------------------------------------------------------------------*
3723 :xmp tab=0.
3724
3725 <TC -  Value list notation for set - template>
3726
3727 <COMPILE>
3728 <VERDICT_LEAF PASS>
3729 <MODULE TTCN Temp Temp.ttcn>
3730 module Temp {
3731
3732
3733 type set aTest  {integer i, bTest r}
3734 type set bTest  {integer i , charstring c optional}
3735
3736 template aTest tem :=  {1, {i :=2, c := omit}}
3737
3738
3739 }
3740 <END_MODULE>
3741 <RESULT IF_PASS COUNT 1>
3742 (?im)error.+?Value.+?list.+?notation.+?not.+?allowed.+?for.+?set.+?type
3743 <END_RESULT>
3744 <RESULT IF_PASS COUNT 1>
3745 (?is)\berror:
3746 <END_RESULT>
3747 <END_TC>
3748
3749 :exmp.
3750
3751 .*---------------------------------------------------------------------*
3752 :h3.Value list notation for contained set - template
3753 .*---------------------------------------------------------------------*
3754 :xmp tab=0.
3755
3756 <TC -  Value list notation for contained set - template>
3757
3758 <COMPILE>
3759 <VERDICT_LEAF PASS>
3760 <MODULE TTCN Temp Temp.ttcn>
3761 module Temp {
3762
3763
3764 type record aTest  {integer i, bTest r}
3765 type set bTest  {integer i , charstring c optional}
3766
3767 template aTest tem :=  {1, {2, omit}}
3768
3769
3770 }
3771 <END_MODULE>
3772 <RESULT IF_PASS COUNT 1>
3773 (?im)error.+?Value.+?list.+?notation.+?not.+?allowed.+?for.+?set.+?type
3774 <END_RESULT>
3775 <RESULT IF_PASS COUNT 1>
3776 (?is)\berror:
3777 <END_RESULT>
3778 <END_TC>
3779
3780 :exmp.
3781
3782 .*---------------------------------------------------------------------*
3783 :h3.Value list notation for contained set inside union - template
3784 .*---------------------------------------------------------------------*
3785 :xmp tab=0.
3786
3787 <TC -  Value list notation for contained set inside union - template>
3788
3789 <COMPILE>
3790 <VERDICT_LEAF PASS>
3791 <MODULE TTCN Temp Temp.ttcn>
3792 module Temp {
3793
3794 type set bTest  {integer i , charstring c optional}
3795 type union uTest {integer i, bTest b}
3796
3797 template uTest u :=  {b := {1, "bTest"}}
3798
3799
3800 }
3801 <END_MODULE>
3802 <RESULT IF_PASS COUNT 1>
3803 (?im)error.+?Value.+?list.+?notation.+?not.+?allowed.+?for.+?set.+?type
3804 <END_RESULT>
3805 <RESULT IF_PASS COUNT 1>
3806 (?is)\berror:
3807 <END_RESULT>
3808 <END_TC>
3809
3810 :exmp.
3811 .*---------------------------------------------------------------------*
3812 :h2.More than one union element is specified
3813 .*---------------------------------------------------------------------*
3814
3815 .*---------------------------------------------------------------------*
3816 :h3.More than one element is defined in union - constant
3817 .*---------------------------------------------------------------------*
3818 :xmp tab=0.
3819
3820 <TC -  More than one element is defined in union - constant>
3821
3822 <COMPILE>
3823 <VERDICT_LEAF PASS>
3824 <MODULE TTCN Temp Temp.ttcn>
3825 module Temp {
3826
3827
3828 type union uTest {integer i, boolean b}
3829
3830 const uTest con := {i := 1, b := true}
3831
3832
3833 }
3834 <END_MODULE>
3835 <RESULT IF_PASS COUNT 1>
3836 (?im)error.+?Only.+?one.+?field.+?expected.+?in.+?union.+?value
3837 <END_RESULT>
3838 <RESULT IF_PASS COUNT 1>
3839 (?is)\berror:
3840 <END_RESULT>
3841 <END_TC>
3842
3843 :exmp.
3844
3845 .*---------------------------------------------------------------------*
3846 :h3.More than one element is defined in contained union - constant1
3847 .*---------------------------------------------------------------------*
3848 :xmp tab=0.
3849
3850 <TC -  More than one element is defined in contained union - constant1>
3851
3852 <COMPILE>
3853 <VERDICT_LEAF PASS>
3854 <MODULE TTCN Temp Temp.ttcn>
3855 module Temp {
3856
3857
3858 type record aTest  {integer i, uTest u}
3859 type union uTest {integer i, boolean b}
3860
3861 const aTest con:= { i := 1, u := {i := 1, b := true}}
3862
3863
3864 }
3865 <END_MODULE>
3866 <RESULT IF_PASS COUNT 1>
3867 (?im)error.+?Only.+?one.+?field.+?expected.+?in.+?union.+?value
3868 <END_RESULT>
3869 <RESULT IF_PASS COUNT 1>
3870 (?is)\berror:
3871 <END_RESULT>
3872 <END_TC>
3873
3874 :exmp.
3875
3876 .*---------------------------------------------------------------------*
3877 :h3.More than one element is defined in contained union - constant2
3878 .*---------------------------------------------------------------------*
3879 :xmp tab=0.
3880
3881 <TC -  More than one element is defined in contained union - constant2>
3882
3883 <COMPILE>
3884 <VERDICT_LEAF PASS>
3885 <MODULE TTCN Temp Temp.ttcn>
3886 module Temp {
3887
3888
3889 type record aTest  {integer i, cTest u}
3890 type union cTest {integer i, boolean b}
3891
3892 const aTest con := { i := 1, u := {i := 1, b := true, c := 2}}
3893
3894
3895 }
3896 <END_MODULE>
3897 <RESULT IF_PASS COUNT 1>
3898 (?im)error.+?Only.+?one.+?field.+?expected.+?in.+?union.+?value
3899 <END_RESULT>
3900 <RESULT IF_PASS COUNT 1>
3901 (?is)\berror:
3902 <END_RESULT>
3903 <END_TC>
3904
3905 :exmp.
3906
3907 .*---------------------------------------------------------------------*
3908 :h3.More than one element is defined in union - template
3909 .*---------------------------------------------------------------------*
3910 :xmp tab=0.
3911
3912 <TC -  More than one element is defined in union - template>
3913
3914 <COMPILE>
3915 <VERDICT_LEAF PASS>
3916 <MODULE TTCN Temp Temp.ttcn>
3917 module Temp {
3918
3919 type union uTest {integer i, boolean b}
3920
3921 template uTest tem := {i := 1, b := true}
3922
3923
3924 }
3925 <END_MODULE>
3926 <RESULT IF_PASS COUNT 1>
3927 (?im)error.+?template.+?for.+?union.+?type.+?must.+?contain.+?exactly.+?one.+?selected.+?field
3928 <END_RESULT>
3929 <RESULT IF_PASS COUNT 1>
3930 (?is)\berror:
3931 <END_RESULT>
3932 <END_TC>
3933
3934 :exmp.
3935
3936 .*---------------------------------------------------------------------*
3937 :h3.More than one element is defined in contained union - template
3938 .*---------------------------------------------------------------------*
3939 :xmp tab=0.
3940
3941 <TC -  More than one element is defined in contained union - template>
3942
3943 <COMPILE>
3944 <VERDICT_LEAF PASS>
3945 <MODULE TTCN Temp Temp.ttcn>
3946 module Temp {
3947
3948
3949 type record aTest  {integer i, uTest u}
3950 type union uTest {integer i, boolean b}
3951
3952 template aTest tem:= { i := 1, u := {i := 1, b := true}}
3953
3954
3955 }
3956 <END_MODULE>
3957 <RESULT IF_PASS COUNT 1>
3958 (?im)error.+?template.+?for.+?union.+?type.+?must.+?contain.+?exactly.+?one.+?selected.+?field
3959 <END_RESULT>
3960 <RESULT IF_PASS COUNT 1>
3961 (?is)\berror:
3962 <END_RESULT>
3963 <END_TC>
3964
3965 :exmp.
3966
3967 .*---------------------------------------------------------------------*
3968 :h3.More than one element is defined in contained union - template_2
3969 .*---------------------------------------------------------------------*
3970 :xmp tab=0.
3971
3972 <TC -  More than one element is defined in contained union - template_2>
3973
3974 <COMPILE>
3975 <VERDICT_LEAF PASS>
3976 <MODULE TTCN Temp Temp.ttcn>
3977 module Temp {
3978
3979
3980 type record aTest  {integer i, cTest u}
3981 type union cTest {integer i, boolean b}
3982
3983 template aTest tem := { i := 1, u := {i := 1, b := true, c := 2}}
3984
3985
3986 }
3987 <END_MODULE>
3988 <RESULT IF_PASS COUNT 1>
3989 (?im)error.+?template.+?for.+?union.+?type.+?must.+?contain.+?exactly.+?one.+?selected.+?field
3990 <END_RESULT>
3991 <RESULT IF_PASS COUNT 1>
3992 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?union.+?template
3993 <END_RESULT>
3994 <RESULT IF_PASS COUNT 2>
3995 (?is)\berror:
3996 <END_RESULT>
3997 <END_TC>
3998
3999 :exmp.
4000 .*---------------------------------------------------------------------*
4001 :h2.Missing fields in template
4002 .*---------------------------------------------------------------------*
4003
4004 .*---------------------------------------------------------------------*
4005 :h3.Missing field in template - set
4006 .*---------------------------------------------------------------------*
4007 :xmp tab=0.
4008
4009 <TC -  Missing field in template - set>
4010
4011 <COMPILE>
4012 <VERDICT_LEAF PASS>
4013 <MODULE TTCN Temp Temp.ttcn>
4014 module Temp {
4015
4016
4017 type set aTest  {integer i, bTest r}
4018 type set bTest  {integer i , charstring c}
4019
4020 template aTest tem := {i := 1}
4021
4022
4023 }
4024 <END_MODULE>
4025 <RESULT IF_PASS COUNT 0>
4026 (?is)\berror:
4027 <END_RESULT>
4028 <END_TC>
4029
4030 :exmp.
4031
4032 .*---------------------------------------------------------------------*
4033 :h3.Missing field in template - record
4034 .*---------------------------------------------------------------------*
4035 :xmp tab=0.
4036
4037 <TC -  Missing field in template - record>
4038
4039 <COMPILE>
4040 <VERDICT_LEAF PASS>
4041 <MODULE TTCN Temp Temp.ttcn>
4042 module Temp {
4043
4044
4045 type record aTest  {integer i, bTest r}
4046 type record bTest  {integer i , charstring c}
4047
4048 template aTest tem := {i:= 1}
4049
4050
4051 }
4052 <END_MODULE>
4053 <RESULT IF_PASS COUNT 0>
4054 (?is)\berror:
4055 <END_RESULT>
4056 <END_TC>
4057
4058 :exmp.
4059
4060 .*---------------------------------------------------------------------*
4061 :h3.Missing field in template - contained set
4062 .*---------------------------------------------------------------------*
4063 :xmp tab=0.
4064
4065 <TC -  Missing field in template - contained set>
4066
4067 <COMPILE>
4068 <VERDICT_LEAF PASS>
4069 <MODULE TTCN Temp Temp.ttcn>
4070 module Temp {
4071
4072
4073 type set aTest  {integer i, bTest r}
4074 type set bTest  {integer i , charstring c}
4075
4076 template aTest tem := {i := 1, r := {i := 2}}
4077
4078
4079 }
4080 <END_MODULE>
4081 <RESULT IF_PASS COUNT 0>
4082 (?is)\berror:
4083 <END_RESULT>
4084 <END_TC>
4085
4086 :exmp.
4087
4088 .*---------------------------------------------------------------------*
4089 :h3.Missing field in template - contained record
4090 .*---------------------------------------------------------------------*
4091 :xmp tab=0.
4092
4093 <TC -  Missing field in template - contained record>
4094
4095 <COMPILE>
4096 <VERDICT_LEAF PASS>
4097 <MODULE TTCN Temp Temp.ttcn>
4098 module Temp {
4099
4100
4101 type record aTest  {integer i, bTest r}
4102 type record bTest  {integer i , charstring c}
4103
4104 template aTest tem := {i := 1, r := {i := 2}}
4105
4106
4107 }
4108 <END_MODULE>
4109 <RESULT IF_PASS COUNT 0>
4110 (?is)\berror:
4111 <END_RESULT>
4112 <END_TC>
4113
4114 :exmp.
4115
4116 .*---------------------------------------------------------------------*
4117 :h3.Missing field in union template - contained set
4118 .*---------------------------------------------------------------------*
4119 :xmp tab=0.
4120
4121 <TC -  Missing field in union template - contained set>
4122
4123 <COMPILE>
4124 <VERDICT_LEAF PASS>
4125 <MODULE TTCN Temp Temp.ttcn>
4126 module Temp {
4127
4128
4129 type set aTest  {integer i, bTest r}
4130 type set bTest  {integer i , charstring c}
4131 type union uTest {aTest a, bTest b}
4132
4133 template uTest tem := { a := {i := 1, r := { i:= 2}}}
4134
4135
4136 }
4137 <END_MODULE>
4138 <RESULT IF_PASS COUNT 0>
4139 (?is)\berror:
4140 <END_RESULT>
4141 <END_TC>
4142
4143 :exmp.
4144
4145 .*---------------------------------------------------------------------*
4146 :h3.Missing field in union template - contained record
4147 .*---------------------------------------------------------------------*
4148 :xmp tab=0.
4149
4150 <TC -  Missing field in union template - contained record>
4151
4152 <COMPILE>
4153 <VERDICT_LEAF PASS>
4154 <MODULE TTCN Temp Temp.ttcn>
4155 module Temp {
4156
4157
4158 type record aTest  {integer i, bTest r}
4159 type record bTest  {integer i , charstring c}
4160 type union uTest {aTest a, bTest b}
4161
4162 template uTest tem := { a := {i := 1, r := { i:= 2}}}
4163
4164
4165 }
4166 <END_MODULE>
4167 <RESULT IF_PASS COUNT 0>
4168 (?is)\berror:
4169 <END_RESULT>
4170 <END_TC>
4171
4172 :exmp.
4173
4174 .*---------------------------------------------------------------------*
4175 :h3.Missing field in template - set of
4176 .*---------------------------------------------------------------------*
4177 :xmp tab=0.
4178
4179 <TC -  Missing field in template - set of>
4180
4181 <COMPILE>
4182 <VERDICT_LEAF PASS>
4183 <MODULE TTCN Temp Temp.ttcn>
4184 module Temp {
4185
4186
4187 type set of integer aTest;
4188
4189 template aTest tem := {1, -, 3}
4190
4191
4192 }
4193 <END_MODULE>
4194 <RESULT IF_PASS COUNT 0>
4195 (?is)\berror:
4196 <END_RESULT>
4197 <END_TC>
4198
4199 :exmp.
4200
4201 .*---------------------------------------------------------------------*
4202 :h3.Missing field in template - record of
4203 .*---------------------------------------------------------------------*
4204 :xmp tab=0.
4205
4206 <TC -  Missing field in template - record of>
4207
4208 <COMPILE>
4209 <VERDICT_LEAF PASS>
4210 <MODULE TTCN Temp Temp.ttcn>
4211 module Temp {
4212
4213
4214 type record of integer aTest;
4215
4216 template aTest tem := {-, 2, 3}
4217
4218
4219 }
4220 <END_MODULE>
4221 <RESULT IF_PASS COUNT 0>
4222 (?is)\berror:
4223 <END_RESULT>
4224 <END_TC>
4225
4226 :exmp.
4227 .*---------------------------------------------------------------------*
4228 :h2.Missing optional fields in template
4229 .*---------------------------------------------------------------------*
4230
4231 .*---------------------------------------------------------------------*
4232 :h3.Missing optional field in template - set
4233 .*---------------------------------------------------------------------*
4234 :xmp tab=0.
4235
4236 <TC -  Missing optional field in template - set>
4237
4238 <COMPILE>
4239 <VERDICT_LEAF PASS>
4240 <MODULE TTCN Temp Temp.ttcn>
4241 module Temp {
4242
4243
4244 type set aTest  {integer i, charstring c, bTest r optional}
4245 type set bTest  {integer i , charstring c}
4246
4247 template aTest tem := { c := "aTest", i := 1}
4248
4249
4250 }
4251 <END_MODULE>
4252 <RESULT IF_PASS COUNT 0>
4253 (?is)\berror:
4254 <END_RESULT>
4255 <END_TC>
4256
4257 :exmp.
4258
4259 .*---------------------------------------------------------------------*
4260 :h3.Missing optional field in template - contained set
4261 .*---------------------------------------------------------------------*
4262 :xmp tab=0.
4263
4264 <TC -  Missing optional field in template - contained set>
4265
4266 <COMPILE>
4267 <VERDICT_LEAF PASS>
4268 <MODULE TTCN Temp Temp.ttcn>
4269 module Temp {
4270
4271
4272 type set aTest  {integer i, bTest r}
4273 type set bTest  {integer i , charstring c optional}
4274
4275 template aTest tem := { i := 1, r := {i := 1}}
4276
4277
4278 }
4279 <END_MODULE>
4280 <RESULT IF_PASS COUNT 0>
4281 (?is)\berror:
4282 <END_RESULT>
4283 <END_TC>
4284
4285 :exmp.
4286
4287 .*---------------------------------------------------------------------*
4288 :h3.Missing optional field in template - record
4289 .*---------------------------------------------------------------------*
4290 :xmp tab=0.
4291
4292 <TC -  Missing optional field in template - record>
4293
4294 <COMPILE>
4295 <VERDICT_LEAF PASS>
4296 <MODULE TTCN Temp Temp.ttcn>
4297 module Temp {
4298
4299
4300 type record aTest  {integer i, bTest r optional}
4301 type set bTest  {integer i , charstring c}
4302
4303 template aTest tem := { i := 1}
4304
4305
4306 }
4307 <END_MODULE>
4308 <RESULT IF_PASS COUNT 0>
4309 (?is)\berror:
4310 <END_RESULT>
4311 <END_TC>
4312
4313 :exmp.
4314
4315 .*---------------------------------------------------------------------*
4316 :h3.Missing optional field in template - contained record
4317 .*---------------------------------------------------------------------*
4318 :xmp tab=0.
4319
4320 <TC -  Missing optional field in template - contained record>
4321
4322 <COMPILE>
4323 <VERDICT_LEAF PASS>
4324 <MODULE TTCN Temp Temp.ttcn>
4325 module Temp {
4326
4327
4328 type record aTest  {integer i, bTest r}
4329 type record bTest  {integer i , charstring c optional}
4330
4331 template aTest tem := { i := 1, r := {i := 2}}
4332
4333
4334 }
4335 <END_MODULE>
4336 <RESULT IF_PASS COUNT 0>
4337 (?is)\berror:
4338 <END_RESULT>
4339 <END_TC>
4340
4341 :exmp.
4342
4343 .*---------------------------------------------------------------------*
4344 :h3.Missing optional field in template inside union - record
4345 .*---------------------------------------------------------------------*
4346 :xmp tab=0.
4347
4348 <TC -  Missing optional field in template inside union - record>
4349
4350 <COMPILE>
4351 <VERDICT_LEAF PASS>
4352 <MODULE TTCN Temp Temp.ttcn>
4353 module Temp {
4354
4355
4356 type record aTest  {integer i, bTest r optional}
4357 type record bTest  {integer i , charstring c}
4358 type union cTest {aTest a, bTest b}
4359
4360 template cTest tem := { a := {i := 1}}
4361
4362
4363 }
4364 <END_MODULE>
4365 <RESULT IF_PASS COUNT 0>
4366 (?is)\berror:
4367 <END_RESULT>
4368 <END_TC>
4369
4370 :exmp.
4371
4372 .*---------------------------------------------------------------------*
4373 :h3.Missing optional field in template inside union - contained record
4374 .*---------------------------------------------------------------------*
4375 :xmp tab=0.
4376
4377 <TC -  Missing optional field in template inside union - contained record>
4378
4379 <COMPILE>
4380 <VERDICT_LEAF PASS>
4381 <MODULE TTCN Temp Temp.ttcn>
4382 module Temp {
4383
4384
4385 type record aTest  {integer i, bTest r}
4386 type record bTest  {integer i , charstring c optional}
4387 type union cTest {aTest a, bTest b}
4388
4389 template cTest tem := { a := {i := 1, r :={i := 2}}}
4390
4391
4392 }
4393 <END_MODULE>
4394 <RESULT IF_PASS COUNT 0>
4395 (?is)\berror:
4396 <END_RESULT>
4397 <END_TC>
4398
4399 :exmp.
4400
4401 .*---------------------------------------------------------------------*
4402 :h3.Missing optional field in template inside union - set
4403 .*---------------------------------------------------------------------*
4404 :xmp tab=0.
4405
4406 <TC -  Missing optional field in template inside union - set>
4407
4408 <COMPILE>
4409 <VERDICT_LEAF PASS>
4410 <MODULE TTCN Temp Temp.ttcn>
4411 module Temp {
4412
4413
4414 type set aTest  {integer i, bTest r optional}
4415 type set bTest  {integer i , charstring c}
4416 type union cTest {aTest a, bTest b}
4417
4418 template cTest tem := { a := {i := 1}}
4419
4420
4421 }
4422 <END_MODULE>
4423 <RESULT IF_PASS COUNT 0>
4424 (?is)\berror:
4425 <END_RESULT>
4426 <END_TC>
4427
4428 :exmp.
4429
4430 .*---------------------------------------------------------------------*
4431 :h3.Missing optional field in template inside union - contained set
4432 .*---------------------------------------------------------------------*
4433 :xmp tab=0.
4434
4435 <TC -  Missing optional field in template inside union - contained set>
4436
4437 <COMPILE>
4438 <VERDICT_LEAF PASS>
4439 <MODULE TTCN Temp Temp.ttcn>
4440 module Temp {
4441
4442
4443 type set aTest  {integer i, bTest r}
4444 type set bTest  {integer i , charstring c optional}
4445 type union cTest {aTest a, bTest b}
4446
4447 template cTest tem := { a := {i := 1, r :={i := 2}}}
4448
4449
4450 }
4451 <END_MODULE>
4452 <RESULT IF_PASS COUNT 0>
4453 (?is)\berror:
4454 <END_RESULT>
4455 <END_TC>
4456
4457 :exmp.
4458
4459 .*---------------------------------------------------------------------*
4460 :h3.Missing optional field in template inside record of
4461 .*---------------------------------------------------------------------*
4462 :xmp tab=0.
4463
4464 <TC -  Missing optional field in template inside record of>
4465
4466 <COMPILE>
4467 <VERDICT_LEAF PASS>
4468 <MODULE TTCN Temp Temp.ttcn>
4469 module Temp {
4470
4471
4472 type record of bTest aTest;
4473 type record bTest  {integer i , charstring c optional}
4474
4475 template aTest tem := {{1,"bTest"},{i:=2}}
4476
4477
4478 }
4479 <END_MODULE>
4480 <RESULT IF_PASS COUNT 0>
4481 (?is)\berror:
4482 <END_RESULT>
4483 <END_TC>
4484
4485 :exmp.
4486
4487 .*---------------------------------------------------------------------*
4488 :h3.Missing optional field in template inside set of
4489 .*---------------------------------------------------------------------*
4490 :xmp tab=0.
4491
4492 <TC -  Missing optional field in template inside set of >
4493
4494 <COMPILE>
4495 <VERDICT_LEAF PASS>
4496 <MODULE TTCN Temp Temp.ttcn>
4497 module Temp {
4498
4499
4500 type set of bTest aTest;
4501 type set bTest  {integer i , charstring c optional}
4502
4503 template aTest tem := {{i := 1, c := "bTest"},{i := 2}}
4504
4505
4506 }
4507 <END_MODULE>
4508 <RESULT IF_PASS COUNT 0>
4509 (?is)\berror:
4510 <END_RESULT>
4511 <END_TC>
4512
4513 :exmp.
4514 .*---------------------------------------------------------------------*
4515 :h2.Omitted mandatory field in template
4516 .*---------------------------------------------------------------------*
4517
4518 .*---------------------------------------------------------------------*
4519 :h3.Omitted mandatory field in template - record
4520 .*---------------------------------------------------------------------*
4521 :xmp tab=0.
4522
4523 <TC -  Omitted mandatory field in template - record>
4524
4525 <COMPILE>
4526 <VERDICT_LEAF PASS>
4527 <MODULE TTCN Temp Temp.ttcn>
4528 module Temp {
4529
4530
4531 type record aTest  {integer i, bTest r optional}
4532 type record bTest  {integer i , charstring c optional}
4533
4534 template aTest tem := { i := omit, r := {i := 2, c := omit}}
4535
4536
4537 }
4538 <END_MODULE>
4539 <RESULT IF_PASS COUNT 1>
4540 (?im)error.+?omit.+?not.+?allowed.+?context
4541 <END_RESULT>
4542 <RESULT IF_PASS COUNT 1>
4543 (?is)\berror:
4544 <END_RESULT>
4545 <END_TC>
4546
4547 :exmp.
4548
4549 .*---------------------------------------------------------------------*
4550 :h3.Omitted mandatory field in template - set
4551 .*---------------------------------------------------------------------*
4552 :xmp tab=0.
4553
4554 <TC -  Omitted mandatory field in template - set>
4555
4556 <COMPILE>
4557 <VERDICT_LEAF PASS>
4558 <MODULE TTCN Temp Temp.ttcn>
4559 module Temp {
4560
4561
4562 type set aTest  {integer i, bTest r optional}
4563 type set bTest  {integer i , charstring c optional}
4564
4565 template aTest tem := { i := omit, r := {i := 2, c := "bTest"}}
4566
4567
4568 }
4569 <END_MODULE>
4570 <RESULT IF_PASS COUNT 1>
4571 (?im)error.+?omit.+?not.+?allowed.+?context
4572 <END_RESULT>
4573 <RESULT IF_PASS COUNT 1>
4574 (?is)\berror:
4575 <END_RESULT>
4576 <END_TC>
4577
4578 :exmp.
4579
4580 .*---------------------------------------------------------------------*
4581 :h3.Omitted mandatory field in template - contained record
4582 .*---------------------------------------------------------------------*
4583 :xmp tab=0.
4584
4585 <TC -  Omitted mandatory field in template - contained record>
4586
4587 <COMPILE>
4588 <VERDICT_LEAF PASS>
4589 <MODULE TTCN Temp Temp.ttcn>
4590 module Temp {
4591
4592
4593 type set aTest  {integer i, bTest r}
4594 type record bTest  {integer i , charstring c optional}
4595
4596 template aTest tem := {i := 1, r := {i := omit, c := omit}}
4597
4598
4599 }
4600 <END_MODULE>
4601 <RESULT IF_PASS COUNT 1>
4602 (?im)error.+?omit.+?not.+?allowed.+?context
4603 <END_RESULT>
4604 <RESULT IF_PASS COUNT 1>
4605 (?is)\berror:
4606 <END_RESULT>
4607 <END_TC>
4608
4609 :exmp.
4610
4611 .*---------------------------------------------------------------------*
4612 :h3.Omitted mandatory field in template - contained set
4613 .*---------------------------------------------------------------------*
4614 :xmp tab=0.
4615
4616 <TC -  Omitted mandatory field in template - contained set>
4617
4618 <COMPILE>
4619 <VERDICT_LEAF PASS>
4620 <MODULE TTCN Temp Temp.ttcn>
4621 module Temp {
4622
4623
4624 type record aTest  {integer i, bTest r}
4625 type set bTest  {integer i , charstring c optional}
4626
4627 template aTest tem := { i := 1, r := {i := omit, c := omit}}
4628
4629
4630 }
4631 <END_MODULE>
4632 <RESULT IF_PASS COUNT 1>
4633 (?im)error.+?omit.+?not.+?allowed.+?context
4634 <END_RESULT>
4635 <RESULT IF_PASS COUNT 1>
4636 (?is)\berror:
4637 <END_RESULT>
4638 <END_TC>
4639
4640 :exmp.
4641
4642 .*---------------------------------------------------------------------*
4643 :h3.Omitted mandatory field in record of template
4644 .*---------------------------------------------------------------------*
4645 :xmp tab=0.
4646
4647 <TC -  Omitted mandatory field in record of template >
4648
4649 <COMPILE>
4650 <VERDICT_LEAF PASS>
4651 <MODULE TTCN Temp Temp.ttcn>
4652 module Temp {
4653
4654
4655 type record of bTest aTest;
4656 type record bTest  {integer i , charstring c optional}
4657
4658 template aTest tem := { {1, omit}, {omit, "bTest"}}
4659
4660
4661 }
4662 <END_MODULE>
4663 <RESULT IF_PASS COUNT 1>
4664 (?im)error.+?omit.+?not.+?allowed.+?context
4665 <END_RESULT>
4666 <RESULT IF_PASS COUNT 1>
4667 (?is)\berror:
4668 <END_RESULT>
4669 <END_TC>
4670
4671 :exmp.
4672
4673 .*---------------------------------------------------------------------*
4674 :h3.Omitted mandatory field in set of template
4675 .*---------------------------------------------------------------------*
4676 :xmp tab=0.
4677
4678 <TC -  Omitted mandatory field in set of template>
4679
4680 <COMPILE>
4681 <VERDICT_LEAF PASS>
4682 <MODULE TTCN Temp Temp.ttcn>
4683 module Temp {
4684
4685
4686 type set of bTest aTest;
4687 type record bTest  {integer i , charstring c optional}
4688
4689 template aTest tem := { {i := 1, c :=  omit}, {i := omit, c := "bTest"}}
4690
4691 }
4692 <END_MODULE>
4693 <RESULT IF_PASS COUNT 1>
4694 (?im)error.+?omit.+?not.+?allowed.+?context
4695 <END_RESULT>
4696 <RESULT IF_PASS COUNT 1>
4697 (?is)\berror:
4698 <END_RESULT>
4699 <END_TC>
4700
4701 :exmp.
4702
4703 .*---------------------------------------------------------------------*
4704 :h3.Omitted mandatory field in union template
4705 .*---------------------------------------------------------------------*
4706 :xmp tab=0.
4707
4708 <TC -  Omitted mandatory field in union template>
4709
4710 <COMPILE>
4711 <VERDICT_LEAF PASS>
4712 <MODULE TTCN Temp Temp.ttcn>
4713 module Temp {
4714
4715
4716 type union cTest {integer i, boolean b}
4717
4718 template cTest tem := {i := omit}
4719
4720 }
4721 <END_MODULE>
4722 <RESULT IF_PASS COUNT 1>
4723 (?im)error.+?omit.+?value.+?not.+?allowed
4724 <END_RESULT>
4725 <RESULT IF_PASS COUNT 1>
4726 (?is)\berror:
4727 <END_RESULT>
4728 <END_TC>
4729
4730 :exmp.
4731
4732 .*---------------------------------------------------------------------*
4733 :h3.Omitted mandatory field in union template - record
4734 .*---------------------------------------------------------------------*
4735 :xmp tab=0.
4736
4737 <TC -  Omitted mandatory field in union template - record>
4738
4739 <COMPILE>
4740 <VERDICT_LEAF PASS>
4741 <MODULE TTCN Temp Temp.ttcn>
4742 module Temp {
4743
4744
4745 type record aTest  {integer i, bTest r}
4746 type record bTest  {integer i , charstring c optional}
4747 type union cTest {aTest a, bTest b}
4748
4749 template cTest tem := {a := { i := omit, r := {2, "bTest"}}}
4750
4751
4752 }
4753 <END_MODULE>
4754 <RESULT IF_PASS COUNT 1>
4755 (?im)error.+?omit.+?not.+?allowed.+?context
4756 <END_RESULT>
4757 <RESULT IF_PASS COUNT 1>
4758 (?is)\berror:
4759 <END_RESULT>
4760 <END_TC>
4761
4762 :exmp.
4763
4764 .*---------------------------------------------------------------------*
4765 :h3.Omitted mandatory field in union template - set
4766 .*---------------------------------------------------------------------*
4767 :xmp tab=0.
4768
4769 <TC -  Omitted mandatory field in union template - set>
4770
4771 <COMPILE>
4772 <VERDICT_LEAF PASS>
4773 <MODULE TTCN Temp Temp.ttcn>
4774 module Temp {
4775
4776
4777 type set aTest  {integer i, bTest r}
4778 type record bTest  {integer i , charstring c optional}
4779 type union cTest {aTest a, bTest b}
4780
4781 template cTest tem := {a := { i := omit, r := {2, "bTest"}}}
4782
4783
4784 }
4785 <END_MODULE>
4786 <RESULT IF_PASS COUNT 1>
4787 (?im)error.+?omit.+?not.+?allowed.+?context
4788 <END_RESULT>
4789 <RESULT IF_PASS COUNT 1>
4790 (?is)\berror:
4791 <END_RESULT>
4792 <END_TC>
4793
4794 :exmp.
4795
4796 .*---------------------------------------------------------------------*
4797 :h3.Omitted mandatory field in union template - contained record
4798 .*---------------------------------------------------------------------*
4799 :xmp tab=0.
4800
4801 <TC -  Omitted mandatory field in union template - contained record>
4802
4803 <COMPILE>
4804 <VERDICT_LEAF PASS>
4805 <MODULE TTCN Temp Temp.ttcn>
4806 module Temp {
4807
4808
4809 type set aTest  {integer i, bTest r}
4810 type record bTest  {integer i , charstring c optional}
4811 type union cTest {aTest a, bTest b}
4812
4813 template cTest tem := {a := { i := 1, r := {omit, "bTest"}}}
4814
4815
4816 }
4817 <END_MODULE>
4818 <RESULT IF_PASS COUNT 1>
4819 (?im)error.+?omit.+?not.+?allowed.+?context
4820 <END_RESULT>
4821 <RESULT IF_PASS COUNT 1>
4822 (?is)\berror:
4823 <END_RESULT>
4824 <END_TC>
4825
4826 :exmp.
4827
4828 .*---------------------------------------------------------------------*
4829 :h3.Omitted mandatory field in union template - contained set
4830 .*---------------------------------------------------------------------*
4831 :xmp tab=0.
4832
4833 <TC -  Omitted mandatory field in union template - contained set>
4834
4835 <COMPILE>
4836 <VERDICT_LEAF PASS>
4837 <MODULE TTCN Temp Temp.ttcn>
4838 module Temp {
4839
4840
4841 type record aTest  {integer i, bTest r}
4842 type set bTest  {integer i , charstring c optional}
4843 type union cTest {aTest a, bTest b}
4844
4845 template cTest tem := {a := { i := 1, r := { i := omit, c := omit}}}
4846
4847
4848 }
4849 <END_MODULE>
4850 <RESULT IF_PASS COUNT 1>
4851 (?im)error.+?omit.+?not.+?allowed.+?context
4852 <END_RESULT>
4853 <RESULT IF_PASS COUNT 1>
4854 (?is)\berror:
4855 <END_RESULT>
4856 <END_TC>
4857
4858 :exmp.
4859
4860 .*---------------------------------------------------------------------*
4861 :h3.Omitted mandatory field in modified union template
4862 .*---------------------------------------------------------------------*
4863 :xmp tab=0.
4864
4865 <TC -  Omitted mandatory field in modified union template>
4866
4867 <COMPILE>
4868 <VERDICT_LEAF PASS>
4869 <MODULE TTCN Temp Temp.ttcn>
4870 module Temp {
4871
4872
4873 type record aTest  {integer i, bTest r optional}
4874 type record bTest  {integer i , charstring c optional}
4875
4876 template aTest tem := { i := 1, r := {i := 2, c := omit}}
4877 template aTest tem1 modifies tem := { r := { i := omit, c := "bTest"}}
4878
4879
4880 }
4881 <END_MODULE>
4882 <RESULT IF_PASS COUNT 1>
4883 (?im)error.+?omit.+?not.+?allowed.+?context
4884 <END_RESULT>
4885 <RESULT IF_PASS COUNT 1>
4886 (?is)\berror:
4887 <END_RESULT>
4888 <END_TC>
4889
4890 :exmp.
4891
4892 .*---------------------------------------------------------------------*
4893 :h2.Order mismatch in record template
4894 .*---------------------------------------------------------------------*
4895
4896 .*---------------------------------------------------------------------*
4897 :h3.Order mismatch in a record template - record
4898 .*---------------------------------------------------------------------*
4899 :xmp tab=0.
4900
4901 <TC -  Order mismatch in a record template - record>
4902
4903 <COMPILE>
4904 <VERDICT_LEAF PASS>
4905 <MODULE TTCN Temp Temp.ttcn>
4906 module Temp {
4907
4908
4909 type record aTest  {integer i, bTest r}
4910 type record bTest  {integer i , charstring c optional}
4911
4912 template aTest tem := {r := {i := 2, c := omit}, i := 1 }
4913
4914
4915 }
4916 <END_MODULE>
4917 <RESULT IF_PASS COUNT 1>
4918 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?template.+?record.+?type
4919 <END_RESULT>
4920 <RESULT IF_PASS COUNT 1>
4921 (?is)\berror:
4922 <END_RESULT>
4923 <END_TC>
4924
4925 :exmp.
4926
4927 .*---------------------------------------------------------------------*
4928 :h3.Order mismatch in a record template - contained record
4929 .*---------------------------------------------------------------------*
4930 :xmp tab=0.
4931
4932 <TC -  Order mismatch in a record template - contained record>
4933
4934 <COMPILE>
4935 <VERDICT_LEAF PASS>
4936 <MODULE TTCN Temp Temp.ttcn>
4937 module Temp {
4938
4939
4940 type record aTest  {integer i, bTest r}
4941 type record bTest  {integer i , charstring c optional}
4942
4943 template aTest tem := { i := 1, r := {c := omit, i := 2}}
4944
4945
4946 }
4947 <END_MODULE>
4948 <RESULT IF_PASS COUNT 1>
4949 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?template.+?record.+?type
4950 <END_RESULT>
4951 <RESULT IF_PASS COUNT 1>
4952 (?is)\berror:
4953 <END_RESULT>
4954 <END_TC>
4955
4956 :exmp.
4957
4958 .*---------------------------------------------------------------------*
4959 :h3.Order mismatch in a record template - record in union
4960 .*---------------------------------------------------------------------*
4961 :xmp tab=0.
4962
4963 <TC -  Order mismatch in a record template - record in union>
4964
4965 <COMPILE>
4966 <VERDICT_LEAF PASS>
4967 <MODULE TTCN Temp Temp.ttcn>
4968 module Temp {
4969
4970
4971 type record aTest  {integer i, charstring c, bTest r optional}
4972 type record bTest  {integer i , charstring c optional}
4973 type union cTest {aTest a, bTest b}
4974
4975 template cTest tem := {a := {r := {i := 2, c := omit}, i := 1}}
4976
4977
4978 }
4979 <END_MODULE>
4980 <RESULT IF_PASS COUNT 1>
4981 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?template.+?record.+?type
4982 <END_RESULT>
4983 <RESULT IF_PASS COUNT 1>
4984 (?is)\berror:
4985 <END_RESULT>
4986 <END_TC>
4987
4988 :exmp.
4989
4990 .*---------------------------------------------------------------------*
4991 :h3.Order mismatch in a record template - contained record in union
4992 .*---------------------------------------------------------------------*
4993 :xmp tab=0.
4994
4995 <TC -  Order mismatch in a record template - contained record in union>
4996
4997 <COMPILE>
4998 <VERDICT_LEAF PASS>
4999 <MODULE TTCN Temp Temp.ttcn>
5000 module Temp {
5001
5002
5003 type record aTest  {integer i, bTest r }
5004 type record bTest  {integer i , charstring c optional}
5005 type union cTest {aTest a, bTest b}
5006
5007 template cTest tem := {a := { i := omit, r := {c := omit, i := 2}}}
5008
5009
5010 }
5011 <END_MODULE>
5012 <RESULT IF_PASS COUNT 1>
5013 (?im)error.+?omit.+?not.+?allowed.+?context
5014 <END_RESULT>
5015 <RESULT IF_PASS COUNT 1>
5016 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?template.+?record.+?type
5017 <END_RESULT>
5018 <<RESULT IF_PASS COUNT 2>
5019 (?is)\berror:
5020 <END_RESULT>
5021 <END_TC>
5022
5023 :exmp.
5024 .*---------------------------------------------------------------------*
5025 :h2.non-existent or duplicate field in template
5026 .*---------------------------------------------------------------------*
5027
5028 .*---------------------------------------------------------------------*
5029 :h3.Duplicate field in template - record
5030 .*---------------------------------------------------------------------*
5031 :xmp tab=0.
5032
5033 <TC -  Duplicate field in template - record>
5034
5035 <COMPILE>
5036 <VERDICT_LEAF PASS>
5037 <MODULE TTCN Temp Temp.ttcn>
5038 module Temp {
5039
5040
5041 type record aTest  {integer i, bTest r}
5042 type record bTest  {integer i , charstring c optional}
5043
5044 template aTest tem := {i := 1, r := {i := 2, c := omit}, i := 3}
5045
5046
5047 }
5048 <END_MODULE>
5049 <RESULT IF_PASS COUNT 1>
5050 (?im)error.+?Duplicate.+?record.+?field
5051 <END_RESULT>
5052 <RESULT IF_PASS COUNT 1>
5053 (?im)note.+?Field.+?is.+?already.+?given.+?here
5054 <END_RESULT>
5055 <<RESULT IF_PASS COUNT 1>
5056 (?is)\berror:
5057 <END_RESULT>
5058 <END_TC>
5059
5060 :exmp.
5061
5062 .*---------------------------------------------------------------------*
5063 :h3.Duplicate field in template - set
5064 .*---------------------------------------------------------------------*
5065 :xmp tab=0.
5066
5067 <TC -  Duplicate field in template - set>
5068
5069 <COMPILE>
5070 <VERDICT_LEAF PASS>
5071 <MODULE TTCN Temp Temp.ttcn>
5072 module Temp {
5073
5074
5075 type set aTest  {integer i, bTest r}
5076 type set bTest  {integer i , charstring c optional}
5077
5078 template aTest tem := {i := 1, r := {i := 2, c := omit}, i := 3}
5079
5080 }
5081 <END_MODULE>
5082 <RESULT IF_PASS COUNT 1>
5083 (?im)error.+?Duplicate.+?set.+?field
5084 <END_RESULT>
5085 <RESULT IF_PASS COUNT 1>
5086 (?im)note.+?Field.+?is.+?already.+?given.+?here
5087 <END_RESULT>
5088 <<RESULT IF_PASS COUNT 1>
5089 (?is)\berror:
5090 <END_RESULT>
5091 <END_TC>
5092
5093 :exmp.
5094
5095 .*---------------------------------------------------------------------*
5096 :h3.Duplicate field in template - contained record
5097 .*---------------------------------------------------------------------*
5098 :xmp tab=0.
5099
5100 <TC -  Duplicate field in template - contained record>
5101
5102 <COMPILE>
5103 <VERDICT_LEAF PASS>
5104 <MODULE TTCN Temp Temp.ttcn>
5105 module Temp {
5106
5107
5108 type set aTest  {integer i, bTest r}
5109 type record bTest  {integer i , charstring c optional}
5110
5111 template aTest tem := {i := 1, r := {i := 2, c := omit, i := 3}}
5112
5113 }
5114 <END_MODULE>
5115 <RESULT IF_PASS COUNT 1>
5116 (?im)error.+?Duplicate.+?record.+?field
5117 <END_RESULT>
5118 <RESULT IF_PASS COUNT 1>
5119 (?im)note.+?Field.+?is.+?already.+?given.+?here
5120 <END_RESULT>
5121 <<RESULT IF_PASS COUNT 1>
5122 (?is)\berror:
5123 <END_RESULT>
5124 <END_TC>
5125
5126 :exmp.
5127
5128 .*---------------------------------------------------------------------*
5129 :h3.Duplicate field in template - contained set
5130 .*---------------------------------------------------------------------*
5131 :xmp tab=0.
5132
5133 <TC -  Duplicate field in template - contained set>
5134
5135 <COMPILE>
5136 <VERDICT_LEAF PASS>
5137 <MODULE TTCN Temp Temp.ttcn>
5138 module Temp {
5139
5140
5141 type record aTest  {integer i, bTest r}
5142 type set bTest  {integer i , charstring c optional}
5143
5144 template aTest tem := {i := 1, r := {c := omit, i := 2, i := 3}}
5145
5146 }
5147 <END_MODULE>
5148 <RESULT IF_PASS COUNT 1>
5149 (?im)error.+?Duplicate.+?set.+?field
5150 <END_RESULT>
5151 <RESULT IF_PASS COUNT 1>
5152 (?im)note.+?Field.+?is.+?already.+?given.+?here
5153 <END_RESULT>
5154 <<RESULT IF_PASS COUNT 1>
5155 (?is)\berror:
5156 <END_RESULT>
5157 <END_TC>
5158
5159 :exmp.
5160
5161 .*---------------------------------------------------------------------*
5162 :h3.non-existent field in template - record
5163 .*---------------------------------------------------------------------*
5164 :xmp tab=0.
5165
5166 <TC -  non-existent field in template - record>
5167
5168 <COMPILE>
5169 <VERDICT_LEAF PASS>
5170 <MODULE TTCN Temp Temp.ttcn>
5171 module Temp {
5172
5173
5174 type record aTest  {integer i, bTest r}
5175 type record bTest  {integer i , charstring c optional}
5176
5177 template aTest tem := {i := 1, r := {i := 2, c := omit}, n := 3}
5178
5179
5180 }
5181 <END_MODULE>
5182 <RESULT IF_PASS COUNT 1>
5183 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?record.+?template
5184 <END_RESULT>
5185 <<RESULT IF_PASS COUNT 1>
5186 (?is)\berror:
5187 <END_RESULT>
5188 <END_TC>
5189
5190 :exmp.
5191
5192 .*---------------------------------------------------------------------*
5193 :h3.non-existent field in template - set
5194 .*---------------------------------------------------------------------*
5195 :xmp tab=0.
5196
5197 <TC -  non-existent field in template - set>
5198
5199 <COMPILE>
5200 <VERDICT_LEAF PASS>
5201 <MODULE TTCN Temp Temp.ttcn>
5202 module Temp {
5203
5204
5205 type set aTest  {integer i, bTest r}
5206 type set bTest  {integer i , charstring c optional}
5207
5208 template aTest tem := {i := 1, r := {i := 2, c := omit}, n := 3}
5209
5210 }
5211 <END_MODULE>
5212 <RESULT IF_PASS COUNT 1>
5213 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?template.+?for.+?set.+?type
5214 <END_RESULT>
5215 <<RESULT IF_PASS COUNT 1>
5216 (?is)\berror:
5217 <END_RESULT>
5218 <END_TC>
5219
5220 :exmp.
5221
5222 .*---------------------------------------------------------------------*
5223 :h3.non-existent field in template - contained record
5224 .*---------------------------------------------------------------------*
5225 :xmp tab=0.
5226
5227 <TC -  non-existent field in template - contained record>
5228
5229 <COMPILE>
5230 <VERDICT_LEAF PASS>
5231 <MODULE TTCN Temp Temp.ttcn>
5232 module Temp {
5233
5234
5235 type set aTest  {integer i, bTest r}
5236 type record bTest  {integer i , charstring c optional}
5237
5238 template aTest tem := {i := 1, r := {i := 2, c := omit, n := 3}}
5239
5240 }
5241 <END_MODULE>
5242 <RESULT IF_PASS COUNT 1>
5243 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?record.+?template
5244 <END_RESULT>
5245 <<RESULT IF_PASS COUNT 1>
5246 (?is)\berror:
5247 <END_RESULT>
5248 <END_TC>
5249
5250 :exmp.
5251
5252 .*---------------------------------------------------------------------*
5253 :h3.non-existent field in template - contained set
5254 .*---------------------------------------------------------------------*
5255 :xmp tab=0.
5256
5257 <TC -  non-existent field in template - contained set>
5258
5259 <COMPILE>
5260 <VERDICT_LEAF PASS>
5261 <MODULE TTCN Temp Temp.ttcn>
5262 module Temp {
5263
5264
5265 type record aTest  {integer i, bTest r}
5266 type set bTest  {integer i , charstring c optional}
5267
5268 template aTest tem := {i := 1, r := {c := omit, i := 2, n := 3}}
5269
5270 }
5271 <END_MODULE>
5272 <RESULT IF_PASS COUNT 1>
5273 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?template.+?for.+?set.+?type
5274 <END_RESULT>
5275 <<RESULT IF_PASS COUNT 1>
5276 (?is)\berror:
5277 <END_RESULT>
5278 <END_TC>
5279
5280 :exmp.
5281
5282 .*---------------------------------------------------------------------*
5283 :h3.Duplicate field in modified template - set
5284 .*---------------------------------------------------------------------*
5285 :xmp tab=0.
5286
5287 <TC -  Duplicate field in modified template - set>
5288
5289 <COMPILE>
5290 <VERDICT_LEAF PASS>
5291 <MODULE TTCN Temp Temp.ttcn>
5292 module Temp {
5293
5294
5295 type set aTest  {integer i, charstring c}
5296
5297 template aTest tem := { i := 1, c := "aTest"}
5298 template aTest tem1 modifies tem := { i := 1, i := 2}
5299
5300
5301 }
5302 <END_MODULE>
5303 <RESULT IF_PASS COUNT 1>
5304 (?im)error.+?Duplicate.+?set.+?field
5305 <END_RESULT>
5306 <RESULT IF_PASS COUNT 1>
5307 (?im)note.+?Field.+?is.+?already.+?given.+?here
5308 <END_RESULT>
5309 <<RESULT IF_PASS COUNT 1>
5310 (?is)\berror:
5311 <END_RESULT>
5312 <END_TC>
5313
5314 :exmp.
5315
5316 .*---------------------------------------------------------------------*
5317 :h3.Duplicate field in modified template - record
5318 .*---------------------------------------------------------------------*
5319 :xmp tab=0.
5320
5321 <TC -  Duplicate field in modified template - record>
5322
5323 <COMPILE>
5324 <VERDICT_LEAF PASS>
5325 <MODULE TTCN Temp Temp.ttcn>
5326 module Temp {
5327
5328
5329 type record aTest  {integer i, charstring c}
5330
5331 template aTest tem := { i := 1, c := "aTest"}
5332 template aTest tem1 modifies tem := { i := 1, i := 2}
5333
5334
5335 }
5336 <END_MODULE>
5337 <RESULT IF_PASS COUNT 1>
5338 (?im)error.+?Duplicate.+?record.+?field
5339 <END_RESULT>
5340 <RESULT IF_PASS COUNT 1>
5341 (?im)note.+?Field.+?is.+?already.+?given.+?here
5342 <END_RESULT>
5343 <<RESULT IF_PASS COUNT 1>
5344 (?is)\berror:
5345 <END_RESULT>
5346 <END_TC>
5347
5348 :exmp.
5349
5350 .*---------------------------------------------------------------------*
5351 :h3.Duplicate field in modified template - contained set
5352 .*---------------------------------------------------------------------*
5353 :xmp tab=0.
5354
5355 <TC -  Duplicate field in modified template - contained set>
5356
5357 <COMPILE>
5358 <VERDICT_LEAF PASS>
5359 <MODULE TTCN Temp Temp.ttcn>
5360 module Temp {
5361
5362
5363 type set aTest  {integer i, bTest r}
5364 type set bTest  {integer i , charstring c optional}
5365
5366 template aTest tem := { i := 1, r := {i := 2, c := omit}}
5367 template aTest tem1 modifies tem := { r := { i := 2, c := omit, i := 3}}
5368
5369
5370 }
5371 <END_MODULE>
5372 <RESULT IF_PASS COUNT 1>
5373 (?im)error.+?Duplicate.+?set.+?field
5374 <END_RESULT>
5375 <RESULT IF_PASS COUNT 1>
5376 (?im)note.+?Field.+?is.+?already.+?given.+?here
5377 <END_RESULT>
5378 <<RESULT IF_PASS COUNT 1>
5379 (?is)\berror:
5380 <END_RESULT>
5381 <END_TC>
5382
5383 :exmp.
5384
5385 .*---------------------------------------------------------------------*
5386 :h3.Duplicate field in modified template - contained record
5387 .*---------------------------------------------------------------------*
5388 :xmp tab=0.
5389
5390 <TC -  Duplicate field in modified template - contained record>
5391
5392 <COMPILE>
5393 <VERDICT_LEAF PASS>
5394 <MODULE TTCN Temp Temp.ttcn>
5395 module Temp {
5396
5397
5398 type set aTest  {integer i, bTest r}
5399 type record bTest  {integer i , charstring c optional}
5400
5401 template aTest tem := { i := 1, r := {i := 2, c := omit}}
5402 template aTest tem1 modifies tem := { r := { i := 2, c := omit, i := 3}}
5403
5404
5405 }
5406 <END_MODULE>
5407 <RESULT IF_PASS COUNT 1>
5408 (?im)error.+?Duplicate.+?record.+?field
5409 <END_RESULT>
5410 <RESULT IF_PASS COUNT 1>
5411 (?im)note.+?Field.+?is.+?already.+?given.+?here
5412 <END_RESULT>
5413 <<RESULT IF_PASS COUNT 1>
5414 (?is)\berror:
5415 <END_RESULT>
5416 <END_TC>
5417
5418 :exmp.
5419
5420 .*---------------------------------------------------------------------*
5421 :h3.non-existent field in modified template - set
5422 .*---------------------------------------------------------------------*
5423 :xmp tab=0.
5424
5425 <TC -  non-existent field in modified template - set>
5426
5427 <COMPILE>
5428 <VERDICT_LEAF PASS>
5429 <MODULE TTCN Temp Temp.ttcn>
5430 module Temp {
5431
5432
5433 type set aTest  {integer i, charstring c}
5434
5435 template aTest tem := { i := 1, c := "aTest"}
5436 template aTest tem1 modifies tem := { n := omit }
5437
5438
5439 }
5440 <END_MODULE>
5441 <RESULT IF_PASS COUNT 1>
5442 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?template.+?for.+?set.+?type
5443 <END_RESULT>
5444 <<RESULT IF_PASS COUNT 1>
5445 (?is)\berror:
5446 <END_RESULT>
5447 <END_TC>
5448
5449 :exmp.
5450
5451 .*---------------------------------------------------------------------*
5452 :h3.non-existent field in modified template - record
5453 .*---------------------------------------------------------------------*
5454 :xmp tab=0.
5455
5456 <TC -  non-existent field in modified template - record>
5457
5458 <COMPILE>
5459 <VERDICT_LEAF PASS>
5460 <MODULE TTCN Temp Temp.ttcn>
5461 module Temp {
5462
5463
5464 type record aTest  {integer i, charstring c}
5465
5466 template aTest tem := { i := 1, c := "aTest"}
5467 template aTest tem1 modifies tem := { i := 1, n := 2}
5468
5469
5470 }
5471 <END_MODULE>
5472 <RESULT IF_PASS COUNT 1>
5473 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?record.+?template
5474 <END_RESULT>
5475 <<RESULT IF_PASS COUNT 1>
5476 (?is)\berror:
5477 <END_RESULT>
5478 <END_TC>
5479
5480 :exmp.
5481
5482 .*---------------------------------------------------------------------*
5483 :h3.non-existent field in modified template - contained set
5484 .*---------------------------------------------------------------------*
5485 :xmp tab=0.
5486
5487 <TC -  non-existent field in modified template - contained set>
5488
5489 <COMPILE>
5490 <VERDICT_LEAF PASS>
5491 <MODULE TTCN Temp Temp.ttcn>
5492 module Temp {
5493
5494
5495 type set aTest  {integer i, bTest r}
5496 type set bTest  {integer i , charstring c optional}
5497
5498 template aTest tem := { i := 1, r := {i := 2, c := omit}}
5499 template aTest tem1 modifies tem := { r := { i := 2, c := omit, n := omit }}
5500
5501
5502 }
5503 <END_MODULE>
5504 <RESULT IF_PASS COUNT 1>
5505 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?template.+?for.+?set.+?type
5506 <END_RESULT>
5507 <<RESULT IF_PASS COUNT 1>
5508 (?is)\berror:
5509 <END_RESULT>
5510 <END_TC>
5511
5512 :exmp.
5513
5514 .*---------------------------------------------------------------------*
5515 :h3.non-existent field in modified template - contained record
5516 .*---------------------------------------------------------------------*
5517 :xmp tab=0.
5518
5519 <TC -  non-existent field in modified template - contained record>
5520
5521 <COMPILE>
5522 <VERDICT_LEAF PASS>
5523 <MODULE TTCN Temp Temp.ttcn>
5524 module Temp {
5525
5526
5527 type set aTest  {integer i, bTest r}
5528 type record bTest  {integer i , charstring c optional}
5529
5530 template aTest tem := { i := 1, r := {i := 2, c := omit}}
5531 template aTest tem1 modifies tem := { r := { i := 2, c := omit, n := 3}}
5532
5533
5534 }
5535 <END_MODULE>
5536 <RESULT IF_PASS COUNT 1>
5537 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?record.+?template
5538 <END_RESULT>
5539 <<RESULT IF_PASS COUNT 1>
5540 (?is)\berror:
5541 <END_RESULT>
5542 <END_TC>
5543
5544 :exmp.
5545
5546 .*---------------------------------------------------------------------*
5547 :h3.Duplicate field in union template - contained record
5548 .*---------------------------------------------------------------------*
5549 :xmp tab=0.
5550
5551 <TC -  Duplicate field in union template - contained record>
5552
5553 <COMPILE>
5554 <VERDICT_LEAF PASS>
5555 <MODULE TTCN Temp Temp.ttcn>
5556 module Temp {
5557
5558
5559 type record aTest  {integer i, bTest r}
5560 type record bTest  {integer i , charstring c optional}
5561 type union cTest {aTest a, bTest b}
5562
5563 template cTest tem := {a := { i := 1, r := {i := 2, c := omit, c := "bTest"}}}
5564
5565
5566 }
5567 <END_MODULE>
5568 <RESULT IF_PASS COUNT 1>
5569 (?im)error.+?Duplicate.+?record.+?field
5570 <END_RESULT>
5571 <RESULT IF_PASS COUNT 1>
5572 (?im)note.+?Field.+?is.+?already.+?given.+?here
5573 <END_RESULT>
5574 <<RESULT IF_PASS COUNT 1>
5575 (?is)\berror:
5576 <END_RESULT>
5577 <END_TC>
5578
5579 :exmp.
5580
5581 .*---------------------------------------------------------------------*
5582 :h3.Duplicate field in union template - contained set
5583 .*---------------------------------------------------------------------*
5584 :xmp tab=0.
5585
5586 <TC -  Duplicate field in union template - contained set>
5587
5588 <COMPILE>
5589 <VERDICT_LEAF PASS>
5590 <MODULE TTCN Temp Temp.ttcn>
5591 module Temp {
5592
5593
5594 type record aTest  {integer i, bTest r}
5595 type set bTest  {integer i , charstring c optional}
5596 type union cTest {aTest a, bTest b}
5597
5598 template cTest tem := {a := { i := 1, r := {i := 2, c := omit, c := "bTest"}}}
5599
5600
5601 }
5602 <END_MODULE>
5603 <RESULT IF_PASS COUNT 1>
5604 (?im)error.+?Duplicate.+?set.+?field
5605 <END_RESULT>
5606 <RESULT IF_PASS COUNT 1>
5607 (?im)note.+?Field.+?is.+?already.+?given.+?here
5608 <END_RESULT>
5609 <<RESULT IF_PASS COUNT 1>
5610 (?is)\berror:
5611 <END_RESULT>
5612 <END_TC>
5613
5614 :exmp.
5615
5616 .*---------------------------------------------------------------------*
5617 :h3.non-existent field in union template - contained record
5618 .*---------------------------------------------------------------------*
5619 :xmp tab=0.
5620
5621 <TC -  non-existent field in union template - contained record>
5622
5623 <COMPILE>
5624 <VERDICT_LEAF PASS>
5625 <MODULE TTCN Temp Temp.ttcn>
5626 module Temp {
5627
5628
5629 type record aTest  {integer i, bTest r}
5630 type record bTest  {integer i , charstring c optional}
5631 type union cTest {aTest a, bTest b}
5632
5633 template cTest tem := {a := { i := 1, r := {i := 2, c := omit, n := 3}}}
5634
5635
5636 }
5637 <END_MODULE>
5638 <RESULT IF_PASS COUNT 1>
5639 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?record.+?template
5640 <END_RESULT>
5641 <<RESULT IF_PASS COUNT 1>
5642 (?is)\berror:
5643 <END_RESULT>
5644 <END_TC>
5645
5646 :exmp.
5647
5648 .*---------------------------------------------------------------------*
5649 :h3.non-existent field in union template - contained set
5650 .*---------------------------------------------------------------------*
5651 :xmp tab=0.
5652
5653 <TC -  non-existent field in union template - contained set>
5654
5655 <COMPILE>
5656 <VERDICT_LEAF PASS>
5657 <MODULE TTCN Temp Temp.ttcn>
5658 module Temp {
5659
5660
5661 type record aTest  {integer i, bTest r}
5662 type set bTest  {integer i , charstring c optional}
5663 type union cTest {aTest a, bTest b}
5664
5665 template cTest tem := {a := { i := 1, r := {i := 2, c := omit, n := 3}}}
5666
5667 }
5668 <END_MODULE>
5669 <RESULT IF_PASS COUNT 1>
5670 (?im)error.+?Reference.+?to.+?non-existent.+?field.+?in.+?template.+?set
5671 <END_RESULT>
5672 <<RESULT IF_PASS COUNT 1>
5673 (?is)\berror:
5674 <END_RESULT>
5675 <END_TC>
5676
5677 :exmp.
5678 .*---------------------------------------------------------------------*
5679 :h2.Union template
5680 .*---------------------------------------------------------------------*
5681
5682 .*---------------------------------------------------------------------*
5683 :h3.More than one field in union template - two insted of one
5684 .*---------------------------------------------------------------------*
5685 :xmp tab=0.
5686
5687 <TC -  More than one field in union template - two insted of one>
5688
5689 <COMPILE>
5690 <VERDICT_LEAF PASS>
5691 <MODULE TTCN Temp Temp.ttcn>
5692 module Temp {
5693
5694
5695 type union uTest {integer i, boolean b, charstring c}
5696
5697 template uTest u := {i := 1, b := true}
5698
5699 }
5700 <END_MODULE>
5701 <RESULT IF_PASS COUNT 1>
5702 (?im)error.+?template.+?for.+?union.+?type.+?must.+?contain.+?exactly.+?one.+?selected.+?field
5703 <END_RESULT>
5704 <<RESULT IF_PASS COUNT 1>
5705 (?is)\berror:
5706 <END_RESULT>
5707 <END_TC>
5708
5709 :exmp.
5710
5711 .*---------------------------------------------------------------------*
5712 :h3.More than one field in union template - three insted of one
5713 .*---------------------------------------------------------------------*
5714 :xmp tab=0.
5715
5716 <TC -  More than one field in union template - three insted of one>
5717
5718 <COMPILE>
5719 <VERDICT_LEAF PASS>
5720 <MODULE TTCN Temp Temp.ttcn>
5721 module Temp {
5722
5723
5724 type union uTest {integer i, boolean b, charstring c}
5725
5726 template uTest u := {i := 1, b := true, c := "c"}
5727
5728 }
5729 <END_MODULE>
5730 <RESULT IF_PASS COUNT 1>
5731 (?im)error.+?template.+?for.+?union.+?type.+?must.+?contain.+?exactly.+?one.+?selected.+?field
5732 <END_RESULT>
5733 <<RESULT IF_PASS COUNT 1>
5734 (?is)\berror:
5735 <END_RESULT>
5736 <END_TC>
5737
5738 :exmp.
5739 .*---------------------------------------------------------------------*
5740 :h2.Template for recursive types
5741 .*---------------------------------------------------------------------*
5742
5743 .*---------------------------------------------------------------------*
5744 :h3.Template for recursive types - valueof()
5745 .*---------------------------------------------------------------------*
5746 :xmp tab=0.
5747
5748 <TC -  Template for recursive types - valueof()>
5749 <COMPILE>
5750 <VERDICT_LEAF PASS>
5751 <MODULE TTCN Temp Temp.ttcn>
5752 module Temp {
5753 // TR 701: Segfault when there is a circular reference, where valueof() is involved
5754
5755 type record aTest  {integer i, bTest r}
5756 type set bTest  {integer i , charstring c}
5757
5758 template aTest tem := tem1;
5759
5760 template aTest tem1 := valueof(tem);
5761
5762
5763 }
5764 <END_MODULE>
5765 <RESULT IF_PASS COUNT 1>
5766 (?im)error.+?Circular.+?reference
5767 <END_RESULT>
5768 <<RESULT IF_PASS COUNT 1>
5769 (?is)\berror:
5770 <END_RESULT>
5771 <END_TC>
5772
5773 :exmp.
5774
5775 .*---------------------------------------------------------------------*
5776 :h3.Template for recursive types - contained record
5777 .*---------------------------------------------------------------------*
5778 :xmp tab=0.
5779
5780 <TC -  Template for recursive types - contained record>
5781
5782 <COMPILE>
5783 <VERDICT_LEAF PASS>
5784 <MODULE TTCN Temp Temp.ttcn>
5785 module Temp {
5786
5787 // TR 690: segmentation fault
5788 type record aTest  {integer i, uTest u}
5789 type union uTest {aTest a, integer i}
5790
5791 template uTest tem1 := {a := {1,tem.u}}
5792 template uTest tem  := tem1;
5793
5794
5795 }
5796 <END_MODULE>
5797 <RESULT IF_PASS COUNT 1>
5798 (?im)error.+?Reference.+?to.+?non-existent.+?field
5799 <END_RESULT>
5800 <<RESULT IF_PASS COUNT 1>
5801 (?is)\berror:
5802 <END_RESULT>
5803 <END_TC>
5804
5805 :exmp.
5806
5807 .*---------------------------------------------------------------------*
5808 :h3.Template for recursive types - sizeof() on record of
5809 .*---------------------------------------------------------------------*
5810 :xmp tab=0.
5811
5812 <TC -  Template for recursive types - sizeof() on record of>
5813
5814 <COMPILEGCC>
5815 <VERDICT_LEAF PASS>
5816 <MODULE TTCN Temp Temp.ttcn>
5817 module Temp {
5818
5819
5820 type record of integer rtype;
5821
5822 template rtype r := {1, 2, sizeof(r)}
5823
5824 }
5825 <END_MODULE>
5826 <RESULT IF_PASS NEGATIVE>
5827 (?is)\berror:
5828 <END_RESULT>
5829 <END_TC>
5830
5831 :exmp.
5832
5833 .*---------------------------------------------------------------------*
5834 :h3.Template for recursive types - sizeof() on set of
5835 .*---------------------------------------------------------------------*
5836 :xmp tab=0.
5837
5838 <TC -  Template for recursive types - sizeof() on set of>
5839
5840 <COMPILEGCC>
5841 <VERDICT_LEAF PASS>
5842 <MODULE TTCN Temp Temp.ttcn>
5843 module Temp {
5844
5845
5846 type set of integer rtype;
5847
5848 template rtype r := {1, 2, sizeof(r)}
5849
5850
5851 }
5852 <END_MODULE>
5853 <RESULT IF_PASS NEGATIVE>
5854 (?is)\berror:
5855 <END_RESULT>
5856 <END_TC>
5857
5858 :exmp.
5859
5860 .*---------------------------------------------------------------------*
5861 :h2.Value list notation in set template
5862 .*---------------------------------------------------------------------*
5863
5864 .*---------------------------------------------------------------------*
5865 :h3.Value list notation in set
5866 .*---------------------------------------------------------------------*
5867 :xmp tab=0.
5868
5869 <TC -  Value list notation in set >
5870
5871 <COMPILE>
5872 <VERDICT_LEAF PASS>
5873 <MODULE TTCN Temp Temp.ttcn>
5874 module Temp {
5875
5876
5877 type set aTest  {integer i, bTest r}
5878 type record bTest  {integer i, charstring c optional}
5879
5880 template aTest tem := {1, {2, omit}}
5881
5882
5883 }
5884 <END_MODULE>
5885 <RESULT IF_PASS COUNT 1>
5886 (?im)error.+?Value.+?list.+?notation.+?not.+?allowed.+?for.+?set.+?type
5887 <END_RESULT>
5888 <<RESULT IF_PASS COUNT 1>
5889 (?is)\berror:
5890 <END_RESULT>
5891 <END_TC>
5892
5893 :exmp.
5894
5895 .*---------------------------------------------------------------------*
5896 :h3.Value list notation in contained set
5897 .*---------------------------------------------------------------------*
5898 :xmp tab=0.
5899
5900 <TC -  Value list notation in contained set>
5901
5902 <COMPILE>
5903 <VERDICT_LEAF PASS>
5904 <MODULE TTCN Temp Temp.ttcn>
5905 module Temp {
5906
5907
5908 type record aTest  {integer i, bTest r}
5909 type set bTest  {integer i, charstring c optional}
5910
5911 template aTest tem := {1, {2, omit}}
5912
5913
5914 }
5915 <END_MODULE>
5916 <RESULT IF_PASS COUNT 1>
5917 (?im)error.+?Value.+?list.+?notation.+?not.+?allowed.+?for.+?set.+?type
5918 <END_RESULT>
5919 <<RESULT IF_PASS COUNT 1>
5920 (?is)\berror:
5921 <END_RESULT>
5922 <END_TC>
5923
5924 :exmp.
5925
5926 .*---------------------------------------------------------------------*
5927 :h3.Value list notation in set inside union
5928 .*---------------------------------------------------------------------*
5929 :xmp tab=0.
5930
5931 <TC -  Value list notation in set inside union>
5932
5933 <COMPILE>
5934 <VERDICT_LEAF PASS>
5935 <MODULE TTCN Temp Temp.ttcn>
5936 module Temp {
5937
5938
5939 type set aTest  {integer i, bTest r}
5940 type record bTest  {integer i , charstring c optional}
5941 type union cTest {aTest a, bTest b}
5942
5943 template cTest tem := {a := {1, {2, "bTest"}}}
5944
5945
5946 }
5947 <END_MODULE>
5948 <RESULT IF_PASS COUNT 1>
5949 (?im)error.+?Value.+?list.+?notation.+?not.+?allowed.+?for.+?set.+?type
5950 <END_RESULT>
5951 <<RESULT IF_PASS COUNT 1>
5952 (?is)\berror:
5953 <END_RESULT>
5954 <END_TC>
5955
5956 :exmp.
5957
5958 .*---------------------------------------------------------------------*
5959 :h3.Value list notation in contained set inside union
5960 .*---------------------------------------------------------------------*
5961 :xmp tab=0.
5962
5963 <TC -  Value list notation in contained set inside union>
5964
5965 <COMPILE>
5966 <VERDICT_LEAF PASS>
5967 <MODULE TTCN Temp Temp.ttcn>
5968 module Temp {
5969
5970
5971 type record aTest  {integer i, bTest r}
5972 type set bTest  {integer i , charstring c optional}
5973 type union cTest {aTest a, bTest b}
5974
5975 template cTest tem := {a := {1, {2, "bTest"}}}
5976
5977
5978 }
5979 <END_MODULE>
5980 <RESULT IF_PASS COUNT 1>
5981 (?im)error.+?Value.+?list.+?notation.+?not.+?allowed.+?for.+?set.+?type
5982 <END_RESULT>
5983 <<RESULT IF_PASS COUNT 1>
5984 (?is)\berror:
5985 <END_RESULT>
5986 <END_TC>
5987
5988 :exmp.
5989
5990 .*---------------------------------------------------------------------*
5991 :h2.recursive derivation in a modified template
5992 .*---------------------------------------------------------------------*
5993
5994 .*---------------------------------------------------------------------*
5995 :h3.Recursive derivation in a modified template1
5996 .*---------------------------------------------------------------------*
5997 :xmp tab=0.
5998
5999 <TC -  Recursive derivation in a modified template1>
6000
6001 <COMPILE>
6002 <VERDICT_LEAF PASS>
6003 <MODULE TTCN Temp Temp.ttcn>
6004 module Temp {
6005
6006
6007 type record aTest  {integer i, charstring c}
6008
6009 template aTest tem modifies tem1 := {i := 2}
6010 template aTest tem1 modifies tem := {i := 1}
6011
6012
6013 }
6014 <END_MODULE>
6015 <RESULT IF_PASS COUNT 1>
6016 (?im)error.+?Circular.+?reference
6017 <END_RESULT>
6018 <<RESULT IF_PASS COUNT 1>
6019 (?is)\berror:
6020 <END_RESULT>
6021 <END_TC>
6022
6023 :exmp.
6024
6025 .*---------------------------------------------------------------------*
6026 :h3.Recursive derivation in a modified template2
6027 .*---------------------------------------------------------------------*
6028 :xmp tab=0.
6029
6030 <TC -  Recursive derivation in a modified template2>
6031
6032 <COMPILE>
6033 <VERDICT_LEAF PASS>
6034 <MODULE TTCN Temp Temp.ttcn>
6035 module Temp {
6036
6037
6038 type record aTest  {integer i, charstring c}
6039 template aTest tem modifies tem1 := {i := tem.i}
6040
6041
6042 }
6043 <END_MODULE>
6044 <RESULT IF_PASS COUNT 1>
6045 (?im)error.+?There.+?is.+?no.+?local.+?or.+?imported.+?definition
6046 <END_RESULT>
6047 <RESULT IF_PASS COUNT 1>
6048 (?im)error.+?Circular.+?reference
6049 <END_RESULT>
6050 <<RESULT IF_PASS COUNT 2>
6051 (?is)\berror:
6052 <END_RESULT>
6053 <END_TC>
6054
6055 :exmp.
6056 .*---------------------------------------------------------------------*
6057 :h2.Wrong order of fields in modified template
6058 .*---------------------------------------------------------------------*
6059
6060 .*---------------------------------------------------------------------*
6061 :h3.Wrong order of fields in modified template - in record
6062 .*---------------------------------------------------------------------*
6063 :xmp tab=0.
6064
6065 <TC -  Wrong order of fields in modified template - in record>
6066
6067 <COMPILE>
6068 <VERDICT_LEAF PASS>
6069 <MODULE TTCN Temp Temp.ttcn>
6070 module Temp {
6071
6072
6073 type record aTest  {integer i , charstring c optional}
6074
6075 template aTest tem := { i := 1, c := omit}
6076 template aTest tem1 modifies tem := {c := omit, i := 3}
6077
6078
6079 }
6080 <END_MODULE>
6081 <RESULT IF_PASS COUNT 1>
6082 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?template.+?for.+?record.+?type
6083 <END_RESULT>
6084 <<RESULT IF_PASS COUNT 1>
6085 (?is)\berror:
6086 <END_RESULT>
6087 <END_TC>
6088
6089 :exmp.
6090
6091 .*---------------------------------------------------------------------*
6092 :h3.Wrong order of fields in modified template - in contained record
6093 .*---------------------------------------------------------------------*
6094 :xmp tab=0.
6095
6096 <TC -  Wrong order of fields in modified template - in contained record>
6097
6098 <COMPILE>
6099 <VERDICT_LEAF PASS>
6100 <MODULE TTCN Temp Temp.ttcn>
6101 module Temp {
6102
6103
6104 type record aTest  {integer i, bTest r}
6105 type record bTest  {integer i , charstring c optional}
6106
6107 template aTest tem := { i := 1, r := {i := 2, c := omit}}
6108 template aTest tem1 modifies tem := {i := 3, r := {c := omit,i := 3}}
6109
6110
6111 }
6112 <END_MODULE>
6113 <RESULT IF_PASS COUNT 1>
6114 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?template.+?for.+?record.+?type
6115 <END_RESULT>
6116 <<RESULT IF_PASS COUNT 1>
6117 (?is)\berror:
6118 <END_RESULT>
6119 <END_TC>
6120
6121 :exmp.
6122
6123 .*---------------------------------------------------------------------*
6124 :h3.Wrong order of fields in modified union template - in record
6125 .*---------------------------------------------------------------------*
6126 :xmp tab=0.
6127
6128 <TC -  Wrong order of fields in modified union template - in record>
6129
6130 <COMPILE>
6131 <VERDICT_LEAF PASS>
6132 <MODULE TTCN Temp Temp.ttcn>
6133 module Temp {
6134
6135
6136 type record aTest  {integer i , charstring c optional}
6137
6138 type union cTest {aTest a, integer i}
6139
6140 template cTest tem := {a := { i := 1, c := "aTest"}}
6141 template cTest tem1 modifies tem := {a := {c := omit, i := 2}}
6142
6143
6144 }
6145 <END_MODULE>
6146 <RESULT IF_PASS COUNT 1>
6147 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?template.+?for.+?record.+?type
6148 <END_RESULT>
6149 <<RESULT IF_PASS COUNT 1>
6150 (?is)\berror:
6151 <END_RESULT>
6152 <END_TC>
6153
6154 :exmp.
6155
6156 .*---------------------------------------------------------------------*
6157 :h3.Wrong order of fields in modified union template - in contained record
6158 .*---------------------------------------------------------------------*
6159 :xmp tab=0.
6160
6161 <TC -  Wrong order of fields in modified union template - in contained record>
6162
6163 <COMPILE>
6164 <VERDICT_LEAF PASS>
6165 <MODULE TTCN Temp Temp.ttcn>
6166 module Temp {
6167
6168
6169 type record aTest  {integer i, bTest r}
6170 type record bTest  {integer i , charstring c optional}
6171 type union cTest {aTest a, bTest b}
6172
6173 template cTest tem := {a := { i := 1, r := {i := 2, c := omit}}}
6174 template cTest tem1 modifies tem := {a := { i := 1, r := {c := omit, i := 3}}}
6175
6176
6177 }
6178 <END_MODULE>
6179 <RESULT IF_PASS COUNT 1>
6180 (?im)error.+?Field.+?cannot.+?appear.+?after.+?field.+?in.+?template.+?for.+?record.+?type
6181 <END_RESULT>
6182 <<RESULT IF_PASS COUNT 1>
6183 (?is)\berror:
6184 <END_RESULT>
6185 <END_TC>
6186
6187 :exmp.
6188 .*---------------------------------------------------------------------*
6189 :h2.Modified template cannot refer to itself
6190 .*---------------------------------------------------------------------*
6191
6192 .*---------------------------------------------------------------------*
6193 :h3.Modified template refers to itself
6194 .*---------------------------------------------------------------------*
6195 :xmp tab=0.
6196
6197 <TC -  Modified template refers to itself >
6198
6199 <COMPILE>
6200 <VERDICT_LEAF PASS>
6201 <MODULE TTCN Temp Temp.ttcn>
6202 module Temp {
6203
6204
6205 type record aTest  {integer i, charstring c}
6206
6207 template aTest tem1 modifies tem1 := {i := 2}
6208
6209
6210 }
6211 <END_MODULE>
6212 <RESULT IF_PASS COUNT 1>
6213 (?im)error.+?Circular.+?reference
6214 <END_RESULT>
6215 <<RESULT IF_PASS COUNT 1>
6216 (?is)\berror:
6217 <END_RESULT>
6218 <END_TC>
6219
6220 :exmp.
6221
6222 .*---------------------------------------------------------------------*
6223 :h3.Modified template refers to itself - record field
6224 .*---------------------------------------------------------------------*
6225 :xmp tab=0.
6226
6227 <TC -  Modified template refers to itself - record field>
6228
6229 <COMPILE>
6230 <VERDICT_LEAF PASS>
6231 <MODULE TTCN Temp Temp.ttcn>
6232 module Temp {
6233
6234
6235 type record aTest  {integer i, charstring c}
6236
6237 template aTest tem1 modifies tem := {i := tem1.i}
6238
6239
6240 }
6241 <END_MODULE>
6242 <RESULT IF_PASS COUNT 1>
6243 (?im)error.+?There.+?is.+?no.+?local.+?or.+?imported.+?definition
6244 <END_RESULT>
6245 <RESULT IF_PASS COUNT 1>
6246 (?im)error.+?Circular.+?reference
6247 <END_RESULT>
6248 <<RESULT IF_PASS COUNT 2>
6249 (?is)\berror:
6250 <END_RESULT>
6251 <END_TC>
6252
6253 :exmp.
6254
6255 .*---------------------------------------------------------------------*
6256 :h3.Modified template refers to itself - record of field
6257 .*---------------------------------------------------------------------*
6258 :xmp tab=0.
6259
6260 <TC -  Modified template refers to itself - record of field>
6261
6262 <COMPILE>
6263 <VERDICT_LEAF PASS>
6264 <MODULE TTCN Temp Temp.ttcn>
6265 module Temp {
6266
6267
6268 type record of integer aTest;
6269
6270 template aTest tem1 modifies tem := {i := tem1[i]}
6271
6272
6273 }
6274 <END_MODULE>
6275 <RESULT IF_PASS COUNT 1>
6276 (?im)error.+?There.+?is.+?no.+?local.+?or.+?imported.+?definition
6277 <END_RESULT>
6278 <RESULT IF_PASS COUNT 1>
6279 (?im)error.+?assignment.+?notation.+?cannot.+?used.+?for.+?record.+?of.+?type
6280 <END_RESULT>
6281 <<RESULT IF_PASS COUNT 2>
6282 (?is)\berror:
6283 <END_RESULT>
6284 <END_TC>
6285
6286 :exmp.
6287 .*---------------------------------------------------------------------*
6288 :h2.First argument of match is not a value
6289 .*---------------------------------------------------------------------*
6290
6291 .*---------------------------------------------------------------------*
6292 :h2.Second argument of match is not a template
6293 .*---------------------------------------------------------------------*
6294
6295 .*---------------------------------------------------------------------*
6296 :h2.Argument of valueof is not a template
6297 .*---------------------------------------------------------------------*
6298
6299 .*---------------------------------------------------------------------*
6300 :h3.Argument of valueof is not a template - constant
6301 .*---------------------------------------------------------------------*
6302 :xmp tab=0.
6303
6304 <TC - Argument of valueof is not a template - constant>
6305
6306 <COMPILEGCC>
6307 <VERDICT_LEAF PASS>
6308 <MODULE TTCN Temp Temp.ttcn>
6309 module Temp {
6310
6311
6312 type record aTest  {integer i, charstring c}
6313
6314 const aTest con  := { i := 1, c := "aTest"}
6315 const aTest con1 := valueof(con);
6316
6317
6318 }
6319 <END_MODULE>
6320 <RESULT IF_PASS NEGATIVE>
6321 (?is)\berror:
6322 <END_RESULT>
6323 <END_TC>
6324
6325 :exmp.
6326
6327 :etext.