function_test/RAW_EncDec/RAW_EncDec_TD.script

   1 .******************************************************************************
   2 .* Copyright (c) 2000-2016 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 .* Contributors:
   9 .*   Balasko, Jeno
  10 .*   Delic, Adam
  11 .*   Hanko, Matyas
  12 .*   Kovacs, Ferenc
  13 .*   Pandi, Krisztian
  14 .*   Raduly, Csaba
  15 .*   Szabados, Kristof
  16 .*   Szabo, Janos Zoltan – initial implementation
  17 .*
  18 .******************************************************************************/
  19 :text.
  20 :lang eng.
  21 .*
  22 :docname.Test Description
  23 :docno.7/152 91-CRL 113 200/3 Uen
  24 :rev.A
  25 :date.2013-01-27
  26 .*
  27 :prep.ETH/XZR Krisztian Pandi
  28 :appr.ETH/XZ (Gyula Koos)
  29 :checked.ETHGRY
  30 .*
  31 :title.Test description - RAW coder
  32 :contents level=3.
  33 .*---------------------------------------------------------------------*
  34 :h1.PREREQUISITES AND PREPARATIONS
  35 .*---------------------------------------------------------------------*
  36 .*---------------------------------------------------------------------*
  37 :h2.Scope of the Test Object
  38 .*---------------------------------------------------------------------*
  39 :xmp tab=1 nokeep.
  40
  41 This file is obsolate, don't modify, improve it anymore!
  42
  43 This TD contains test cases related to TTCN3 Executor's RAW coder function.
  44 DON'T YOU DARE TO WRITE AN INSPECTION RECORD ABOUT THIS FILE.
  45
  46 :exmp.
  47
  48 :p.:us.Revision Information:eus.
  49
  50 :xmp nokeep.
  51 :us.History:eus.
  52
  53 REV   DATE         PREPARED   CHANGE
  54 ===   ==========   ========   ======
  55 A     2003-10-31   ETHCSIR    New document
  56 B     2005-11-09   EKRISZA    New tests and updates of the original tests.
  57 C     2007-03-06   EDMDELI    Implicit message encoding
  58 D     2007-06-20   EDMDELI    New testcase for implicit message encoding
  59 E     2008-10-01   EFERKOV    Big integers
  60 F     2010-01-18   EKRISZA     Updated for TITAN R8C
  61 H     2010-08-13   EKRISZA     Updated for TITAN R8E
  62 J      2011-05-26   EKRISZA    Added new test
  63 K     2010-01-18   EKRISZA     Updated for TITAN R8H
  64 A     2011-12-12   EKRISZA     Updated for release
  65 A     2012-06-27   EFERKOV     Updated for release
  66 A     2013-01-17   EKRIPND     Updated for release
  67 :exmp.
  68
  69 .*---------------------------------------------------------------------*
  70 :h2.Test Tools
  71 .*---------------------------------------------------------------------*
  72 :p.:us.Software Tools:eus.
  73 :xmp tab=2 nokeep.
  74
  75         SAtester
  76
  77 :exmp.
  78 :np.
  79 .*---------------------------------------------------------------------*
  80 :h1.REQUIREMENT-BASED TESTS
  81 .*---------------------------------------------------------------------*
  82 .*---------------------------------------------------------------------*
  83 :h2.Testing FIELDLENGTH Attribute
  84 .*---------------------------------------------------------------------*
  85 .*---------------------------------------------------------------------*
  86 :h3.  FIELDLENGTH(16)  for integer
  87 .*---------------------------------------------------------------------*
  88 :xmp tab=0.
  89
  90 <TC-   FIELDLENGTH(16)  for integer>
  91
  92 <STATIC>
  93
  94 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
  95 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
  96
  97 type integer RAW_PDU
  98 with { encode "RAW"; variant "FIELDLENGTH(16)"};
  99
 100 const RAW_PDU           i := 255
 101 const octetstring       o := 'FF00'O
 102
 103 <TTCN_TC:EXEC>
 104
 105 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 106 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 107
 108 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 109   else {setverdict(fail);}
 110
 111 <RESULT>
 112
 113 Overall verdict: pass
 114
 115 <END_TC>
 116
 117 :exmp.
 118
 119 .*---------------------------------------------------------------------*
 120 :h3.  FIELDLENGTH(8)  for integer
 121 .*---------------------------------------------------------------------*
 122 :xmp tab=0.
 123
 124 <TC-   FIELDLENGTH(8)  for integer>
 125
 126 <STATIC>
 127
 128 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 129 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 130
 131 type integer RAW_PDU
 132 with { encode "RAW"; variant "FIELDLENGTH(8)"};
 133
 134 const RAW_PDU           i := 15
 135 const octetstring       o := '0F'O
 136
 137 <TTCN_TC:EXEC>
 138
 139 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 140 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 141
 142 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 143   else {setverdict(fail);}
 144
 145 <RESULT>
 146
 147 Overall verdict: pass
 148
 149 <END_TC>
 150
 151 :exmp.
 152
 153 .*---------------------------------------------------------------------*
 154 :h3.  FIELDLENGTH(4)  for integer
 155 .*---------------------------------------------------------------------*
 156 :xmp tab=0.
 157
 158 <TC-   FIELDLENGTH(4)  for integer>
 159
 160 <STATIC>
 161
 162 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 163 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 164
 165 type integer RAW_PDU
 166 with { encode "RAW"; variant "FIELDLENGTH(4)"};
 167
 168 const RAW_PDU           i := 15
 169 const octetstring       o := '0F'O
 170
 171 <TTCN_TC:EXEC>
 172
 173 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 174 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 175
 176 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 177   else {setverdict(fail);}
 178
 179 <RESULT>
 180
 181 Overall verdict: pass
 182
 183 <END_TC>
 184
 185 :exmp.
 186
 187 .*---------------------------------------------------------------------*
 188 :h3.  FIELDLENGTH(1)  for longer integer
 189 .*---------------------------------------------------------------------*
 190 :xmp tab=0.
 191
 192 <TC-   FIELDLENGTH(1)  for longer integer>
 193
 194 <STATIC>
 195
 196 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 197 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 198
 199 type integer RAW_PDU
 200 with { encode "RAW"; variant "FIELDLENGTH(1)"};
 201
 202 const RAW_PDU           i := 15
 203 const octetstring       o := '0F'O
 204
 205 <TTCN_TC:EXEC>
 206
 207 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 208 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 209
 210 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 211   else {setverdict(fail);}
 212
 213 <RESULT>
 214
 215 Overall verdict: error
 216
 217 <END_TC>
 218
 219 :exmp.
 220
 221 .*---------------------------------------------------------------------*
 222 :h3.  FIELDLENGTH(16)  for integer
 223 .*---------------------------------------------------------------------*
 224 :xmp tab=0.
 225
 226 <TC-   FIELDLENGTH(16)  for integer>
 227
 228 <STATIC>
 229
 230 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 231 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 232
 233 type integer RAW_PDU
 234 with { encode "RAW"; variant "FIELDLENGTH(16)"};
 235
 236 const RAW_PDU           i := 4660
 237 const octetstring       o := '3412'O
 238
 239 <TTCN_TC:EXEC>
 240
 241 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 242 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 243
 244 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 245   else {setverdict(fail);}
 246
 247 <RESULT>
 248
 249 Overall verdict: pass
 250
 251 <END_TC>
 252
 253 :exmp.
 254
 255 .*---------------------------------------------------------------------*
 256 :h3.  FIELDLENGTH(32)  for integer 1 bit long
 257 .*---------------------------------------------------------------------*
 258 :xmp tab=0.
 259
 260 <TC-   FIELDLENGTH(32)  for integer 1 bit long>
 261
 262 <STATIC>
 263
 264 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 265 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 266
 267 type integer RAW_PDU
 268 with { encode "RAW"; variant "FIELDLENGTH(32)"};
 269
 270 const RAW_PDU           i := 1
 271 const octetstring       o := '01000000'O
 272
 273 <TTCN_TC:EXEC>
 274
 275 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 276 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 277
 278 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 279   else {setverdict(fail);}
 280
 281 <RESULT>
 282
 283 Overall verdict: pass
 284
 285 <END_TC>
 286
 287 :exmp.
 288
 289 .*---------------------------------------------------------------------*
 290 :h3. Default FIELDLENGTH  for integer
 291 .*---------------------------------------------------------------------*
 292 :xmp tab=0.
 293
 294 <TC-  Default FIELDLENGTH  for integer>
 295
 296 <STATIC>
 297
 298 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 299 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 300
 301 type integer RAW_PDU
 302 with { encode "RAW"; variant ""};
 303
 304 const RAW_PDU           i := 255
 305 const octetstring       o := 'FF'O
 306
 307 <TTCN_TC:EXEC>
 308
 309 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 310 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 311
 312 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 313   else {setverdict(fail);}
 314
 315 <RESULT>
 316
 317 Overall verdict: pass
 318
 319 <END_TC>
 320
 321 :exmp.
 322
 323 .*---------------------------------------------------------------------*
 324 :h3.  FIELDLENGTH(8)  for bitstring
 325 .*---------------------------------------------------------------------*
 326 :xmp tab=0.
 327
 328 <TC-   FIELDLENGTH(8)  for bitstring>
 329
 330 <STATIC>
 331
 332 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 333 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 334
 335 type bitstring RAW_PDU
 336 with { encode "RAW"; variant "FIELDLENGTH(8)"};
 337
 338 const RAW_PDU           i := '11110000'B
 339 const octetstring       o := 'F0'O
 340
 341 <TTCN_TC:EXEC>
 342
 343 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 344 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 345
 346 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 347   else {setverdict(fail);}
 348
 349 <RESULT>
 350
 351 Overall verdict: pass
 352
 353 <END_TC>
 354
 355 :exmp.
 356
 357 .*---------------------------------------------------------------------*
 358 :h3.  FIELDLENGTH(8)  for bitstring 4 bits long
 359 .*---------------------------------------------------------------------*
 360 :xmp tab=0.
 361
 362 <TC-   FIELDLENGTH(8)  for bitstring 4 bits long>
 363
 364 <STATIC>
 365
 366 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 367 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 368
 369 type bitstring RAW_PDU
 370 with { encode "RAW"; variant "FIELDLENGTH(8)"};
 371
 372 const RAW_PDU           i := '1111'B
 373 const octetstring       o := '0F'O
 374
 375 <TTCN_TC:EXEC>
 376
 377 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 378 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 379
 380 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == '0000'B & i)) {setverdict(pass);}
 381   else {setverdict(fail);}
 382
 383 <RESULT>
 384
 385 Overall verdict: pass
 386
 387 <END_TC>
 388
 389 :exmp.
 390
 391 .*---------------------------------------------------------------------*
 392 :h3.  FIELDLENGTH(4)  for bitstring
 393 .*---------------------------------------------------------------------*
 394 :xmp tab=0.
 395
 396 <TC-   FIELDLENGTH(4)  for bitstring>
 397
 398 <STATIC>
 399
 400 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 401 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 402
 403 type bitstring RAW_PDU
 404 with { encode "RAW"; variant "FIELDLENGTH(4)"};
 405
 406 const RAW_PDU           i := '1111'B
 407 const octetstring       o := '0F'O
 408
 409 <TTCN_TC:EXEC>
 410
 411 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 412 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 413
 414 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 415   else {setverdict(fail);}
 416
 417 <RESULT>
 418
 419 Overall verdict: pass
 420
 421 <END_TC>
 422
 423 :exmp.
 424
 425 .*---------------------------------------------------------------------*
 426 :h3.  FIELDLENGTH(4)  for longer bitstring
 427 .*---------------------------------------------------------------------*
 428 :xmp tab=0.
 429
 430 <TC-   FIELDLENGTH(4)  for longer bitstring>
 431
 432 <STATIC>
 433
 434 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 435 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 436
 437 type bitstring RAW_PDU
 438 with { encode "RAW"; variant "FIELDLENGTH(4)"};
 439
 440 const RAW_PDU           i := '11111111'B
 441 const octetstring       o := 'FF'O
 442
 443 <TTCN_TC:EXEC>
 444
 445 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 446 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 447
 448 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 449   else {setverdict(fail);}
 450
 451 <RESULT>
 452
 453 Overall verdict: error
 454
 455 <END_TC>
 456
 457 :exmp.
 458
 459 .*---------------------------------------------------------------------*
 460 :h3.  FIELDLENGTH(16)  for bitstring
 461 .*---------------------------------------------------------------------*
 462 :xmp tab=0.
 463
 464 <TC-   FIELDLENGTH(16)  for bitstring>
 465
 466 <STATIC>
 467
 468 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 469 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 470
 471 type bitstring RAW_PDU
 472 with { encode "RAW"; variant "FIELDLENGTH(16)"};
 473
 474 const RAW_PDU           i := '1111000001110000'B
 475 const octetstring       o := '70F0'O
 476
 477 <TTCN_TC:EXEC>
 478
 479 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 480 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 481
 482 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 483   else {setverdict(fail);}
 484
 485 <RESULT>
 486
 487 Overall verdict: pass
 488
 489 <END_TC>
 490
 491 :exmp.
 492
 493 .*---------------------------------------------------------------------*
 494 :h3.  FIELDLENGTH(24)  for bitstring
 495 .*---------------------------------------------------------------------*
 496 :xmp tab=0.
 497
 498 <TC-   FIELDLENGTH(24)  for bitstring>
 499
 500 <STATIC>
 501
 502 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 503 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 504
 505 type bitstring RAW_PDU
 506 with { encode "RAW"; variant "FIELDLENGTH(24)"};
 507
 508 const RAW_PDU           i := '1111000001110000'B
 509 const octetstring       o := '70F000'O
 510
 511 <TTCN_TC:EXEC>
 512
 513 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 514 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 515
 516 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) =='00000000'B & i)) {setverdict(pass);}
 517   else {setverdict(fail);}
 518
 519 <RESULT>
 520
 521 Overall verdict: pass
 522
 523 <END_TC>
 524
 525 :exmp.
 526
 527 .*---------------------------------------------------------------------*
 528 :h3.  FIELDLENGTH(0)  for bitstring
 529 .*---------------------------------------------------------------------*
 530 :xmp tab=0.
 531
 532 <TC-   FIELDLENGTH(0)  for bitstring>
 533
 534 <STATIC>
 535
 536 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 537 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 538
 539 type bitstring RAW_PDU
 540 with { encode "RAW"; variant "FIELDLENGTH(0)"};
 541
 542 const RAW_PDU           i := '1111000001110000'B
 543 const octetstring       o := '70F0'O
 544
 545 <TTCN_TC:EXEC>
 546
 547 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 548 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 549
 550 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 551   else {setverdict(fail);}
 552
 553 <RESULT>
 554
 555 Overall verdict: pass
 556
 557 <END_TC>
 558
 559 :exmp.
 560
 561 .*---------------------------------------------------------------------*
 562 :h3.  Default FIELDLENGTH  for bitstring
 563 .*---------------------------------------------------------------------*
 564 :xmp tab=0.
 565
 566 <TC-   Default FIELDLENGTH  for bitstring>
 567
 568 <STATIC>
 569
 570 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 571 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 572
 573 type bitstring RAW_PDU
 574 with { encode "RAW"; variant ""};
 575
 576 const RAW_PDU           i := '1111000001110000'B
 577 const octetstring       o := '70F0'O
 578
 579 <TTCN_TC:EXEC>
 580
 581 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 582 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 583
 584 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 585   else {setverdict(fail);}
 586
 587 <RESULT>
 588
 589 Overall verdict: pass
 590
 591 <END_TC>
 592
 593 :exmp.
 594
 595 .*---------------------------------------------------------------------*
 596 :h3.  FIELDLENGTH(32)  for bitstring 4 bits long
 597 .*---------------------------------------------------------------------*
 598 :xmp tab=0.
 599
 600 <TC-   FIELDLENGTH(32)  for bitstring 4 bits long>
 601
 602 <STATIC>
 603
 604 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 605 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 606
 607 type bitstring RAW_PDU
 608 with { encode "RAW"; variant "FIELDLENGTH(32)"};
 609
 610 const RAW_PDU           i := '1111'B
 611 const octetstring       o := '0F000000'O
 612
 613 <TTCN_TC:EXEC>
 614
 615 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 616 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 617
 618 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == '0000000000000000000000000000'B & i)) {setverdict(pass);}
 619   else {setverdict(fail);}
 620
 621 <RESULT>
 622
 623 Overall verdict: pass
 624
 625 <END_TC>
 626
 627 :exmp.
 628
 629 .*---------------------------------------------------------------------*
 630 :h3.   FIELDLENGTH(1)  for octetstring
 631 .*---------------------------------------------------------------------*
 632 :xmp tab=0.
 633
 634 <TC-    FIELDLENGTH(1)  for octetstring>
 635
 636 <STATIC>
 637
 638 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 639 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 640
 641 type octetstring RAW_PDU
 642 with { encode "RAW"; variant "FIELDLENGTH(1)"};
 643
 644 const RAW_PDU           i := '0F'O
 645 const octetstring       o := '0F'O
 646
 647 <TTCN_TC:EXEC>
 648
 649 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 650 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 651
 652 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 653   else {setverdict(fail);}
 654
 655 <RESULT>
 656
 657 Overall verdict: pass
 658
 659 <END_TC>
 660
 661 :exmp.
 662
 663 .*---------------------------------------------------------------------*
 664 :h3.   FIELDLENGTH(2)  for octetstring
 665 .*---------------------------------------------------------------------*
 666 :xmp tab=0.
 667
 668 <TC-    FIELDLENGTH(2)  for octetstring>
 669
 670 <STATIC>
 671
 672 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 673 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 674
 675 type octetstring RAW_PDU
 676 with { encode "RAW"; variant "FIELDLENGTH(2)"};
 677
 678 const RAW_PDU           i := '1234'O
 679 const octetstring       o := '1234'O
 680
 681 <TTCN_TC:EXEC>
 682
 683 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 684 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 685
 686 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 687   else {setverdict(fail);}
 688
 689 <RESULT>
 690
 691 Overall verdict: pass
 692
 693 <END_TC>
 694
 695 :exmp.
 696
 697 .*---------------------------------------------------------------------*
 698 :h3.   FIELDLENGTH(2) and BYTEORDER (first)  for octetstring
 699 .*---------------------------------------------------------------------*
 700 :xmp tab=0.
 701
 702 <TC-    FIELDLENGTH(2) and BYTEORDER (first)  for octetstring>
 703
 704 <STATIC>
 705
 706 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 707 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 708
 709 type octetstring RAW_PDU
 710 with { variant "FIELDLENGTH(2)";
 711        variant "BYTEORDER (first)";
 712        encode "RAW"
 713      };
 714
 715 const RAW_PDU           i := '1234'O
 716 const octetstring       o := '1234'O
 717
 718 <TTCN_TC:EXEC>
 719
 720 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 721 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 722
 723 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 724   else {setverdict(fail);}
 725
 726 <RESULT>
 727
 728 Overall verdict: pass
 729
 730 <END_TC>
 731
 732 :exmp.
 733
 734 .*---------------------------------------------------------------------*
 735 :h3.   FIELDLENGTH(2) and BYTEORDER (last)  for octetstring
 736 .*---------------------------------------------------------------------*
 737 :xmp tab=0.
 738
 739 <TC-    FIELDLENGTH(2) and BYTEORDER (last)  for octetstring>
 740
 741 <STATIC>
 742
 743 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 744 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 745
 746 type octetstring RAW_PDU
 747 with { encode "RAW";
 748        variant "FIELDLENGTH(2)";
 749        variant "BYTEORDER (last)"
 750      };
 751
 752 const RAW_PDU           i := '1234'O
 753 const octetstring       o := '3412'O
 754
 755 <TTCN_TC:EXEC>
 756
 757 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 758 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 759
 760 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 761   else {setverdict(fail);}
 762
 763 <RESULT>
 764
 765 Overall verdict: pass
 766
 767 <END_TC>
 768
 769 :exmp.
 770
 771 .*---------------------------------------------------------------------*
 772 :h3.   FIELDLENGTH(4) and  BYTEORDER (first) for octetstring
 773 .*---------------------------------------------------------------------*
 774 :xmp tab=0.
 775
 776 <TC-    FIELDLENGTH(4) and  BYTEORDER (first) for octetstring>
 777
 778 <STATIC>
 779
 780 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 781 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 782
 783 type octetstring RAW_PDU
 784 with { encode "RAW";
 785        variant "FIELDLENGTH(4)";
 786        variant "BYTEORDER (first)"
 787      };
 788
 789 const RAW_PDU           i := '12345678'O
 790 const octetstring       o := '12345678'O
 791
 792 <TTCN_TC:EXEC>
 793
 794 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 795 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 796
 797 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 798   else {setverdict(fail);}
 799
 800 <RESULT>
 801
 802 Overall verdict: pass
 803
 804 <END_TC>
 805
 806 :exmp.
 807
 808 .*---------------------------------------------------------------------*
 809 :h3.   FIELDLENGTH(4)  for octetstring 3 octets long
 810 .*---------------------------------------------------------------------*
 811 :xmp tab=0.
 812
 813 <TC-    FIELDLENGTH(4)  for octetstring 3 octets long>
 814
 815 <STATIC>
 816
 817 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 818 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 819
 820 type octetstring RAW_PDU
 821 with { encode "RAW";
 822        variant "FIELDLENGTH(4)";
 823        variant "BYTEORDER (first)"
 824      };
 825
 826 const RAW_PDU           i := '123456'O
 827 const octetstring       o := '12345600'O
 828
 829 <TTCN_TC:EXEC>
 830
 831 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 832 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 833
 834 if ((enc_RAW_PDU(i) == o)and((dec_RAW_PDU(o) == i & '00'O))) {setverdict(pass);}
 835   else {setverdict(fail);}
 836
 837 <RESULT>
 838
 839 Overall verdict: pass
 840
 841 <END_TC>
 842
 843 :exmp.
 844
 845 .*---------------------------------------------------------------------*
 846 :h3.   FIELDLENGTH(5)  for octetstring 2 octets long
 847 .*---------------------------------------------------------------------*
 848 :xmp tab=0.
 849
 850 <TC-    FIELDLENGTH(5)  for octetstring 2 octets long>
 851
 852 <STATIC>
 853
 854 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 855 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 856
 857 type octetstring RAW_PDU
 858 with { encode "RAW";
 859        variant "FIELDLENGTH(5)"
 860        };
 861
 862 const RAW_PDU           i := '1234'O
 863 const octetstring       o := '1234000000'O
 864
 865 <TTCN_TC:EXEC>
 866
 867 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 868 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 869
 870 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i & '000000'O )) {setverdict(pass);}
 871   else {setverdict(fail);}
 872
 873 <RESULT>
 874
 875 Overall verdict: pass
 876
 877 <END_TC>
 878
 879 :exmp.
 880
 881 .*---------------------------------------------------------------------*
 882 :h3.   FIELDLENGTH(4) and BYTEORDER (last)  for octetstring
 883 .*---------------------------------------------------------------------*
 884 :xmp tab=0.
 885
 886 <TC-    FIELDLENGTH(4) and BYTEORDER (last)  for octetstring>
 887
 888 <STATIC>
 889
 890 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 891 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 892
 893 type octetstring RAW_PDU
 894 with { encode "RAW";
 895        variant "FIELDLENGTH(4)";
 896        variant "BYTEORDER (last)"
 897      };
 898
 899 const RAW_PDU           i := '12345678'O
 900 const octetstring       o := '78563412'O
 901
 902 <TTCN_TC:EXEC>
 903
 904 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 905 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 906
 907 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 908   else {setverdict(fail);}
 909
 910 <RESULT>
 911
 912 Overall verdict: pass
 913
 914 <END_TC>
 915
 916 :exmp.
 917
 918 .*---------------------------------------------------------------------*
 919 :h3.   FIELDLENGTH(4) and BYTEORDER (last) for octetstring 3 octets long
 920 .*---------------------------------------------------------------------*
 921 :xmp tab=0.
 922
 923 <TC-    FIELDLENGTH(4) and BYTEORDER (last) for octetstring 3 octets long>
 924
 925 <STATIC>
 926
 927 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 928 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 929
 930 type octetstring RAW_PDU
 931 with { encode "RAW";
 932        variant "FIELDLENGTH(4)";
 933        variant "BYTEORDER (last)"
 934      };
 935
 936 const RAW_PDU           i := '123456'O
 937 const octetstring       o := '00563412'O
 938
 939 <TTCN_TC:EXEC>
 940
 941 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 942 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 943
 944 if ((enc_RAW_PDU(i) == o)and((dec_RAW_PDU(o) == i & '00'O))) {setverdict(pass);}
 945   else {setverdict(fail);}
 946
 947 <RESULT>
 948
 949 Overall verdict: pass
 950
 951 <END_TC>
 952
 953 :exmp.
 954
 955 .*---------------------------------------------------------------------*
 956 :h3.  Default  FIELDLENGTH  for octetstring
 957 .*---------------------------------------------------------------------*
 958 :xmp tab=0.
 959
 960 <TC-   Default  FIELDLENGTH  for octetstring>
 961
 962 <STATIC>
 963
 964 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
 965 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
 966
 967 type octetstring RAW_PDU
 968 with { encode "RAW";
 969        variant ""};
 970
 971 const RAW_PDU           i := '123456'O
 972 const octetstring       o := '123456'O
 973
 974 <TTCN_TC:EXEC>
 975
 976 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
 977 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
 978
 979 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
 980   else {setverdict(fail);}
 981
 982 <RESULT>
 983
 984 Overall verdict: pass
 985
 986 <END_TC>
 987
 988 :exmp.
 989
 990 .*---------------------------------------------------------------------*
 991 :h3.   FIELDLENGTH(0)  for octetstring
 992 .*---------------------------------------------------------------------*
 993 :xmp tab=0.
 994
 995 <TC-    FIELDLENGTH(0)  for octetstring>
 996
 997 <STATIC>
 998
 999 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1000 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1001
1002 type octetstring RAW_PDU
1003 with {encode "RAW";
1004       variant "FIELDLENGTH(0)"
1005       };
1006
1007 const RAW_PDU           i := '1234'O
1008 const octetstring       o := '1234'O
1009
1010 <TTCN_TC:EXEC>
1011
1012 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1013 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1014
1015 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1016   else {setverdict(fail);}
1017
1018 <RESULT>
1019
1020 Overall verdict: pass
1021
1022 <END_TC>
1023
1024 :exmp.
1025
1026 .*---------------------------------------------------------------------*
1027 :h3.   FIELDLENGTH(2)  for hexstring
1028 .*---------------------------------------------------------------------*
1029 :xmp tab=0.
1030
1031 <TC-    FIELDLENGTH(2)  for hexstring>
1032
1033 <STATIC>
1034
1035 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1036 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1037
1038 type hexstring RAW_PDU
1039 with { encode "RAW";
1040        variant "FIELDLENGTH(2)"};
1041
1042 const RAW_PDU           i := '0F'H
1043 const octetstring       o := 'F0'O
1044
1045 <TTCN_TC:EXEC>
1046
1047 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1048 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1049
1050 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1051   else {setverdict(fail);}
1052
1053 <RESULT>
1054
1055 Overall verdict: pass
1056
1057 <END_TC>
1058
1059 :exmp.
1060
1061 .*---------------------------------------------------------------------*
1062 :h3.   FIELDLENGTH(4)  for hexstring
1063 .*---------------------------------------------------------------------*
1064 :xmp tab=0.
1065
1066 <TC-    FIELDLENGTH(4)  for hexstring>
1067
1068 <STATIC>
1069
1070 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1071 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1072
1073 type hexstring RAW_PDU
1074 with {encode "RAW";
1075       variant "FIELDLENGTH(4)"};
1076
1077 const RAW_PDU           i := '1234'H
1078 const octetstring       o := '2143'O
1079
1080 <TTCN_TC:EXEC>
1081
1082 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1083 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1084
1085 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1086   else {setverdict(fail);}
1087
1088 <RESULT>
1089
1090 Overall verdict: pass
1091
1092 <END_TC>
1093
1094 :exmp.
1095
1096 .*---------------------------------------------------------------------*
1097 :h3.   FIELDLENGTH(8)  for hexstring
1098 .*---------------------------------------------------------------------*
1099 :xmp tab=0.
1100
1101 <TC-    FIELDLENGTH(8)  for hexstring>
1102
1103 <STATIC>
1104
1105 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1106 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1107
1108 type hexstring RAW_PDU
1109 with { encode "RAW";
1110        variant "FIELDLENGTH(8)"};
1111
1112 const RAW_PDU           i := '1234'H
1113 const octetstring       o := '21430000'O
1114
1115 <TTCN_TC:EXEC>
1116
1117 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1118 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1119
1120 if ((enc_RAW_PDU(i)  == o)and((dec_RAW_PDU(o) == i & '0000'H ))) {setverdict(pass);}
1121   else {setverdict(fail);}
1122
1123 <RESULT>
1124
1125 Overall verdict: pass
1126
1127 <END_TC>
1128
1129 :exmp.
1130
1131 .*---------------------------------------------------------------------*
1132 :h3.   FIELDLENGTH(2)  for hexstring longer
1133 .*---------------------------------------------------------------------*
1134 :xmp tab=0.
1135
1136 <TC-    FIELDLENGTH(2)  for hexstring longer>
1137
1138 <STATIC>
1139
1140 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1141 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1142
1143 type hexstring RAW_PDU
1144 with {encode "RAW";
1145       variant "FIELDLENGTH(2)"};
1146
1147 const RAW_PDU           i := '1234'H
1148 const octetstring       o := '1234'O
1149
1150 <TTCN_TC:EXEC>
1151
1152 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1153 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1154
1155 if ((enc_RAW_PDU(i)  == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1156   else {setverdict(fail);}
1157
1158 <RESULT>
1159
1160 Overall verdict: error
1161
1162 <END_TC>
1163
1164 :exmp.
1165
1166 .*---------------------------------------------------------------------*
1167 :h3.  Default FIELDLENGTH  for hexstring
1168 .*---------------------------------------------------------------------*
1169 :xmp tab=0.
1170
1171 <TC-   Default FIELDLENGTH  for hexstring>
1172
1173 <STATIC>
1174
1175 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1176 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1177
1178 type hexstring RAW_PDU
1179 with { encode "RAW";
1180        variant ""};
1181
1182 const RAW_PDU           i := '12345670'H
1183 const octetstring       o := '21436507'O
1184
1185 <TTCN_TC:EXEC>
1186
1187 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1188 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1189
1190 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1191   else {setverdict(fail);}
1192
1193 <RESULT>
1194
1195 Overall verdict: pass
1196
1197 <END_TC>
1198
1199 :exmp.
1200
1201 .*---------------------------------------------------------------------*
1202 :h3.   FIELDLENGTH(0)  for hexstring
1203 .*---------------------------------------------------------------------*
1204 :xmp tab=0.
1205
1206 <TC-    FIELDLENGTH(0)  for hexstring>
1207
1208 <STATIC>
1209
1210 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1211 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1212
1213 type hexstring RAW_PDU
1214 with { encode "RAW";
1215        variant "FIELDLENGTH(0)"};
1216
1217 const RAW_PDU           i := '123456'H
1218 const octetstring       o := '214365'O
1219
1220 <TTCN_TC:EXEC>
1221
1222 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1223 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1224
1225 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1226   else {setverdict(fail);}
1227
1228 <RESULT>
1229
1230 Overall verdict: pass
1231
1232 <END_TC>
1233
1234 :exmp.
1235
1236 .*---------------------------------------------------------------------*
1237 :h3.   FIELDLENGTH(12)  for hexstring 2 hex long
1238 .*---------------------------------------------------------------------*
1239 :xmp tab=0.
1240
1241 <TC-    FIELDLENGTH(12)  for hexstring 2 hex long>
1242
1243 <STATIC>
1244
1245 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1246 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1247
1248 type hexstring RAW_PDU
1249 with { encode "RAW";
1250        variant "FIELDLENGTH(12)"};
1251
1252 const RAW_PDU           i := '12'H
1253 const octetstring       o := '210000000000'O
1254
1255 <TTCN_TC:EXEC>
1256
1257 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1258 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1259
1260 if ((enc_RAW_PDU(i)  == o)and((dec_RAW_PDU(o) == i & '0000000000'H ))) {setverdict(pass);}
1261   else {setverdict(fail);}
1262
1263 <RESULT>
1264
1265 Overall verdict: pass
1266
1267 <END_TC>
1268
1269 :exmp.
1270
1271 .*---------------------------------------------------------------------*
1272 :h3.   FIELDLENGTH (4) for enumerated
1273 .*---------------------------------------------------------------------*
1274 :xmp tab=0.
1275
1276 <TC-    FIELDLENGTH (4) for enumerated>
1277
1278 <STATIC>
1279
1280 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1281 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1282
1283 type enumerated RAW_PDU
1284   { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
1285   tenth  }
1286 with { variant "FIELDLENGTH(4)" ;
1287        encode "RAW"};
1288
1289 const RAW_PDU           i := first
1290 const octetstring       o := '01'O
1291
1292 <TTCN_TC:EXEC>
1293
1294 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1295 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1296
1297 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
1298   else {setverdict(fail);}
1299
1300 <RESULT>
1301
1302 Overall verdict: pass
1303
1304 <END_TC>
1305
1306 :exmp.
1307
1308 .*---------------------------------------------------------------------*
1309 :h3.   FIELDLENGTH(32)  for enumerated
1310 .*---------------------------------------------------------------------*
1311 :xmp tab=0.
1312
1313 <TC-    FIELDLENGTH(32)  for enumerated>
1314
1315 <STATIC>
1316
1317 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1318 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1319
1320 type enumerated RAW_PDU
1321   { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
1322   tenth  }
1323 with { variant "FIELDLENGTH(32)"
1324        encode "RAW";};
1325
1326 const RAW_PDU           i := first
1327 const octetstring       o := '01000000'O
1328
1329 <TTCN_TC:EXEC>
1330
1331 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1332 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1333
1334 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
1335   else {setverdict(fail);}
1336
1337 <RESULT>
1338
1339 Overall verdict: pass
1340
1341 <END_TC>
1342
1343 :exmp.
1344
1345 .*---------------------------------------------------------------------*
1346 :h3.  Default FIELDLENGTH  for enumerated
1347 .*---------------------------------------------------------------------*
1348 :xmp tab=0.
1349
1350 <TC-   Default FIELDLENGTH  for enumerated>
1351
1352 <STATIC>
1353
1354 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1355 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1356
1357 type enumerated RAW_PDU
1358   { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
1359   tenth  }
1360 with { variant ""
1361        encode "RAW";};
1362
1363 const RAW_PDU           i := tenth
1364 const octetstring       o := '0A'O
1365
1366 <TTCN_TC:EXEC>
1367
1368 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1369 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1370
1371 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
1372   else {setverdict(fail);}
1373
1374 <RESULT>
1375
1376 Overall verdict: pass
1377
1378 <END_TC>
1379
1380 :exmp.
1381
1382 .*---------------------------------------------------------------------*
1383 :h3.  FIELDLENGTH with length restriction - bitstring
1384 .*---------------------------------------------------------------------*
1385 :xmp tab=0.
1386
1387 <TC-   FIELDLENGTH with length restriction bitstring>
1388
1389 <STATIC>
1390
1391 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1392 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1393
1394
1395 type bitstring RAW_PDU length (4);
1396
1397 const octetstring       o := '0F'O
1398 const RAW_PDU   i := '1111'B
1399
1400
1401 <TTCN_TC:EXEC>
1402
1403 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1404 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1405
1406 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
1407   else {setverdict(fail);}
1408
1409 <RESULT>
1410
1411 Overall verdict: pass
1412
1413 <END_TC>
1414
1415 :exmp.
1416
1417 .*---------------------------------------------------------------------*
1418 :h3.  FIELDLENGTH with length restriction - hexstring
1419 .*---------------------------------------------------------------------*
1420 :xmp tab=0.
1421
1422 <TC-   FIELDLENGTH with length restriction hexstring>
1423
1424 <STATIC>
1425
1426 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1427 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1428
1429
1430 type hexstring RAW_PDU length (0);
1431
1432 const octetstring       o := ''O
1433 const RAW_PDU   i := ''H
1434
1435
1436 <TTCN_TC:EXEC>
1437
1438 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1439 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1440
1441 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
1442   else {setverdict(fail);}
1443
1444 <RESULT>
1445
1446 Overall verdict: pass
1447
1448 <END_TC>
1449
1450 :exmp.
1451
1452 .*---------------------------------------------------------------------*
1453 :h3.  FIELDLENGTH with length restriction - octetstring
1454 .*---------------------------------------------------------------------*
1455 :xmp tab=0.
1456
1457 <TC-   FIELDLENGTH with length restriction hexstring>
1458
1459 <STATIC>
1460
1461 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1462 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1463
1464
1465 type octetstring RAW_PDU length (2 .. 2);
1466
1467 const octetstring       o := '1122'O
1468 const RAW_PDU   i := '1122'O
1469
1470
1471 <TTCN_TC:EXEC>
1472
1473 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1474 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1475
1476 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
1477   else {setverdict(fail);}
1478
1479 <RESULT>
1480
1481 Overall verdict: pass
1482
1483 <END_TC>
1484
1485 :exmp.
1486
1487 .*---------------------------------------------------------------------*
1488 :h3.  FIELDLENGTH with length restriction - record
1489 .*---------------------------------------------------------------------*
1490 :xmp tab=0.
1491
1492 <TC-   FIELDLENGTH with length restriction record>
1493
1494 <STATIC>
1495
1496 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1497 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1498
1499
1500
1501 type bitstring btype length (4)
1502 type hexstring htype length (5)
1503 type octetstring otype length (2 .. 2)
1504
1505 type record RAW_PDU {btype b, htype h, otype o}
1506 with {encode "RAW"; variant  ""};
1507
1508 const octetstring       o := '1932541122'O
1509 const RAW_PDU   i := {'1001'B,'12345'H, '1122'O}
1510
1511 <TTCN_TC:EXEC>
1512
1513 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1514 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1515
1516 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
1517   else {setverdict(fail);}
1518
1519 <RESULT>
1520
1521 Overall verdict: pass
1522
1523 <END_TC>
1524
1525 :exmp.
1526
1527 .*---------------------------------------------------------------------*
1528 :h3.  FIELDLENGTH with length restriction - record of
1529 .*---------------------------------------------------------------------*
1530 :xmp tab=0.
1531
1532 <TC-   FIELDLENGTH with length restriction record of>
1533
1534 <STATIC>
1535
1536 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1537 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1538
1539
1540 type bitstring btype length (12 .. 12)
1541
1542 type record length (2 .. 2) of btype  RAW_PDU
1543 with {encode "RAW"; variant  ""};
1544
1545 const RAW_PDU   i := {'000011111111'B, '111100001111'B}
1546 const octetstring       o := 'FFF0F0'O
1547
1548 <TTCN_TC:EXEC>
1549
1550 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1551 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1552
1553 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
1554   else {setverdict(fail);}
1555
1556 <RESULT>
1557
1558 Overall verdict: pass
1559
1560 <END_TC>
1561
1562 :exmp.
1563
1564 .*---------------------------------------------------------------------*
1565 :h3.  FIELDLENGTH with length restriction - set
1566 .*---------------------------------------------------------------------*
1567 :xmp tab=0.
1568
1569 <TC-   FIELDLENGTH with length restriction set>
1570
1571 <STATIC>
1572
1573 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1574 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1575
1576
1577
1578 type bitstring btype length (1)
1579 type hexstring htype length (4)
1580 type octetstring otype length (2 .. 2)
1581
1582 type set RAW_PDU {htype h, otype o, btype b}
1583 with {encode "RAW"; variant  ""};
1584
1585 const octetstring       o := '2143112201'O
1586 const RAW_PDU   i := {h := '1234'H, o := '1122'O, b := '1'B}
1587
1588 <TTCN_TC:EXEC>
1589
1590 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1591 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1592
1593 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
1594   else {setverdict(fail);}
1595
1596 <RESULT>
1597
1598 Overall verdict: pass
1599
1600 <END_TC>
1601
1602 :exmp.
1603
1604 .*---------------------------------------------------------------------*
1605 :h3.  FIELDLENGTH with length restriction - set of
1606 .*---------------------------------------------------------------------*
1607 :xmp tab=0.
1608
1609 <TC-   FIELDLENGTH with length restriction set of>
1610
1611 <STATIC>
1612
1613 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1614 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1615
1616
1617 type bitstring btype length (12 .. 12)
1618
1619 type set length (2 .. 2) of btype  RAW_PDU
1620 with {encode "RAW"; variant  ""};
1621
1622 const RAW_PDU   i := {'000011111111'B, '111100001111'B}
1623 const octetstring       o := 'FFF0F0'O
1624
1625 <TTCN_TC:EXEC>
1626
1627 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1628 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1629
1630 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
1631   else {setverdict(fail);}
1632
1633 <RESULT>
1634
1635 Overall verdict: pass
1636
1637 <END_TC>
1638
1639 :exmp.
1640
1641 .*---------------------------------------------------------------------*
1642 :h3.  FIELDLENGTH with length restriction and ALIGN - bitstring
1643 .*---------------------------------------------------------------------*
1644 :xmp tab=0.
1645
1646 <TC-   FIELDLENGTH with length restriction and ALIGN - bitstring>
1647
1648 <STATIC>
1649
1650 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1651 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1652
1653
1654 type bitstring RAW_PDU length (9 .. 9)
1655 with {encode "RAW"; variant "ALIGN(left)"}
1656
1657
1658 const RAW_PDU   i := '111100001'B
1659 const octetstring       o := 'E101'O
1660
1661 <TTCN_TC:EXEC>
1662
1663 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1664 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1665
1666 if ((dec_RAW_PDU(o) == i )) {setverdict(pass);} else {setverdict(fail);}
1667
1668
1669 <RESULT>
1670
1671 Overall verdict: pass
1672
1673 <END_TC>
1674
1675 :exmp.
1676
1677 .*---------------------------------------------------------------------*
1678 :h3.  FIELDLENGTH with length restriction and ALIGN - hexstring
1679 .*---------------------------------------------------------------------*
1680 :xmp tab=0.
1681
1682 <TC-   FIELDLENGTH with length restriction and ALIGN - hexstring>
1683
1684 <STATIC>
1685
1686 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1687 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1688
1689
1690 type hexstring RAW_PDU length (10 .. 10)
1691 with {encode "RAW"; variant "ALIGN(right), BITORDERINOCTET(lsb)"}
1692
1693
1694 const RAW_PDU   i := '0000012345'H
1695 const octetstring       o := '0000103254000000'O
1696
1697 <TTCN_TC:EXEC>
1698
1699 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1700 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1701
1702 if ((dec_RAW_PDU(o) == i )) {setverdict(pass);} else {setverdict(fail);}
1703
1704
1705 <RESULT>
1706
1707 Overall verdict: pass
1708
1709 <END_TC>
1710
1711 :exmp.
1712
1713
1714 .*---------------------------------------------------------------------*
1715 :h3.  FIELDLENGTH with length restriction and ALIGN - octetstring
1716 .*---------------------------------------------------------------------*
1717 :xmp tab=0.
1718
1719 <TC-   FIELDLENGTH with length restriction and ALIGN - octetstring>
1720
1721 <STATIC>
1722
1723 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1724 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1725
1726
1727 type octetstring RAW_PDU length (8 .. 8)
1728 with {encode "RAW"; variant "ALIGN(left)"}
1729
1730
1731 const RAW_PDU   i := '0102030400000000'O
1732 const octetstring       o := '010203040000000000000000000000'O
1733
1734 <TTCN_TC:EXEC>
1735
1736 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1737 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1738
1739 if ((dec_RAW_PDU(o) == i )) {setverdict(pass);} else {setverdict(fail);}
1740
1741 <RESULT>
1742
1743 Overall verdict: pass
1744
1745 <END_TC>
1746
1747 :exmp.
1748
1749 .*---------------------------------------------------------------------*
1750 :h2.Testing BYTEORDER Attribute
1751 .*---------------------------------------------------------------------*
1752
1753 .*---------------------------------------------------------------------*
1754 :h3.   BYTEORDER(first)  for integer 0
1755 .*---------------------------------------------------------------------*
1756 :xmp tab=0.
1757
1758 <TC-    BYTEORDER(first)  for integer 0>
1759
1760 <STATIC>
1761
1762 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1763 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1764
1765 type integer RAW_PDU
1766 with { encode "RAW"; variant "BYTEORDER (first)"  };
1767
1768 const RAW_PDU           i := 0
1769 const octetstring       o := '00'O
1770
1771 <TTCN_TC:EXEC>
1772
1773 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1774 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1775
1776 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1777   else {setverdict(fail);}
1778
1779 <RESULT>
1780
1781 Overall verdict: pass
1782
1783 <END_TC>
1784
1785 :exmp.
1786
1787 .*---------------------------------------------------------------------*
1788 :h3.   BYTEORDER(first)  for integer
1789 .*---------------------------------------------------------------------*
1790 :xmp tab=0.
1791
1792 <TC-    BYTEORDER(first)  for integer>
1793
1794 <STATIC>
1795
1796 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1797 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1798
1799 type integer RAW_PDU
1800 with { encode "RAW"; variant "BYTEORDER (first)"  };
1801
1802 const RAW_PDU           i := 1
1803 const octetstring       o := '01'O
1804
1805 <TTCN_TC:EXEC>
1806
1807 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1808 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1809
1810 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1811   else {setverdict(fail);}
1812
1813 <RESULT>
1814
1815 Overall verdict: pass
1816
1817 <END_TC>
1818
1819 :exmp.
1820
1821 .*---------------------------------------------------------------------*
1822 :h3.   BYTEORDER(first)  for integer
1823 .*---------------------------------------------------------------------*
1824 :xmp tab=0.
1825
1826 <TC-    BYTEORDER(first)  for integer>
1827
1828 <STATIC>
1829
1830 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1831 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1832
1833 type integer RAW_PDU
1834 with { encode "RAW"; variant "BYTEORDER (first)"  };
1835
1836 const RAW_PDU           i := 18
1837 const octetstring       o := '12'O
1838
1839 <TTCN_TC:EXEC>
1840
1841 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1842 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1843
1844 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1845   else {setverdict(fail);}
1846
1847 <RESULT>
1848
1849 Overall verdict: pass
1850
1851 <END_TC>
1852
1853 :exmp.
1854
1855 .*---------------------------------------------------------------------*
1856 :h3.   BYTEORDER(first) and FIELDLENGTH (8)  for integer
1857 .*---------------------------------------------------------------------*
1858 :xmp tab=0.
1859
1860 <TC-    BYTEORDER(first) and FIELDLENGTH (8)  for integer>
1861
1862 <STATIC>
1863
1864 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1865 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1866
1867 type integer RAW_PDU
1868 with { encode "RAW" ;
1869        variant "FIELDLENGTH (8)" ;
1870        variant "BYTEORDER (first)" };
1871
1872 const RAW_PDU           i := 15
1873 const octetstring       o := '0F'O
1874
1875 <TTCN_TC:EXEC>
1876
1877 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1878 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1879
1880 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1881   else {setverdict(fail);}
1882
1883 <RESULT>
1884
1885 Overall verdict: pass
1886
1887 <END_TC>
1888
1889 :exmp.
1890
1891 .*---------------------------------------------------------------------*
1892 :h3.   BYTEORDER(first) and  FIELDLENGTH(16)for integer
1893 .*---------------------------------------------------------------------*
1894 :xmp tab=0.
1895
1896 <TC-    BYTEORDER(first) and  FIELDLENGTH(16)for integer>
1897
1898 <STATIC>
1899
1900 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1901 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1902
1903 type integer RAW_PDU
1904 with { encode "RAW" ;
1905        variant "FIELDLENGTH(16)" ;
1906        variant "BYTEORDER (first)" };
1907
1908 const RAW_PDU           i := 15
1909 const octetstring       o := '0F00'O
1910
1911 <TTCN_TC:EXEC>
1912
1913 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1914 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1915
1916 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1917   else {setverdict(fail);}
1918
1919 <RESULT>
1920
1921 Overall verdict: pass
1922
1923 <END_TC>
1924
1925 :exmp.
1926
1927 .*---------------------------------------------------------------------*
1928 :h3.   BYTEORDER(last)  for integer 0
1929 .*---------------------------------------------------------------------*
1930 :xmp tab=0.
1931
1932 <TC-    BYTEORDER(last)  for integer 0>
1933
1934 <STATIC>
1935
1936 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1937 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1938
1939 type integer RAW_PDU
1940 with { encode "RAW"; variant "BYTEORDER (last)"  };
1941
1942 const RAW_PDU           i := 0
1943 const octetstring       o := '00'O
1944
1945 <TTCN_TC:EXEC>
1946
1947 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1948 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1949
1950 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1951   else {setverdict(fail);}
1952
1953 <RESULT>
1954
1955 Overall verdict: pass
1956
1957 <END_TC>
1958
1959 :exmp.
1960
1961 .*---------------------------------------------------------------------*
1962 :h3.   BYTEORDER(last)  for integer
1963 .*---------------------------------------------------------------------*
1964 :xmp tab=0.
1965
1966 <TC-    BYTEORDER(last)  for integer>
1967
1968 <STATIC>
1969
1970 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
1971 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
1972
1973 type integer RAW_PDU
1974 with { encode "RAW"; variant "BYTEORDER (last)"  };
1975
1976 const RAW_PDU           i := 1
1977 const octetstring       o := '01'O
1978
1979 <TTCN_TC:EXEC>
1980
1981 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
1982 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
1983
1984 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
1985   else {setverdict(fail);}
1986
1987 <RESULT>
1988
1989 Overall verdict: pass
1990
1991 <END_TC>
1992
1993 :exmp.
1994
1995 .*---------------------------------------------------------------------*
1996 :h3.   BYTEORDER (last) for integer
1997 .*---------------------------------------------------------------------*
1998 :xmp tab=0.
1999
2000 <TC-    BYTEORDER (last) for integer>
2001
2002 <STATIC>
2003
2004 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2005 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2006
2007 type integer RAW_PDU
2008 with { encode "RAW"; variant "BYTEORDER (last)"  };
2009
2010 const RAW_PDU           i := 18
2011 const octetstring       o := '12'O
2012
2013 <TTCN_TC:EXEC>
2014
2015 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2016 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2017
2018 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2019   else {setverdict(fail);}
2020
2021 <RESULT>
2022
2023 Overall verdict: pass
2024
2025 <END_TC>
2026
2027 :exmp.
2028
2029 .*---------------------------------------------------------------------*
2030 :h3.   BYTEORDER(last) and FIELDLENGTH (8) for integer
2031 .*---------------------------------------------------------------------*
2032 :xmp tab=0.
2033
2034 <TC-    BYTEORDER(last) and FIELDLENGTH (8) for integer>
2035
2036 <STATIC>
2037
2038 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2039 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2040
2041 type integer RAW_PDU
2042 with { encode "RAW";
2043        variant "FIELDLENGTH (8)" ;
2044        variant "BYTEORDER (last)" };
2045
2046 const RAW_PDU           i := 15
2047 const octetstring       o := '0F'O
2048
2049 <TTCN_TC:EXEC>
2050
2051 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2052 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2053
2054 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2055   else {setverdict(fail);}
2056
2057 <RESULT>
2058
2059 Overall verdict: pass
2060
2061 <END_TC>
2062
2063 :exmp.
2064
2065 .*---------------------------------------------------------------------*
2066 :h3.   BYTEORDER(last) and FIELDLENGTH(16) for integer
2067 .*---------------------------------------------------------------------*
2068 :xmp tab=0.
2069
2070 <TC-    BYTEORDER(last) and FIELDLENGTH(16) for integer>
2071
2072 <STATIC>
2073
2074 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2075 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2076
2077 type integer RAW_PDU
2078 with { encode "RAW";
2079        variant "FIELDLENGTH(16)" ;
2080        variant "BYTEORDER (last)" };
2081
2082 const RAW_PDU           i := 15
2083 const octetstring       o := '000F'O
2084
2085 <TTCN_TC:EXEC>
2086
2087 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2088 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2089
2090 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2091   else {setverdict(fail);}
2092
2093 <RESULT>
2094
2095 Overall verdict: pass
2096
2097 <END_TC>
2098
2099 :exmp.
2100
2101 .*---------------------------------------------------------------------*
2102 :h3.   BYTEORDER(first)  for bitstring
2103 .*---------------------------------------------------------------------*
2104 :xmp tab=0.
2105
2106 <TC-    BYTEORDER(first)  for bitstring>
2107
2108 <STATIC>
2109
2110 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2111 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2112
2113 type bitstring RAW_PDU
2114 with { encode "RAW";
2115        variant "FIELDLENGTH(16)" ;
2116        variant "BYTEORDER (first)" };
2117
2118 const RAW_PDU           i := '0000000100000010'B
2119 const octetstring       o := '0201'O
2120
2121 <TTCN_TC:EXEC>
2122
2123 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2124 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2125
2126 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2127   else {setverdict(fail);}
2128
2129 <RESULT>
2130
2131 Overall verdict: pass
2132
2133 <END_TC>
2134
2135 :exmp.
2136
2137 .*---------------------------------------------------------------------*
2138 :h3.   BYTEORDER(last)  for bitstring
2139 .*---------------------------------------------------------------------*
2140 :xmp tab=0.
2141
2142 <TC-    BYTEORDER(last)  for bitstring>
2143
2144 <STATIC>
2145
2146 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2147 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2148
2149 type bitstring RAW_PDU
2150 with { encode "RAW";
2151        variant "FIELDLENGTH(16)" ;
2152        variant "BYTEORDER (last)" };
2153
2154 const RAW_PDU           i := '0000000100000010'B
2155 const octetstring       o := '0102'O
2156
2157 <TTCN_TC:EXEC>
2158
2159 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2160 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2161
2162 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2163   else {setverdict(fail);}
2164
2165 <RESULT>
2166
2167 Overall verdict: pass
2168
2169 <END_TC>
2170
2171 :exmp.
2172
2173 .*---------------------------------------------------------------------*
2174 :h3.   BYTEORDER(first)  for octetstring
2175 .*---------------------------------------------------------------------*
2176 :xmp tab=0.
2177
2178 <TC-    BYTEORDER(first)  for octetstring>
2179
2180 <STATIC>
2181
2182 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2183 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2184
2185 type octetstring RAW_PDU
2186 with { encode "RAW";
2187        variant "BYTEORDER (first)"};
2188
2189 const RAW_PDU           i := '1234'O
2190 const octetstring       o := '1234'O
2191
2192 <TTCN_TC:EXEC>
2193
2194 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2195 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2196
2197 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2198   else {setverdict(fail);}
2199
2200 <RESULT>
2201
2202 Overall verdict: pass
2203
2204 <END_TC>
2205
2206 :exmp.
2207
2208 .*---------------------------------------------------------------------*
2209 :h3.   BYTEORDER(last)  for octetstring
2210 .*---------------------------------------------------------------------*
2211 :xmp tab=0.
2212
2213 <TC-    BYTEORDER(last)  for octetstring>
2214
2215 <STATIC>
2216
2217 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2218 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2219
2220 type octetstring RAW_PDU
2221 with { encode "RAW";
2222        variant "BYTEORDER (last)"};
2223
2224 const RAW_PDU           i := '1234'O
2225 const octetstring       o := '3412'O
2226
2227 <TTCN_TC:EXEC>
2228
2229 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2230 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2231
2232 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2233   else {setverdict(fail);}
2234
2235 <RESULT>
2236
2237 Overall verdict: pass
2238
2239 <END_TC>
2240
2241 :exmp.
2242
2243
2244 .*---------------------------------------------------------------------*
2245 :h3.   BYTEORDER(first)  for enumerated
2246 .*---------------------------------------------------------------------*
2247 :xmp tab=0.
2248
2249 <TC-    BYTEORDER(first)  for enumerated>
2250
2251 <STATIC>
2252
2253 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2254 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2255
2256 type enumerated RAW_PDU
2257   { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
2258   tenth  }
2259 with { encode "RAW";
2260        variant "FIELDLENGTH(16)" ;
2261        variant "BYTEORDER (first) "};
2262
2263 const RAW_PDU           i := first
2264 const octetstring       o := '0100'O
2265
2266 <TTCN_TC:EXEC>
2267
2268 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2269 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2270
2271 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
2272   else {setverdict(fail);}
2273
2274 <RESULT>
2275
2276 Overall verdict: pass
2277
2278 <END_TC>
2279
2280 :exmp.
2281
2282 .*---------------------------------------------------------------------*
2283 :h3.   BYTEORDER(last)  for enumerated
2284 .*---------------------------------------------------------------------*
2285 :xmp tab=0.
2286
2287 <TC-    BYTEORDER(last)  for enumerated>
2288
2289 <STATIC>
2290
2291 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2292 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2293
2294 type enumerated RAW_PDU
2295   { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
2296   tenth  }
2297 with { encode "RAW";
2298        variant "FIELDLENGTH(16)" ;
2299        variant "BYTEORDER (last) "};
2300
2301 const RAW_PDU           i := first
2302 const octetstring       o := '0001'O
2303
2304 <TTCN_TC:EXEC>
2305
2306 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2307 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2308
2309 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
2310   else {setverdict(fail);}
2311
2312 <RESULT>
2313
2314 Overall verdict: pass
2315
2316 <END_TC>
2317
2318 :exmp.
2319
2320 .*---------------------------------------------------------------------*
2321 :h3.   BYTEORDER(first)  for hexstring
2322 .*---------------------------------------------------------------------*
2323 :xmp tab=0.
2324
2325 <TC-    BYTEORDER(first)  for hexstring>
2326
2327 <STATIC>
2328
2329 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2330 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2331
2332 type hexstring RAW_PDU
2333 with { encode "RAW"; variant "BYTEORDER(first)"};
2334
2335 const RAW_PDU           i := '1234567890'H
2336 const octetstring       o := '2143658709'O
2337
2338 <TTCN_TC:EXEC>
2339
2340 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2341 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2342
2343 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2344   else {setverdict(fail);}
2345
2346 <RESULT>
2347
2348 Overall verdict: pass
2349
2350 <END_TC>
2351
2352 :exmp.
2353
2354 .*---------------------------------------------------------------------*
2355 :h3.   BYTEORDER(last)  for hexstring
2356 .*---------------------------------------------------------------------*
2357 :xmp tab=0.
2358
2359 <TC-    BYTEORDER(last)  for hexstring>
2360
2361 <STATIC>
2362
2363 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2364 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2365
2366 type hexstring RAW_PDU
2367 with { encode "RAW"; variant "BYTEORDER(last)"};
2368
2369 const RAW_PDU           i := '1234567890'H
2370 const octetstring       o := '0987654321'O
2371
2372 <TTCN_TC:EXEC>
2373
2374 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2375 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2376
2377 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2378   else {setverdict(fail);}
2379
2380 <RESULT>
2381
2382 Overall verdict: pass
2383
2384 <END_TC>
2385
2386 :exmp.
2387
2388 .*---------------------------------------------------------------------*
2389 :h2.Testing BITORDERINFIELD Attribute
2390 .*---------------------------------------------------------------------*
2391 .*---------------------------------------------------------------------*
2392 :h3.   BITORDERINFIELD(lsb)  for integer
2393 .*---------------------------------------------------------------------*
2394 :xmp tab=0.
2395
2396 <TC-    BITORDERINFIELD(lsb)  for integer>
2397
2398 <STATIC>
2399
2400 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2401 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2402
2403 type integer RAW_PDU
2404 with { encode "RAW";
2405        variant "FIELDLENGTH(8)" ;
2406        variant "BITORDERINFIELD(lsb)"};
2407
2408 const RAW_PDU           i := 15
2409 const octetstring       o := '0F'O
2410
2411 <TTCN_TC:EXEC>
2412
2413 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2414 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2415
2416 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2417   else {setverdict(fail);}
2418
2419 <RESULT>
2420
2421 Overall verdict: pass
2422
2423 <END_TC>
2424
2425 :exmp.
2426
2427 .*---------------------------------------------------------------------*
2428 :h3.   BITORDERINFIELD(msb)  for integer
2429 .*---------------------------------------------------------------------*
2430 :xmp tab=0.
2431
2432 <TC-    BITORDERINFIELD(msb)  for integer>
2433
2434 <STATIC>
2435
2436 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2437 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2438
2439 type integer RAW_PDU
2440 with { encode "RAW";
2441        variant "FIELDLENGTH(8)" ;
2442        variant "BITORDERINFIELD(msb)"};
2443
2444 const RAW_PDU           i := 15
2445 const octetstring       o := 'F0'O
2446
2447 <TTCN_TC:EXEC>
2448
2449 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2450 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2451
2452 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2453   else {setverdict(fail);}
2454
2455 <RESULT>
2456
2457 Overall verdict: pass
2458
2459 <END_TC>
2460
2461 :exmp.
2462
2463 .*---------------------------------------------------------------------*
2464 :h3.   BITORDERINFIELD(lsb)  for integer
2465 .*---------------------------------------------------------------------*
2466 :xmp tab=0.
2467
2468 <TC-    BITORDERINFIELD(lsb)  for integer>
2469
2470 <STATIC>
2471
2472 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2473 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2474
2475 type integer RAW_PDU
2476 with { encode "RAW";
2477        variant "FIELDLENGTH(16)" ;
2478        variant "BITORDERINFIELD(lsb)"};
2479
2480 const RAW_PDU           i := 4660
2481 const octetstring       o := '3412'O
2482
2483 <TTCN_TC:EXEC>
2484
2485 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2486 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2487
2488 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2489   else {setverdict(fail);}
2490
2491 <RESULT>
2492
2493 Overall verdict: pass
2494
2495 <END_TC>
2496
2497 :exmp.
2498
2499 .*---------------------------------------------------------------------*
2500 :h3.   BITORDERINFIELD(msb)  for integer
2501 .*---------------------------------------------------------------------*
2502 :xmp tab=0.
2503
2504 <TC-    BITORDERINFIELD(msb)  for integer>
2505
2506 <STATIC>
2507
2508 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2509 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2510
2511 type integer RAW_PDU
2512 with { encode "RAW";
2513        variant "FIELDLENGTH(16)" ;
2514        variant "BITORDERINFIELD(msb)"};
2515
2516 const RAW_PDU           i := 4660
2517 const octetstring       o := '482C'O
2518
2519 <TTCN_TC:EXEC>
2520
2521 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2522 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2523
2524 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2525   else {setverdict(fail);}
2526
2527 <RESULT>
2528
2529 Overall verdict: pass
2530
2531 <END_TC>
2532
2533 :exmp.
2534
2535 .*---------------------------------------------------------------------*
2536 :h3.   BITORDERINFIELD(lsb)  for octetstring
2537 .*---------------------------------------------------------------------*
2538 :xmp tab=0.
2539
2540 <TC-    BITORDERINFIELD(lsb)  for octetstring>
2541
2542 <STATIC>
2543
2544 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2545 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2546
2547 type octetstring RAW_PDU
2548 with { encode "RAW";
2549        variant "FIELDLENGTH(1)" ;
2550        variant "BITORDERINFIELD(lsb)"};
2551
2552 const RAW_PDU           i := '0F'O
2553 const octetstring       o := '0F'O
2554
2555 <TTCN_TC:EXEC>
2556
2557 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2558 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2559
2560 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2561   else {setverdict(fail);}
2562
2563 <RESULT>
2564
2565 Overall verdict: pass
2566
2567 <END_TC>
2568
2569 :exmp.
2570
2571 .*---------------------------------------------------------------------*
2572 :h3.   BITORDERINFIELD(msb)  for octetstring
2573 .*---------------------------------------------------------------------*
2574 :xmp tab=0.
2575
2576 <TC-    BITORDERINFIELD(msb)  for octetstring>
2577
2578 <STATIC>
2579
2580 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2581 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2582
2583 type octetstring RAW_PDU
2584 with { encode "RAW";
2585        variant "FIELDLENGTH(1)" ;
2586        variant "BITORDERINFIELD(msb)"};
2587
2588 const RAW_PDU           i := '0F'O
2589 const octetstring       o := 'F0'O
2590
2591 <TTCN_TC:EXEC>
2592
2593 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2594 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2595
2596 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2597   else {setverdict(fail);}
2598
2599 <RESULT>
2600
2601 Overall verdict: pass
2602
2603 <END_TC>
2604
2605 :exmp.
2606
2607 .*---------------------------------------------------------------------*
2608 :h3.   BITORDERINFIELD(lsb)  for octetstring
2609 .*---------------------------------------------------------------------*
2610 :xmp tab=0.
2611
2612 <TC-    BITORDERINFIELD(lsb)  for octetstring>
2613
2614 <STATIC>
2615
2616 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2617 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2618
2619 type octetstring RAW_PDU
2620 with { encode "RAW";
2621        variant "FIELDLENGTH(2)" ;
2622        variant "BITORDERINFIELD(lsb)"};
2623
2624 const RAW_PDU           i := '1234'O
2625 const octetstring       o := '1234'O
2626
2627 <TTCN_TC:EXEC>
2628
2629 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2630 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2631
2632 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2633   else {setverdict(fail);}
2634
2635 <RESULT>
2636
2637 Overall verdict: pass
2638
2639 <END_TC>
2640
2641 :exmp.
2642
2643 .*---------------------------------------------------------------------*
2644 :h3.   BITORDERINFIELD(msb)  for octetstring
2645 .*---------------------------------------------------------------------*
2646 :xmp tab=0.
2647
2648 <TC-    BITORDERINFIELD(msb)  for octetstring>
2649
2650 <STATIC>
2651
2652 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2653 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2654
2655 type octetstring RAW_PDU
2656 with { encode "RAW";
2657        variant "FIELDLENGTH(2)" ;
2658        variant "BITORDERINFIELD(msb)"};
2659
2660 const RAW_PDU           i := '1234'O
2661 const octetstring       o := '2C48'O
2662
2663 <TTCN_TC:EXEC>
2664
2665 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2666 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2667
2668 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2669   else {setverdict(fail);}
2670
2671 <RESULT>
2672
2673 Overall verdict: pass
2674
2675 <END_TC>
2676
2677 :exmp.
2678
2679 .*---------------------------------------------------------------------*
2680 :h3.   BITORDERINFIELD(lsb)  for bitstring
2681 .*---------------------------------------------------------------------*
2682 :xmp tab=0.
2683
2684 <TC-    BITORDERINFIELD(lsb)  for bitstring>
2685
2686 <STATIC>
2687
2688 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2689 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2690
2691 type bitstring RAW_PDU
2692 with { encode "RAW";
2693        variant "FIELDLENGTH(8)" ;
2694        variant "BITORDERINFIELD(lsb)"};
2695
2696 const RAW_PDU           i := '00000011'B
2697 const octetstring       o := '03'O
2698
2699 <TTCN_TC:EXEC>
2700
2701 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2702 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2703
2704 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2705   else {setverdict(fail);}
2706
2707 <RESULT>
2708
2709 Overall verdict: pass
2710
2711 <END_TC>
2712
2713 :exmp.
2714
2715 .*---------------------------------------------------------------------*
2716 :h3.   BITORDERINFIELD(msb)  for bitstring
2717 .*---------------------------------------------------------------------*
2718 :xmp tab=0.
2719
2720 <TC-    BITORDERINFIELD(msb)  for bitstring>
2721
2722 <STATIC>
2723
2724 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2725 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2726
2727 type bitstring RAW_PDU
2728 with { encode "RAW";
2729        variant "FIELDLENGTH(8)" ;
2730        variant "BITORDERINFIELD(msb)"};
2731
2732 const RAW_PDU           i := '00000011'B
2733 const octetstring       o := 'C0'O
2734
2735 <TTCN_TC:EXEC>
2736
2737 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2738 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2739
2740 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2741   else {setverdict(fail);}
2742
2743 <RESULT>
2744
2745 Overall verdict: pass
2746
2747 <END_TC>
2748
2749 :exmp.
2750
2751 .*---------------------------------------------------------------------*
2752 :h3.   BITORDERINFIELD(lsb)  for bitstring
2753 .*---------------------------------------------------------------------*
2754 :xmp tab=0.
2755
2756 <TC-    BITORDERINFIELD(lsb)  for bitstring>
2757
2758 <STATIC>
2759
2760 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2761 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2762
2763 type bitstring RAW_PDU
2764 with { encode "RAW";
2765        variant "FIELDLENGTH(16)" ;
2766        variant "BITORDERINFIELD(lsb)"};
2767
2768 const RAW_PDU           i := '0001111100110001'B
2769 const octetstring       o := '311F'O
2770
2771 <TTCN_TC:EXEC>
2772
2773 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2774 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2775
2776 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2777   else {setverdict(fail);}
2778
2779 <RESULT>
2780
2781 Overall verdict: pass
2782
2783 <END_TC>
2784
2785 :exmp.
2786
2787 .*---------------------------------------------------------------------*
2788 :h3.   BITORDERINFIELD(msb)  for bitstring
2789 .*---------------------------------------------------------------------*
2790 :xmp tab=0.
2791
2792 <TC-    BITORDERINFIELD(msb)  for bitstring>
2793
2794 <STATIC>
2795
2796 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2797 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2798
2799 type bitstring RAW_PDU
2800 with { encode "RAW";
2801        variant "FIELDLENGTH(16)" ;
2802        variant "BITORDERINFIELD(msb)"};
2803
2804 const RAW_PDU           i := '0001111100110001'B
2805 const octetstring       o := 'F88C'O
2806
2807 <TTCN_TC:EXEC>
2808
2809 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2810 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2811
2812 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2813   else {setverdict(fail);}
2814
2815 <RESULT>
2816
2817 Overall verdict: pass
2818
2819 <END_TC>
2820
2821 :exmp.
2822
2823 .*---------------------------------------------------------------------*
2824 :h3.   BITORDERINFIELD(lsb)  for enumerated
2825 .*---------------------------------------------------------------------*
2826 :xmp tab=0.
2827
2828 <TC-    BITORDERINFIELD(lsb)  for enumerated>
2829
2830 <STATIC>
2831
2832 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2833 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2834
2835 type enumerated RAW_PDU
2836   { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
2837   tenth  }
2838 with { encode "RAW";
2839        variant "FIELDLENGTH(4)" ;
2840        variant "BITORDERINFIELD (lsb) "};
2841
2842 const RAW_PDU           i := first
2843 const octetstring       o := '01'O
2844
2845 <TTCN_TC:EXEC>
2846
2847 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2848 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2849
2850 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
2851   else {setverdict(fail);}
2852
2853 <RESULT>
2854
2855 Overall verdict: pass
2856
2857 <END_TC>
2858
2859 :exmp.
2860
2861 .*---------------------------------------------------------------------*
2862 :h3.   BITORDERINFIELD(msb)   for enumerated
2863 .*---------------------------------------------------------------------*
2864 :xmp tab=0.
2865
2866 <TC-    BITORDERINFIELD(msb)   for enumerated>
2867
2868 <STATIC>
2869
2870 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2871 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2872
2873 type enumerated RAW_PDU
2874   { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
2875   tenth  }
2876 with { encode "RAW";
2877        variant "FIELDLENGTH(8)" ;
2878        variant "BITORDERINFIELD (msb) "};
2879
2880 const RAW_PDU           i := first
2881 const octetstring       o := '80'O
2882
2883 <TTCN_TC:EXEC>
2884
2885 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2886 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2887
2888 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
2889   else {setverdict(fail);}
2890
2891 <RESULT>
2892
2893 Overall verdict: pass
2894
2895 <END_TC>
2896
2897 :exmp.
2898
2899 .*---------------------------------------------------------------------*
2900 :h3.   BITORDERINFIELD(lsb)  for hexstring
2901 .*---------------------------------------------------------------------*
2902 :xmp tab=0.
2903
2904 <TC-    BITORDERINFIELD(lsb)  for hexstring>
2905
2906 <STATIC>
2907
2908 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2909 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2910
2911 type hexstring RAW_PDU
2912 with { encode "RAW"; variant "BITORDERINFIELD(lsb)"};
2913
2914 const RAW_PDU           i := '1234'H
2915 const octetstring       o := '2143'O
2916
2917 <TTCN_TC:EXEC>
2918
2919 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2920 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2921
2922 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2923   else {setverdict(fail);}
2924
2925 <RESULT>
2926
2927 Overall verdict: pass
2928
2929 <END_TC>
2930
2931 :exmp.
2932
2933 .*---------------------------------------------------------------------*
2934 :h3.   BITORDERINFIELD(msb)  for hexstring
2935 .*---------------------------------------------------------------------*
2936 :xmp tab=0.
2937
2938 <TC-    BITORDERINFIELD(msb)  for hexstring>
2939
2940 <STATIC>
2941
2942 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2943 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2944
2945 type hexstring RAW_PDU
2946 with { encode "RAW"; variant "BITORDERINFIELD(msb)"};
2947
2948 const RAW_PDU           i := '1234'H
2949 const octetstring       o := 'C284'O
2950
2951 <TTCN_TC:EXEC>
2952
2953 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2954 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2955
2956 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2957   else {setverdict(fail);}
2958
2959 <RESULT>
2960
2961 Overall verdict: pass
2962
2963 <END_TC>
2964
2965 :exmp.
2966
2967 .*---------------------------------------------------------------------*
2968 :h2.Testing BITORDERINOCTET Attribute
2969 .*---------------------------------------------------------------------*
2970
2971 .*---------------------------------------------------------------------*
2972 :h3.   BITORDERINOCTET(lsb)  for integer
2973 .*---------------------------------------------------------------------*
2974 :xmp tab=0.
2975
2976 <TC-    BITORDERINOCTET(lsb)  for integer>
2977
2978 <STATIC>
2979
2980 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
2981 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
2982
2983 type integer RAW_PDU
2984 with { encode "RAW";
2985        variant "FIELDLENGTH(8)" ;
2986        variant "BITORDERINOCTET(lsb)"};
2987
2988 const RAW_PDU           i := 15
2989 const octetstring       o := '0F'O
2990
2991 <TTCN_TC:EXEC>
2992
2993 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
2994 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
2995
2996 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
2997   else {setverdict(fail);}
2998
2999 <RESULT>
3000
3001 Overall verdict: pass
3002
3003 <END_TC>
3004
3005 :exmp.
3006
3007 .*---------------------------------------------------------------------*
3008 :h3.   BITORDERINOCTET (msb) for integer
3009 .*---------------------------------------------------------------------*
3010 :xmp tab=0.
3011
3012 <TC-    BITORDERINOCTET (msb) for integer>
3013
3014 <STATIC>
3015
3016 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3017 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3018
3019 type integer RAW_PDU
3020 with { encode "RAW";
3021        variant "FIELDLENGTH(8)" ;
3022        variant "BITORDERINOCTET(msb)"};
3023
3024 const RAW_PDU           i := 15
3025 const octetstring       o := 'F0'O
3026
3027 <TTCN_TC:EXEC>
3028
3029 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3030 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3031
3032 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3033   else {setverdict(fail);}
3034
3035 <RESULT>
3036
3037 Overall verdict: pass
3038
3039 <END_TC>
3040
3041 :exmp.
3042
3043 .*---------------------------------------------------------------------*
3044 :h3.   BITORDERINOCTET(lsb)  for integer
3045 .*---------------------------------------------------------------------*
3046 :xmp tab=0.
3047
3048 <TC-    BITORDERINOCTET(lsb)  for integer>
3049
3050 <STATIC>
3051
3052 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3053 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3054
3055 type integer RAW_PDU
3056 with { encode "RAW";
3057        variant "FIELDLENGTH(16)" ;
3058        variant "BITORDERINOCTET(lsb)"};
3059
3060 const RAW_PDU           i := 4660
3061 const octetstring       o := '3412'O
3062
3063 <TTCN_TC:EXEC>
3064
3065 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3066 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3067
3068 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3069   else {setverdict(fail);}
3070
3071 <RESULT>
3072
3073 Overall verdict: pass
3074
3075 <END_TC>
3076
3077 :exmp.
3078
3079 .*---------------------------------------------------------------------*
3080 :h3.   BITORDERINOCTET(msb)  for integer
3081 .*---------------------------------------------------------------------*
3082 :xmp tab=0.
3083
3084 <TC-    BITORDERINOCTET(msb)  for integer>
3085
3086 <STATIC>
3087
3088 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3089 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3090
3091 type integer RAW_PDU
3092 with { encode "RAW";
3093        variant "FIELDLENGTH(16)" ;
3094        variant "BITORDERINOCTET(msb)"
3095      };
3096
3097 const RAW_PDU           i := 4660
3098 const octetstring       o := '2C48'O
3099
3100 <TTCN_TC:EXEC>
3101
3102 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3103 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3104
3105 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3106   else {setverdict(fail);}
3107
3108 <RESULT>
3109
3110 Overall verdict: pass
3111
3112 <END_TC>
3113
3114 :exmp.
3115
3116 .*---------------------------------------------------------------------*
3117 :h3.   BITORDERINOCTET(lsb)  for octetstring
3118 .*---------------------------------------------------------------------*
3119 :xmp tab=0.
3120
3121 <TC-    BITORDERINOCTET(lsb)  for octetstring>
3122
3123 <STATIC>
3124
3125 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3126 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3127
3128 type octetstring RAW_PDU
3129 with { encode "RAW";
3130        variant "FIELDLENGTH(1)" ;
3131        variant "BITORDERINOCTET(lsb)"
3132      };
3133
3134 const RAW_PDU           i := '0F'O
3135 const octetstring       o := '0F'O
3136
3137 <TTCN_TC:EXEC>
3138
3139 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3140 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3141
3142 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3143   else {setverdict(fail);}
3144
3145 <RESULT>
3146
3147 Overall verdict: pass
3148
3149 <END_TC>
3150
3151 :exmp.
3152
3153 .*---------------------------------------------------------------------*
3154 :h3.   BITORDERINOCTET(msb)  for octetstring
3155 .*---------------------------------------------------------------------*
3156 :xmp tab=0.
3157
3158 <TC-    BITORDERINOCTET(msb)  for octetstring>
3159
3160 <STATIC>
3161
3162 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3163 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3164
3165 type octetstring RAW_PDU
3166 with { encode "RAW";
3167        variant "FIELDLENGTH(1)" ;
3168        variant "BITORDERINOCTET(msb)"
3169      };
3170
3171 const RAW_PDU           i := '0F'O
3172 const octetstring       o := 'F0'O
3173
3174 <TTCN_TC:EXEC>
3175
3176 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3177 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3178
3179 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3180   else {setverdict(fail);}
3181
3182 <RESULT>
3183
3184 Overall verdict: pass
3185
3186 <END_TC>
3187
3188 :exmp.
3189
3190 .*---------------------------------------------------------------------*
3191 :h3.   BITORDERINOCTET(lsb) for octetstring
3192 .*---------------------------------------------------------------------*
3193 :xmp tab=0.
3194
3195 <TC-    BITORDERINOCTET(lsb) for octetstring>
3196
3197 <STATIC>
3198
3199 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3200 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3201
3202 type octetstring RAW_PDU
3203 with {encode "RAW";
3204       variant "FIELDLENGTH(2)" ;
3205       variant "BITORDERINOCTET(lsb)"
3206      };
3207
3208 const RAW_PDU           i := '1234'O
3209 const octetstring       o := '1234'O
3210
3211 <TTCN_TC:EXEC>
3212
3213 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3214 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3215
3216 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3217   else {setverdict(fail);}
3218
3219 <RESULT>
3220
3221 Overall verdict: pass
3222
3223 <END_TC>
3224
3225 :exmp.
3226
3227 .*---------------------------------------------------------------------*
3228 :h3.   BITORDERINOCTET(msb)  for octetstring
3229 .*---------------------------------------------------------------------*
3230 :xmp tab=0.
3231
3232 <TC-    BITORDERINOCTET(msb)  for octetstring>
3233
3234 <STATIC>
3235
3236 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3237 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3238
3239 type octetstring RAW_PDU
3240 with { encode "RAW";
3241        variant "FIELDLENGTH(2)" ;
3242        variant "BITORDERINOCTET(msb)"
3243      };
3244
3245 const RAW_PDU           i := '1234'O
3246 const octetstring       o := '482C'O
3247
3248 <TTCN_TC:EXEC>
3249
3250 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3251 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3252
3253 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3254   else {setverdict(fail);}
3255
3256 <RESULT>
3257
3258 Overall verdict: pass
3259
3260 <END_TC>
3261
3262 :exmp.
3263
3264 .*---------------------------------------------------------------------*
3265 :h3.   BITORDERINOCTET(lsb)  for bitstring
3266 .*---------------------------------------------------------------------*
3267 :xmp tab=0.
3268
3269 <TC-    BITORDERINOCTET(lsb)  for bitstring>
3270
3271 <STATIC>
3272
3273 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3274 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3275
3276 type bitstring RAW_PDU
3277 with { encode "RAW";
3278        variant "FIELDLENGTH(8)" ;
3279        variant "BITORDERINOCTET(lsb)"
3280      };
3281
3282 const RAW_PDU           i := '00000011'B
3283 const octetstring       o := '03'O
3284
3285 <TTCN_TC:EXEC>
3286
3287 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3288 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3289
3290 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3291   else {setverdict(fail);}
3292
3293 <RESULT>
3294
3295 Overall verdict: pass
3296
3297 <END_TC>
3298
3299 :exmp.
3300
3301 .*---------------------------------------------------------------------*
3302 :h3.   BITORDERINOCTET(msb)  for bitstring
3303 .*---------------------------------------------------------------------*
3304 :xmp tab=0.
3305
3306 <TC-    BITORDERINOCTET(msb)  for bitstring>
3307
3308 <STATIC>
3309
3310 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3311 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3312
3313 type bitstring RAW_PDU
3314 with { encode "RAW";
3315        variant "FIELDLENGTH(8)" ;
3316        variant "BITORDERINOCTET(msb)"
3317      };
3318
3319 const RAW_PDU           i := '00000011'B
3320 const octetstring       o := 'C0'O
3321
3322 <TTCN_TC:EXEC>
3323
3324 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3325 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3326
3327 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3328   else {setverdict(fail);}
3329
3330 <RESULT>
3331
3332 Overall verdict: pass
3333
3334 <END_TC>
3335
3336 :exmp.
3337
3338 .*---------------------------------------------------------------------*
3339 :h3.   BITORDERINOCTET(lsb)  for bitstring
3340 .*---------------------------------------------------------------------*
3341 :xmp tab=0.
3342
3343 <TC-    BITORDERINOCTET(lsb)  for bitstring>
3344
3345 <STATIC>
3346
3347 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3348 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3349
3350 type bitstring RAW_PDU
3351 with { encode "RAW";
3352        variant "FIELDLENGTH(16)" ;
3353        variant "BITORDERINOCTET(lsb)"
3354      };
3355
3356 const RAW_PDU           i := '0001111100110001'B
3357 const octetstring       o := '311F'O
3358
3359 <TTCN_TC:EXEC>
3360
3361 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3362 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3363
3364 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3365   else {setverdict(fail);}
3366
3367 <RESULT>
3368
3369 Overall verdict: pass
3370
3371 <END_TC>
3372
3373 :exmp.
3374
3375 .*---------------------------------------------------------------------*
3376 :h3.   BITORDERINOCTET(msb)  for bitstring
3377 .*---------------------------------------------------------------------*
3378 :xmp tab=0.
3379
3380 <TC-    BITORDERINOCTET(msb)  for bitstring>
3381
3382 <STATIC>
3383
3384 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3385 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3386
3387 type bitstring RAW_PDU
3388 with { encode "RAW";
3389        variant "FIELDLENGTH(16)" ;
3390        variant "BITORDERINOCTET(msb)"
3391      };
3392
3393 const RAW_PDU           i := '0001111100110001'B
3394 const octetstring       o := '8CF8'O
3395
3396 <TTCN_TC:EXEC>
3397
3398 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3399 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3400
3401 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3402   else {setverdict(fail);}
3403
3404 <RESULT>
3405
3406 Overall verdict: pass
3407
3408 <END_TC>
3409
3410 :exmp.
3411
3412 .*---------------------------------------------------------------------*
3413 :h3.   BITORDERINOCTET(lsb)  for enumerated
3414 .*---------------------------------------------------------------------*
3415 :xmp tab=0.
3416
3417 <TC-    BITORDERINOCTET(lsb)  for enumerated>
3418
3419 <STATIC>
3420
3421 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3422 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3423
3424 type enumerated RAW_PDU
3425   { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
3426   tenth  }
3427 with { encode "RAW";
3428        variant "FIELDLENGTH(4)" ;
3429        variant "BITORDERINOCTET (lsb) "
3430      };
3431
3432 const RAW_PDU           i := first
3433 const octetstring       o := '01'O
3434
3435 <TTCN_TC:EXEC>
3436
3437 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3438 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3439
3440 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
3441   else {setverdict(fail);}
3442
3443 <RESULT>
3444
3445 Overall verdict: pass
3446
3447 <END_TC>
3448
3449 :exmp.
3450
3451 .*---------------------------------------------------------------------*
3452 :h3.   BITORDERINOCTET(msb)  for enumerated
3453 .*---------------------------------------------------------------------*
3454 :xmp tab=0.
3455
3456 <TC-    BITORDERINOCTET(msb)  for enumerated>
3457
3458 <STATIC>
3459
3460 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3461 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3462
3463 type enumerated RAW_PDU
3464   { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
3465   tenth  }
3466 with { encode "RAW";
3467        variant "FIELDLENGTH(8)" ;
3468        variant "BITORDERINOCTET (msb) "
3469      };
3470
3471 const RAW_PDU           i := first
3472 const octetstring       o := '80'O
3473
3474 <TTCN_TC:EXEC>
3475
3476 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3477 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3478
3479 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i )) {setverdict(pass);}
3480   else {setverdict(fail);}
3481
3482 <RESULT>
3483
3484 Overall verdict: pass
3485
3486 <END_TC>
3487
3488 :exmp.
3489
3490
3491 .*---------------------------------------------------------------------*
3492 :h3.   BITORDERINOCTET(lsb)  for hexstring
3493 .*---------------------------------------------------------------------*
3494 :xmp tab=0.
3495
3496 <TC-    BITORDERINOCTET(lsb)  for hexstring>
3497
3498 <STATIC>
3499
3500 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3501 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3502
3503 type hexstring RAW_PDU
3504 with { encode "RAW"; variant "BITORDERINOCTET(lsb)"};
3505
3506 const RAW_PDU           i := '1234'H
3507 const octetstring       o := '2143'O
3508
3509 <TTCN_TC:EXEC>
3510
3511 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3512 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3513
3514 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3515   else {setverdict(fail);}
3516
3517 <RESULT>
3518
3519 Overall verdict: pass
3520
3521 <END_TC>
3522
3523 :exmp.
3524
3525 .*---------------------------------------------------------------------*
3526 :h3.   BITORDERINOCTET(msb)  for hexstring
3527 .*---------------------------------------------------------------------*
3528 :xmp tab=0.
3529
3530 <TC-    BITORDERINOCTET(msb)  for hexstring>
3531
3532 <STATIC>
3533
3534 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3535 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3536
3537 type hexstring RAW_PDU
3538 with { encode "RAW"; variant "BITORDERINOCTET(msb)"};
3539
3540 const RAW_PDU           i := '1234'H
3541 const octetstring       o := '84C2'O
3542
3543 <TTCN_TC:EXEC>
3544
3545 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3546 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3547
3548 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3549   else {setverdict(fail);}
3550
3551 <RESULT>
3552
3553 Overall verdict: pass
3554
3555 <END_TC>
3556
3557 :exmp.
3558
3559
3560 .*---------------------------------------------------------------------*
3561 :h2.Testing COMP Attribute
3562 .*---------------------------------------------------------------------*
3563
3564 .*---------------------------------------------------------------------*
3565 :h3.   COMP( nosign )  for positive integer
3566 .*---------------------------------------------------------------------*
3567 :xmp tab=0.
3568
3569 <TC-    COMP( nosign )  for positive integer>
3570
3571 <STATIC>
3572
3573 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3574 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3575
3576 type integer RAW_PDU
3577 with { encode "RAW";
3578        variant "FIELDLENGTH(8)" ;
3579        variant "COMP( nosign ) "
3580      };
3581
3582 const RAW_PDU           i := 2
3583 const octetstring       o := '02'O
3584
3585 <TTCN_TC:EXEC>
3586
3587 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3588 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3589
3590 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3591   else {setverdict(fail);}
3592
3593 <RESULT>
3594
3595 Overall verdict: pass
3596
3597 <END_TC>
3598
3599 :exmp.
3600
3601 .*---------------------------------------------------------------------*
3602 :h3.   COMP ( nosign ) for negative integer
3603 .*---------------------------------------------------------------------*
3604 :xmp tab=0.
3605
3606 <TC-    COMP ( nosign ) for negative integer >
3607
3608 <STATIC>
3609
3610 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3611 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3612
3613 type integer RAW_PDU
3614 with { encode "RAW";
3615        variant "FIELDLENGTH(8)" ;
3616        variant "COMP( nosign ) "
3617      };
3618
3619 const RAW_PDU           i := -2
3620 const octetstring       o := '02'O
3621
3622 <TTCN_TC:EXEC>
3623
3624 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3625 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3626
3627 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3628   else {setverdict(fail);}
3629
3630 <RESULT>
3631
3632 Overall verdict: error
3633
3634 <END_TC>
3635
3636 :exmp.
3637
3638 .*---------------------------------------------------------------------*
3639 :h3.   COMP( signbit )  for positive integer
3640 .*---------------------------------------------------------------------*
3641 :xmp tab=0.
3642
3643 <TC-    COMP( signbit )  for positive integer>
3644
3645 <STATIC>
3646
3647 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3648 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3649
3650 type integer RAW_PDU
3651 with { encode "RAW";
3652        variant "FIELDLENGTH(8)" ;
3653        variant "COMP( signbit ) "
3654      };
3655
3656 const RAW_PDU           i := 2
3657 const octetstring       o := '02'O
3658
3659 <TTCN_TC:EXEC>
3660
3661 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3662 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3663
3664 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3665   else {setverdict(fail);}
3666
3667 <RESULT>
3668
3669 Overall verdict: pass
3670
3671 <END_TC>
3672
3673 :exmp.
3674
3675 .*---------------------------------------------------------------------*
3676 :h3.   COMP( signbit )   for negative integer
3677 .*---------------------------------------------------------------------*
3678 :xmp tab=0.
3679
3680 <TC-    COMP( signbit )   for negative integer>
3681
3682 <STATIC>
3683
3684 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3685 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3686
3687 type integer RAW_PDU
3688 with { encode "RAW";
3689        variant "FIELDLENGTH(8)" ;
3690        variant "COMP( signbit ) "
3691      };
3692
3693 const RAW_PDU           i := -2
3694 const octetstring       o := '82'O
3695
3696 <TTCN_TC:EXEC>
3697
3698 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3699 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3700
3701 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3702   else {setverdict(fail);}
3703
3704 <RESULT>
3705
3706 Overall verdict: pass
3707
3708 <END_TC>
3709
3710 :exmp.
3711
3712 .*---------------------------------------------------------------------*
3713 :h3.   COMP( 2scompl )  for positive integer
3714 .*---------------------------------------------------------------------*
3715 :xmp tab=0.
3716
3717 <TC-    COMP( 2scompl )  for positive integer>
3718
3719 <STATIC>
3720
3721 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3722 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3723
3724 type integer RAW_PDU
3725 with { encode "RAW";
3726        variant "FIELDLENGTH(8)" ;
3727        variant "COMP( 2scompl ) "
3728      };
3729
3730 const RAW_PDU           i := 2
3731 const octetstring       o := '02'O
3732
3733 <TTCN_TC:EXEC>
3734
3735 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3736 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3737
3738 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3739   else {setverdict(fail);}
3740
3741 <RESULT>
3742
3743 Overall verdict: pass
3744
3745 <END_TC>
3746
3747 :exmp.
3748
3749 .*---------------------------------------------------------------------*
3750 :h3.   COMP( 2scompl )  for negative integer
3751 .*---------------------------------------------------------------------*
3752 :xmp tab=0.
3753
3754 <TC-    COMP( 2scompl )  for negative integer>
3755
3756 <STATIC>
3757
3758 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3759 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3760
3761 type integer RAW_PDU
3762 with { encode "RAW";
3763        variant "FIELDLENGTH(8)" ;
3764        variant "COMP( 2scompl ) "
3765      };
3766
3767 const RAW_PDU           i := -2
3768 const octetstring       o := 'FE'O
3769
3770 <TTCN_TC:EXEC>
3771
3772 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3773 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3774
3775 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3776   else {setverdict(fail);}
3777
3778 <RESULT>
3779
3780 Overall verdict: pass
3781
3782 <END_TC>
3783
3784 :exmp.
3785
3786 .*---------------------------------------------------------------------*
3787 :h2.Testing PADDING Attribute
3788 .*---------------------------------------------------------------------*
3789
3790 .*---------------------------------------------------------------------*
3791 :h3.   PADDING  for integer
3792 .*---------------------------------------------------------------------*
3793 :xmp tab=0.
3794
3795 <TC-    PADDING  for integer>
3796
3797 <STATIC>
3798
3799 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3800 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3801
3802 group RAW_group{
3803
3804 type record RAW_PDU
3805 { integer   int1 ,
3806   integer   int2 ,
3807   integer   int3 ,
3808   integer   int4   }
3809  with { variant (int3) "FIELDLENGTH (4)" ;
3810         variant (int1) "PADDING( yes ) " ;
3811         variant (int2) "FIELDLENGTH (4)" ;
3812         variant (int2) "PADDING( yes ) " ;
3813         variant (int3) "FIELDLENGTH (4)" ;
3814         variant (int3) "PADDING( no ) " ;
3815         variant (int4) "FIELDLENGTH (4)" ;
3816         variant (int4) "PADDING( no ) " ; }
3817 } with {encode "RAW" };
3818
3819
3820 const RAW_PDU
3821         i := {  int1 :=    1  ,
3822                 int2 :=    2  ,
3823                 int3 :=    3  ,
3824                 int4 :=    4       }
3825
3826
3827
3828 const octetstring       o := '010243'O
3829
3830 <TTCN_TC:EXEC>
3831
3832 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3833 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3834
3835 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3836   else {setverdict(fail);}
3837
3838 <RESULT>
3839
3840 Overall verdict: pass
3841
3842 <END_TC>
3843
3844 :exmp.
3845
3846 .*---------------------------------------------------------------------*
3847 :h3.   PADDING  for bitstring
3848 .*---------------------------------------------------------------------*
3849 :xmp tab=0.
3850
3851 <TC-    PADDING  for bitstring>
3852
3853 <STATIC>
3854
3855 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3856 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3857
3858 group RAW_group{
3859
3860 type record RAW_PDU
3861 { bitstring   bit1 ,
3862   bitstring   bit2 ,
3863   bitstring   bit3 ,
3864   bitstring   bit4   }
3865  with { variant (bit1) "FIELDLENGTH(4)" ;
3866         variant (bit1) "PADDING( yes ) " ;
3867         variant (bit2) "FIELDLENGTH(4)" ;
3868         variant (bit2) "PADDING( yes ) " ;
3869         variant (bit3) "FIELDLENGTH(4)" ;
3870         variant (bit3) "PADDING( no ) " ;
3871         variant (bit4) "FIELDLENGTH(4)" ;
3872         variant (bit4) "PADDING( no ) " ;
3873       };
3874 } with {encode "RAW"}
3875
3876
3877 const RAW_PDU
3878         i := {  bit1 :=  '0001'B  ,
3879                 bit2 :=  '0010'B  ,
3880                 bit3 :=  '0011'B  ,
3881                 bit4 :=  '0100'B       }
3882
3883
3884
3885 const octetstring       o := '010243'O
3886
3887 <TTCN_TC:EXEC>
3888
3889 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3890 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3891
3892 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3893   else {setverdict(fail);}
3894
3895 <RESULT>
3896
3897 Overall verdict: pass
3898
3899 <END_TC>
3900
3901 :exmp.
3902
3903 .*---------------------------------------------------------------------*
3904 :h3.   PADDING  for enumerated
3905 .*---------------------------------------------------------------------*
3906 :xmp tab=0.
3907
3908 <TC-    PADDING  for enumerated>
3909
3910 <STATIC>
3911
3912 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3913 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3914
3915 group RAW_group{
3916
3917 type enumerated enumerated1
3918 { zero, first, second, third, fourth, fifth }
3919
3920 type enumerated enumerated2
3921 { tenth, eleventh, twelfth, thirteenth, fourthteenth, fifteenth }
3922
3923 type enumerated enumerated3
3924 { twenty, twentyfirst, twentysecond, twentythird, twentyfourth, twentyfifth }
3925
3926 type enumerated enumerated4
3927 { thirty, thirtyfirst, thirtysecond, thirtythird, thirtyfourth, thirtyfifth }
3928
3929
3930 type record RAW_PDU
3931 { enumerated1   enum1 ,
3932   enumerated2   enum2 ,
3933   enumerated3   enum3 ,
3934   enumerated4   enum4   }
3935  with { variant (enum1) "FIELDLENGTH(4)" ;
3936         variant (enum1) "PADDING( yes ) " ;
3937         variant (enum2) "FIELDLENGTH(4)" ;
3938         variant (enum2) "PADDING( yes ) " ;
3939         variant (enum3) "FIELDLENGTH(4)" ;
3940         variant (enum3) "PADDING( no ) " ;
3941         variant (enum4) "FIELDLENGTH(4)" ;
3942         variant (enum4) "PADDING( no ) " ;
3943       };
3944 } with {encode "RAW" };
3945
3946
3947 const RAW_PDU
3948         i := {  enum1 :=  first  ,
3949                 enum2 :=  twelfth  ,
3950                 enum3 :=  twentythird  ,
3951                 enum4 :=  thirtyfourth       }
3952
3953
3954
3955
3956
3957
3958 const octetstring       o := '010243'O
3959
3960 <TTCN_TC:EXEC>
3961
3962 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
3963 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
3964
3965 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
3966   else {setverdict(fail);}
3967
3968 <RESULT>
3969
3970 Overall verdict: pass
3971
3972 <END_TC>
3973
3974 :exmp.
3975
3976 .*---------------------------------------------------------------------*
3977 :h3.   PADDING  for hexstring
3978 .*---------------------------------------------------------------------*
3979 :xmp tab=0.
3980
3981 <TC-    PADDING  for hexstring>
3982
3983 <STATIC>
3984
3985 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
3986 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
3987
3988 group RAW_group{
3989
3990 type record RAW_PDU
3991 { hexstring   hex1 ,
3992   hexstring   hex2 ,
3993   hexstring   hex3 ,
3994   hexstring   hex4   }
3995  with { encode "RAW";
3996         variant (hex1) "FIELDLENGTH(1)" ;
3997         variant (hex1) "PADDING( yes ) " ;
3998         variant (hex2) "FIELDLENGTH(1)" ;
3999         variant (hex2) "PADDING( yes ) " ;
4000         variant (hex3) "FIELDLENGTH(1)" ;
4001         variant (hex3) "PADDING( no ) " ;
4002         variant (hex4) "FIELDLENGTH(1)" ;
4003         variant (hex4) "PADDING( no ) " ;
4004       };
4005 } with {encode "RAW" }
4006
4007
4008 const RAW_PDU
4009         i := {  hex1 :=  '1'H  ,
4010                 hex2 :=  '2'H  ,
4011                 hex3 :=  '3'H  ,
4012                 hex4 :=  '4'H       }
4013
4014
4015
4016 const octetstring       o := '010243'O
4017
4018 <TTCN_TC:EXEC>
4019
4020 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4021 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4022
4023 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4024   else {setverdict(fail);}
4025
4026 <RESULT>
4027
4028 Overall verdict: pass
4029
4030 <END_TC>
4031
4032 :exmp.
4033
4034
4035 .*---------------------------------------------------------------------*
4036 :h2.Testing PREPADDING Attribute
4037 .*---------------------------------------------------------------------*
4038
4039 .*---------------------------------------------------------------------*
4040 :h3.  PREPADDING(yes)  for bitstring
4041 .*---------------------------------------------------------------------*
4042 :xmp tab=0.
4043
4044 <TC-    PREPADDING(yes)  for bitstring>
4045
4046 <STATIC>
4047
4048 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4049 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4050
4051 type bitstring RAW_PDU length (3)
4052 with {encode "RAW"; variant "PREPADDING(yes)"}
4053
4054 const RAW_PDU           i := '101'B
4055 const octetstring       o := '05'O
4056
4057 <TTCN_TC:EXEC>
4058
4059 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4060 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4061
4062 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4063   else {setverdict(fail);}
4064
4065 <RESULT>
4066
4067 Overall verdict: pass
4068
4069 <END_TC>
4070
4071 :exmp.
4072
4073
4074 .*---------------------------------------------------------------------*
4075 :h3.  PREPADDING(yes)  for hexstring
4076 .*---------------------------------------------------------------------*
4077 :xmp tab=0.
4078
4079 <TC-    PREPADDING(yes)  for hexstring>
4080
4081 <STATIC>
4082
4083 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4084 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4085
4086 type hexstring RAW_PDU length (1)
4087 with {encode "RAW"; variant "PREPADDING(yes)"}
4088
4089 const RAW_PDU           i := 'F'H
4090 const octetstring       o := '0F'O
4091
4092 <TTCN_TC:EXEC>
4093
4094 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4095 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4096
4097 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4098   else {setverdict(fail);}
4099
4100 <RESULT>
4101
4102 Overall verdict: pass
4103
4104 <END_TC>
4105
4106 :exmp.
4107
4108 .*---------------------------------------------------------------------*
4109 :h3.  PREPADDING(word16)  for octetstring
4110 .*---------------------------------------------------------------------*
4111 :xmp tab=0.
4112
4113 <TC-    PREPADDING(word16)  for octetstring>
4114
4115 <STATIC>
4116
4117 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4118 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4119
4120 type octetstring otype
4121 with {encode "RAW"; variant "PREPADDING(word16)"}
4122 type hexstring   htype length (3)
4123
4124 type record RAW_PDU { htype h, otype o}
4125 with {encode "RAW"; variant ""}
4126
4127 const RAW_PDU           i := {'AAA'H,'FF'O}
4128 const octetstring       o := 'AA0AFF'O
4129
4130 <TTCN_TC:EXEC>
4131
4132 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4133 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4134
4135 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4136   else {setverdict(fail);}
4137
4138 <RESULT>
4139
4140 Overall verdict: pass
4141
4142 <END_TC>
4143
4144 :exmp.
4145
4146 .*---------------------------------------------------------------------*
4147 :h3.  PREPADDING(word16)  for record of
4148 .*---------------------------------------------------------------------*
4149 :xmp tab=0.
4150
4151 <TC-    PREPADDING(word16)  for record of>
4152
4153 <STATIC>
4154
4155 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4156 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4157
4158 type integer itype
4159 with {encode "RAW"; variant "FIELDLENGTH(3)"}
4160 type record length (1) of itype rtype
4161 with {encode "RAW"; variant "PREPADDING(word16)"}
4162
4163 type record RAW_PDU {itype r1, rtype r2}
4164 with {encode "RAW"; variant ""}
4165
4166 const RAW_PDU           i := {4,{7}}
4167 const octetstring       o := '040007'O
4168
4169 <TTCN_TC:EXEC>
4170
4171 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4172 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4173
4174 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4175   else {setverdict(fail);}
4176
4177 <RESULT>
4178
4179 Overall verdict: pass
4180
4181 <END_TC>
4182
4183 :exmp.
4184
4185 .*---------------------------------------------------------------------*
4186 :h3.  PREPADDING(dword32)  for set of
4187 .*---------------------------------------------------------------------*
4188 :xmp tab=0.
4189
4190 <TC-    PREPADDING(dword32)  for set of>
4191
4192 <STATIC>
4193
4194 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4195 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4196
4197 type bitstring BIT3 length (3)
4198 type record length (2) of BIT3 rtype
4199 with {encode "RAW"; variant "PREPADDING(dword32)"}
4200
4201 type record RAW_PDU {BIT3 r1, rtype r2}
4202 with {encode "RAW"; variant ""}
4203
4204 const RAW_PDU           i := {'100'B,{'111'B, '101'B}}
4205 const octetstring       o := '040000002F'O
4206
4207 <TTCN_TC:EXEC>
4208
4209 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4210 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4211
4212 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4213   else {setverdict(fail);}
4214
4215 <RESULT>
4216
4217 Overall verdict: pass
4218
4219 <END_TC>
4220
4221 :exmp.
4222
4223 .*---------------------------------------------------------------------*
4224 :h3.  PREPADDING(dword32)  for record
4225 .*---------------------------------------------------------------------*
4226 :xmp tab=0.
4227
4228 <TC-    PREPADDING(dword32)  for record>
4229
4230 <STATIC>
4231
4232 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4233 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4234
4235 type bitstring BIT3 length (3)
4236
4237 type record stype {BIT3 s1, BIT3 s2}
4238 with {encode "RAW"; variant "PREPADDING(dword32)"}
4239
4240 type record RAW_PDU {stype r1, stype r2, stype r3}
4241 with {encode "RAW"; variant ""}
4242
4243 const RAW_PDU           i := {{'111'B,'111'B},{'110'B,'000'B},{'111'B,'111'B}}
4244 const octetstring       o := '3F000000060000003F'O
4245
4246 <TTCN_TC:EXEC>
4247
4248 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4249 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4250
4251 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4252   else {setverdict(fail);}
4253
4254 <RESULT>
4255
4256 Overall verdict: pass
4257
4258 <END_TC>
4259
4260 :exmp.
4261
4262 .*---------------------------------------------------------------------*
4263 :h3.  PREPADDING(word16)  for set
4264 .*---------------------------------------------------------------------*
4265 :xmp tab=0.
4266
4267 <TC-    PREPADDING(word16)  for set>
4268
4269 <STATIC>
4270
4271 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4272 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4273
4274 type bitstring BIT3 length (3)
4275
4276 type set stype {BIT3 s1}
4277 with {encode "RAW"; variant "PREPADDING(word16)"}
4278
4279 type record RAW_PDU {stype r1, stype r2, stype r3}
4280 with {encode "RAW"; variant ""}
4281
4282 const RAW_PDU           i := {{s1:='111'B},{s1:='110'B},{s1:='111'B}}
4283 const octetstring       o := '0700060007'O
4284
4285 <TTCN_TC:EXEC>
4286
4287 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4288 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4289
4290 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4291   else {setverdict(fail);}
4292
4293 <RESULT>
4294
4295 Overall verdict: pass
4296
4297 <END_TC>
4298
4299 :exmp.
4300
4301 .*---------------------------------------------------------------------*
4302 :h3.  PREPADDING(word16)  for union
4303 .*---------------------------------------------------------------------*
4304 :xmp tab=0.
4305
4306 <TC-    PREPADDING(word16)  for union>
4307
4308 <STATIC>
4309
4310 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4311 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4312
4313 type bitstring BIT3 length (3)
4314 type hexstring HEX1 length (1)
4315
4316 type union utype {BIT3 u1, HEX1 u2}
4317 with {encode "RAW"; variant "PREPADDING(word16)"}
4318
4319 type record RAW_PDU {utype r1, utype r2, utype r3}
4320 with {encode "RAW"; variant ""}
4321
4322 const RAW_PDU           i := {{u1:='111'B},{u1:='010'B},{u1:='111'B}}
4323 const octetstring       o := '0700020007'O
4324
4325 <TTCN_TC:EXEC>
4326
4327 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4328 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4329
4330 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4331   else {setverdict(fail);}
4332
4333 <RESULT>
4334
4335 Overall verdict: pass
4336
4337 <END_TC>
4338
4339 :exmp.
4340
4341 .*---------------------------------------------------------------------*
4342 :h2.Testing PADDING_PATTERN Attribute
4343 .*---------------------------------------------------------------------*
4344
4345 .*---------------------------------------------------------------------*
4346 :h3.  PADDING_PATTERN  for record of
4347 .*---------------------------------------------------------------------*
4348 :xmp tab=0.
4349
4350 <TC-     PADDING_PATTERN  for record of>
4351
4352 <STATIC>
4353
4354 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4355 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4356
4357 type integer itype
4358 with {encode "RAW"; variant "FIELDLENGTH(3)"}
4359 type record length (1) of itype rtype
4360 with {encode "RAW"; variant "PREPADDING(yes), PADDING_PATTERN('1'B)"}
4361
4362 type record RAW_PDU {itype r1, rtype r2}
4363 with {encode "RAW"; variant ""}
4364
4365 const RAW_PDU           i := {4,{7}}
4366 const octetstring       o := 'FC07'O
4367
4368 <TTCN_TC:EXEC>
4369
4370 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4371 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4372
4373 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4374   else {setverdict(fail);}
4375
4376 <RESULT>
4377
4378 Overall verdict: pass
4379
4380 <END_TC>
4381
4382 :exmp.
4383
4384 .*---------------------------------------------------------------------*
4385 :h3.  PADDING_PATTERN  for set of
4386 .*---------------------------------------------------------------------*
4387 :xmp tab=0.
4388
4389 <TC-     PADDING_PATTERN  for set of>
4390
4391 <STATIC>
4392
4393 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4394 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4395
4396 type bitstring BIT3 length (3)
4397
4398 type set length (2) of BIT3 rtype
4399 with {encode "RAW"; variant "PREPADDING(yes), PADDING_PATTERN('10000'B)"}
4400
4401 type record RAW_PDU {BIT3 r1, rtype r2}
4402 with {encode "RAW"; variant ""}
4403
4404
4405 const RAW_PDU           i := {'100'B,{'111'B, '101'B}}
4406 const octetstring       o := '842F'O
4407
4408 <TTCN_TC:EXEC>
4409
4410 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4411 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4412
4413 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4414   else {setverdict(fail);}
4415
4416 <RESULT>
4417
4418 Overall verdict: pass
4419
4420 <END_TC>
4421
4422 :exmp.
4423
4424 .*---------------------------------------------------------------------*
4425 :h3.  PADDING_PATTERN  for record
4426 .*---------------------------------------------------------------------*
4427 :xmp tab=0.
4428
4429 <TC-    PADDING_PATTERN  for record>
4430
4431 <STATIC>
4432
4433 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4434 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4435
4436 type bitstring BIT9 length (9)
4437
4438 type record stype {BIT9 s1, BIT9 s2}
4439 with {encode "RAW"; variant "PREPADDING(40), PADDING_PATTERN('100000'B)"}
4440
4441 type record RAW_PDU {stype r1, stype r2, stype r3}
4442 with {encode "RAW"; variant ""}
4443
4444
4445 const RAW_PDU           i := {{'111000111'B,'111000111'B},{'111111111'B,'111111111'B},{'111000111'B,'111000111'B}}
4446 const octetstring       o := 'C78F832008FFFF832008C78F03'O
4447
4448 <TTCN_TC:EXEC>
4449
4450 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4451 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4452
4453 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4454   else {setverdict(fail);}
4455
4456 <RESULT>
4457
4458 Overall verdict: pass
4459
4460 <END_TC>
4461
4462 :exmp.
4463
4464 .*---------------------------------------------------------------------*
4465 :h3.  PADDING_PATTERN  for set
4466 .*---------------------------------------------------------------------*
4467 :xmp tab=0.
4468
4469 <TC-    PADDING_PATTERN  for set>
4470
4471 <STATIC>
4472
4473 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4474 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4475
4476 type hexstring HEX3 length (3)
4477
4478 type set stype {HEX3 s1}
4479 with {encode "RAW"; variant "PREPADDING(15), PADDING_PATTERN('10001'B)"}
4480
4481 type record RAW_PDU {stype r1, stype r2, stype r3}
4482 with {encode "RAW"; variant ""}
4483
4484 const RAW_PDU           i := {{s1:='FFF'H},{s1:='FFF'H},{s1:='FFF'H}}
4485 const octetstring       o := 'FF9FFFCFFF03'O
4486
4487 <TTCN_TC:EXEC>
4488
4489 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4490 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4491
4492 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4493   else {setverdict(fail);}
4494
4495 <RESULT>
4496
4497 Overall verdict: pass
4498
4499 <END_TC>
4500
4501 :exmp.
4502
4503 .*---------------------------------------------------------------------*
4504 :h3.  PADDING_PATTERN  for union
4505 .*---------------------------------------------------------------------*
4506 :xmp tab=0.
4507
4508 <TC-    PADDING_PATTERN  for union>
4509
4510 <STATIC>
4511
4512 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4513 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4514
4515 type octetstring OCT2 length (2)
4516
4517 type union utype {OCT2 u1, hexstring u2}
4518 with {encode "RAW"; variant "PREPADDING(256),PADDING_PATTERN('11001'B)"}
4519
4520 type record RAW_PDU {utype r1, utype r2, utype r3}
4521 with {encode "RAW"; variant ""}
4522
4523 const RAW_PDU           i := {{u1:='AABB'O},{u1:='CCDD'O},{u1:='EEFF'O}}
4524 const octetstring       o := 'AABB39E79C73CE39E79C73CE39E79C73CE39E79C73CE39E79C73CE39E79C73CECCDD39E79C73CE39E79C73CE39E79C73CE39E79C73CE39E79C73CE39E79C73CEEEFF'O
4525
4526 <TTCN_TC:EXEC>
4527
4528 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4529 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4530
4531 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4532   else {setverdict(fail);}
4533
4534 <RESULT>
4535
4536 Overall verdict: pass
4537
4538 <END_TC>
4539
4540 :exmp.
4541
4542
4543 .*---------------------------------------------------------------------*
4544 :h2.Testing PADDALL Attribute
4545 .*---------------------------------------------------------------------*
4546
4547 .*---------------------------------------------------------------------*
4548 :h3.  PADDALL with PADDING Attribute - record
4549 .*---------------------------------------------------------------------*
4550 :xmp tab=0.
4551
4552 <TC-    PADDALL with PADDING Attribute - record>
4553
4554 <STATIC>
4555
4556 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4557 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4558
4559 type bitstring BIT1 length (1)
4560
4561 type record stype {BIT1 s1, BIT1 s2}
4562 with {encode "RAW"; variant "PADDING(yes), PADDALL"}
4563
4564 type record RAW_PDU {stype r1, stype r2, stype r3}
4565 with {encode "RAW"; variant ""}
4566
4567 const RAW_PDU           i := {{'1'B,'1'B},{'1'B,'1'B},{'1'B,'1'B}}
4568 const octetstring       o := '010101010101'O
4569
4570 <TTCN_TC:EXEC>
4571
4572 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4573 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4574
4575 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4576   else {setverdict(fail);}
4577
4578 <RESULT>
4579
4580 Overall verdict: pass
4581
4582 <END_TC>
4583
4584 :exmp.
4585
4586 .*---------------------------------------------------------------------*
4587 :h3.  PADDALL with PADDING Attribute - set
4588 .*---------------------------------------------------------------------*
4589 :xmp tab=0.
4590
4591 <TC-    PADDALL with PADDING Attribute - set>
4592
4593 <STATIC>
4594
4595 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4596 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4597
4598 type bitstring BIT3 length (3)
4599
4600 type set stype {BIT3 s1, BIT3 s2}
4601 with {encode "RAW"; variant "PADDING(4), PADDALL"}
4602
4603 type set RAW_PDU {stype r1, stype r2}
4604 with {encode "RAW"; variant "PADDING(dword32), PADDALL"}
4605
4606 const RAW_PDU           i := {r1:={s1:='111'B,s2:='101'B},r2:={s1:='111'B,s2:='101'B}}
4607
4608 const octetstring       o := '57570000'O
4609
4610 <TTCN_TC:EXEC>
4611
4612 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4613 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4614
4615 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4616   else {setverdict(fail);}
4617
4618 <RESULT>
4619
4620 Overall verdict: pass
4621
4622 <END_TC>
4623
4624 :exmp.
4625
4626 .*---------------------------------------------------------------------*
4627 :h3.  PADDALL with PREPADDING Attribute - record
4628 .*---------------------------------------------------------------------*
4629 :xmp tab=0.
4630
4631 <TC-    PADDALL with PADDING Attribute - record>
4632
4633 <STATIC>
4634
4635 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4636 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4637
4638 type hexstring HEX1 length (1)
4639
4640 type record stype {HEX1 s1, HEX1 s2}
4641
4642 type record RAW_PDU {stype r1, stype r2, stype r3}
4643 with {encode "RAW"; variant "PREPADDING(12), PADDALL"}
4644
4645 const RAW_PDU           i := {{'A'H,'B'H},{'A'H,'B'H},{'A'H,'B'H}}
4646 const octetstring       o := 'BAA00BBA'O
4647
4648 <TTCN_TC:EXEC>
4649
4650 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4651 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4652
4653 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4654   else {setverdict(fail);}
4655
4656 <RESULT>
4657
4658 Overall verdict: pass
4659
4660 <END_TC>
4661
4662 :exmp.
4663
4664 .*---------------------------------------------------------------------*
4665 :h3.  PADDALL with PREPADDING Attribute - set
4666 .*---------------------------------------------------------------------*
4667 :xmp tab=0.
4668
4669 <TC-    PADDALL with PADDING Attribute - set>
4670
4671 <STATIC>
4672
4673 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4674 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4675
4676 type hexstring HEX1 length (1)
4677
4678 type set stype {HEX1 s1, HEX1 s2, HEX1 s3}
4679 with {encode "RAW"; variant "PREPADDING(12), PADDALL"}
4680
4681 type set RAW_PDU {stype r1, stype r2}
4682 with {encode "RAW"; variant "PREPADDING(36), PADDALL, PADDING_PATTERN('1111'B)"}
4683
4684 const RAW_PDU           i := {  r1:={s1:='A'H,s2:='B'H,s3:='C'H},
4685                                 r2:={s1:='A'H,s2:='B'H,s3:='C'H}}
4686
4687 const octetstring       o := '0AB000FCAF000BC0'O
4688
4689 <TTCN_TC:EXEC>
4690
4691 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4692 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4693
4694 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4695   else {setverdict(fail);}
4696
4697 <RESULT>
4698
4699 Overall verdict: pass
4700
4701 <END_TC>
4702
4703 :exmp.
4704
4705
4706 .*---------------------------------------------------------------------*
4707 :h2.Testing PTROFFSET Attribute
4708 .*---------------------------------------------------------------------*
4709
4710 .*---------------------------------------------------------------------*
4711 :h3.  PTROFFSET is set to default base
4712 .*---------------------------------------------------------------------*
4713 :xmp tab=0.
4714
4715 <TC-    PTROFFSET is set to default base>
4716
4717 <STATIC>
4718
4719 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4720 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4721
4722 type bitstring BIT4 length (4)
4723 type hexstring HEX1 length (1)
4724 type octetstring OCT3 length (3)
4725
4726 group RAW_group{
4727
4728 type integer INT1
4729 with {variant "FIELDLENGTH(8)" };
4730
4731 type record RAW_PDU {
4732                         INT1 ptr1,
4733                         INT1 ptr2,
4734                         BIT4 field1,
4735                         BIT4 field2 }
4736
4737 with { variant (ptr1) "POINTERTO(field1)";
4738        variant (ptr1) "UNIT(1)";
4739        variant (ptr1) "PTROFFSET(ptr1)";
4740        variant (ptr2) "POINTERTO(field2)";
4741        variant (ptr2) "UNIT(1)"
4742        variant (ptr2) "PTROFFSET(ptr2)"}
4743
4744 } with {encode "RAW" };
4745
4746 const   RAW_PDU i := {16,12,'0110'B,'1001'B}
4747
4748 const octetstring       o := '100C96'O
4749
4750
4751 <TTCN_TC:EXEC>
4752
4753 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4754 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4755
4756 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4757   else {setverdict(fail);}
4758
4759 <RESULT>
4760
4761 Overall verdict: pass
4762
4763 <END_TC>
4764
4765 :exmp.
4766
4767 .*---------------------------------------------------------------------*
4768 :h3.  PTROFFSET is set to the beginning of record
4769 .*---------------------------------------------------------------------*
4770 :xmp tab=0.
4771
4772 <TC-    PTROFFSET is set to the beginning of record>
4773
4774 <STATIC>
4775
4776 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4777 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4778
4779 type bitstring BIT3 length (3)
4780 type hexstring HEX1 length (1)
4781 type octetstring OCT3 length (3)
4782
4783 group RAW_group{
4784
4785 type integer INT1
4786 with { encode "RAW"; variant "FIELDLENGTH(8)" };
4787
4788
4789 type record RAW_PDU {
4790                         INT1 ptr1,
4791                         INT1 ptr2,
4792                         INT1 ptr3,
4793
4794                         BIT3 field1,
4795                         HEX1 field2,
4796                         OCT3 field3 }
4797
4798 with { variant (ptr1) "POINTERTO(field1)";
4799        variant (ptr1) "UNIT(1)";
4800        variant (ptr1) "PTROFFSET(ptr1)";
4801        variant (ptr2) "POINTERTO(field2)";
4802        variant (ptr2) "UNIT(1)";
4803        variant (ptr2) "PTROFFSET(ptr1)";
4804        variant (ptr3) "POINTERTO(field3)";
4805        variant (ptr3) "UNIT(1)";
4806        variant (ptr3) "PTROFFSET(ptr1)"}
4807
4808 } with {encode "RAW" };
4809
4810 const   RAW_PDU i := {24,27,31,'111'B,'A'H,'010203'O}
4811
4812 const octetstring       o := '181B1FD7008101'O
4813
4814 <TTCN_TC:EXEC>
4815
4816 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4817 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4818
4819 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4820   else {setverdict(fail);}
4821
4822 <RESULT>
4823
4824 Overall verdict: pass
4825
4826 <END_TC>
4827
4828 :exmp.
4829
4830
4831 .*---------------------------------------------------------------------*
4832 :h3.  PTROFFSET is set to data field
4833 .*---------------------------------------------------------------------*
4834 :xmp tab=0.
4835
4836 <TC-    PTROFFSET is set to data field>
4837
4838 <STATIC>
4839
4840 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4841 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4842
4843 type bitstring BIT3 length (3)
4844 type hexstring HEX1 length (1)
4845 type octetstring OCT3 length (3)
4846
4847 group RAW_group{
4848
4849 type integer INT1
4850 with { variant "FIELDLENGTH(8)" };
4851
4852
4853 type record RAW_PDU {
4854                         INT1 ptr1,
4855                         INT1 ptr2,
4856                         INT1 ptr3,
4857
4858                         BIT3 field1,
4859                         HEX1 field2,
4860                         OCT3 field3 }
4861
4862 with {  variant (ptr1) "POINTERTO(field1)";
4863         variant (ptr1) "UNIT(1)";
4864         variant (ptr1) "PTROFFSET(field1)";
4865         variant (ptr2) "POINTERTO(field2)";
4866         variant (ptr2) "UNIT(1)";
4867         variant (ptr2) "PTROFFSET(field1)";
4868         variant (ptr3) "POINTERTO(field3)";
4869         variant (ptr3) "UNIT(1)";
4870         variant (ptr3) "PTROFFSET(field1)"}
4871
4872 } with {encode "RAW" };
4873
4874 const   RAW_PDU i := {0,3,7,'111'B,'A'H,'010203'O}
4875
4876 const octetstring       o := '000307D7008101'O
4877
4878 <TTCN_TC:EXEC>
4879
4880 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4881 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4882
4883 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4884   else {setverdict(fail);}
4885
4886 <RESULT>
4887
4888 Overall verdict: pass
4889
4890 <END_TC>
4891
4892 :exmp.
4893
4894 .*---------------------------------------------------------------------*
4895 :h2.Testing HEXORDER Attribute
4896 .*---------------------------------------------------------------------*
4897
4898 .*---------------------------------------------------------------------*
4899 :h3.   HEXORDER(low)  for hexstring
4900 .*---------------------------------------------------------------------*
4901 :xmp tab=0.
4902
4903 <TC-    HEXORDER(low)  for hexstring>
4904
4905 <STATIC>
4906
4907 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4908 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4909
4910 type hexstring RAW_PDU
4911 with { encode "RAW"; variant "HEXORDER(low)"};
4912
4913 const RAW_PDU           i := '1234567890'H
4914 const octetstring       o := '2143658709'O
4915
4916 <TTCN_TC:EXEC>
4917
4918 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4919 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4920
4921 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4922   else {setverdict(fail);}
4923
4924 <RESULT>
4925
4926 Overall verdict: pass
4927
4928 <END_TC>
4929
4930 :exmp.
4931
4932 .*---------------------------------------------------------------------*
4933 :h3.   HEXORDER(high)  for hexstring
4934 .*---------------------------------------------------------------------*
4935 :xmp tab=0.
4936
4937 <TC-    HEXORDER(high)  for hexstring>
4938
4939 <STATIC>
4940
4941 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4942 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4943
4944 type hexstring RAW_PDU
4945 with { encode "RAW"; variant "HEXORDER(high)"};
4946
4947 const RAW_PDU           i := '1234567890'H
4948 const octetstring       o := '1234567890'O
4949
4950 <TTCN_TC:EXEC>
4951
4952 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4953 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4954
4955 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4956   else {setverdict(fail);}
4957
4958 <RESULT>
4959
4960 Overall verdict: pass
4961
4962 <END_TC>
4963
4964 :exmp.
4965
4966 .*---------------------------------------------------------------------*
4967 :h2.Testing EXTENSION BIT Attribute
4968 .*---------------------------------------------------------------------*
4969
4970 .*---------------------------------------------------------------------*
4971 :h3.   EXTENSION_BIT(no)  for octetstring
4972 .*---------------------------------------------------------------------*
4973 :xmp tab=0.
4974
4975 <TC-    EXTENSION_BIT(no)  for octetstring>
4976
4977 <STATIC>
4978
4979 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
4980 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
4981
4982 type octetstring RAW_PDU
4983 with { encode "RAW"; variant "EXTENSION_BIT(no)"};
4984
4985 const RAW_PDU           i := '1234567890'O
4986 const octetstring       o := '1234567890'O
4987
4988 <TTCN_TC:EXEC>
4989
4990 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
4991 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
4992
4993 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
4994   else {setverdict(fail);}
4995
4996 <RESULT>
4997
4998 Overall verdict: pass
4999
5000 <END_TC>
5001
5002 :exmp.
5003
5004 .*---------------------------------------------------------------------*
5005 :h3.   EXTENSION_BIT(yes)  for octetstring
5006 .*---------------------------------------------------------------------*
5007 :xmp tab=0.
5008
5009 <TC-    EXTENSION_BIT(yes)  for octetstring>
5010
5011 <STATIC>
5012
5013 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5014 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5015
5016 type octetstring RAW_PDU
5017 with { encode "RAW"; variant "EXTENSION_BIT(yes)"};
5018
5019 const RAW_PDU           i := '010203040500'O
5020 const octetstring       o := '010203040580'O
5021
5022 <TTCN_TC:EXEC>
5023
5024 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5025 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5026
5027 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == '010203040580'O)) {setverdict(pass);}
5028   else {setverdict(fail);}
5029
5030 <RESULT>
5031
5032 Overall verdict: pass
5033
5034 <END_TC>
5035
5036 :exmp.
5037
5038 .*---------------------------------------------------------------------*
5039 :h3.   EXTENSION_BIT(reverse)  for octetstring
5040 .*---------------------------------------------------------------------*
5041 :xmp tab=0.
5042
5043 <TC-    EXTENSION_BIT(reverse)  for octetstring>
5044
5045 <STATIC>
5046
5047 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5048 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5049
5050 type octetstring RAW_PDU
5051 with { encode "RAW"; variant "EXTENSION_BIT(reverse)"};
5052
5053 const RAW_PDU           i := '010203040500'O
5054 const octetstring       o := '818283848500'O
5055
5056 <TTCN_TC:EXEC>
5057
5058 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5059 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5060
5061 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == '818283848500'O)) {setverdict(pass);}
5062   else {setverdict(fail);}
5063
5064 <RESULT>
5065
5066 Overall verdict: pass
5067
5068 <END_TC>
5069
5070 :exmp.
5071
5072 .*---------------------------------------------------------------------*
5073 :h3.   EXTENSION_BIT(yes)  for record of octetstring
5074 .*---------------------------------------------------------------------*
5075 :xmp tab=0.
5076
5077 <TC-    EXTENSION_BIT(yes)  for record of octetstring>
5078
5079 <STATIC>
5080
5081 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5082 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5083
5084 type octetstring OCT1
5085 with { encode "RAW"; variant "FIELDLENGTH(1)"};
5086
5087 type record of OCT1 RAW_PDU
5088 with { encode "RAW"; variant "EXTENSION_BIT(yes)"};
5089
5090 const RAW_PDU           i := {'84'O, '00'O}
5091 const octetstring       o := '0480'O
5092
5093 <TTCN_TC:EXEC>
5094
5095 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5096 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5097
5098 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
5099
5100 <RESULT>
5101
5102 Overall verdict: pass
5103
5104 <END_TC>
5105
5106 :exmp.
5107
5108 .*---------------------------------------------------------------------*
5109 :h3.   EXTENSION_BIT(reverse)  for record of octetstring
5110 .*---------------------------------------------------------------------*
5111 :xmp tab=0.
5112
5113 <TC-    EXTENSION_BIT(reverse)  for record of octetstring>
5114
5115 <STATIC>
5116
5117 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5118 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5119
5120 type octetstring OCT1
5121 with { encode "RAW"; variant "FIELDLENGTH(1)"};
5122
5123 type record of OCT1 RAW_PDU
5124 with { encode "RAW"; variant "EXTENSION_BIT(reverse)"};
5125
5126 const RAW_PDU           i := {'80'O}
5127 const octetstring       o := '00'O
5128
5129 <TTCN_TC:EXEC>
5130
5131 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5132 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5133
5134 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
5135
5136 <RESULT>
5137
5138 Overall verdict: pass
5139
5140 <END_TC>
5141
5142 :exmp.
5143
5144 .*---------------------------------------------------------------------*
5145 :h3.   EXTENSION_BIT(no)  for record of octetstring
5146 .*---------------------------------------------------------------------*
5147 :xmp tab=0.
5148
5149 <TC-    EXTENSION_BIT(no)  for record of octetstring>
5150
5151 <STATIC>
5152
5153 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5154 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5155
5156 type octetstring OCT1
5157 with { encode "RAW"; variant "FIELDLENGTH(1)"};
5158
5159 type record of OCT1 RAW_PDU
5160 with { encode "RAW"; variant "EXTENSION_BIT(no)"};
5161
5162 const RAW_PDU           i := {'84'O, '05'O}
5163 const octetstring       o := '8405'O
5164
5165 <TTCN_TC:EXEC>
5166
5167 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5168 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5169
5170 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
5171
5172 <RESULT>
5173
5174 Overall verdict: pass
5175
5176 <END_TC>
5177
5178 :exmp.
5179
5180 *---------------------------------------------------------------------*
5181 :h3.   EXTENSION_BIT(yes)  for record of bitstring
5182 .*---------------------------------------------------------------------*
5183 :xmp tab=0.
5184
5185 <TC-    EXTENSION_BIT(yes)  for record of bitstring>
5186
5187 <STATIC>
5188
5189 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5190 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5191
5192
5193 type bitstring BIT3
5194 with { encode "RAW"; variant "FIELDLENGTH(3)"};
5195
5196 type record of BIT3 RAW_PDU
5197 with { encode "RAW"; variant "EXTENSION_BIT(yes)"};
5198
5199 const RAW_PDU           i := {'111'B, '000'B, '111'B}
5200 const octetstring       o := 'C301'O
5201
5202 <TTCN_TC:EXEC>
5203
5204 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5205 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5206
5207 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
5208
5209 <RESULT>
5210
5211 Overall verdict: pass
5212
5213 <END_TC>
5214
5215 :exmp.
5216
5217 *---------------------------------------------------------------------*
5218 :h3.   EXTENSION_BIT(reverse)  for record of bitstring
5219 .*---------------------------------------------------------------------*
5220 :xmp tab=0.
5221
5222 <TC-    EXTENSION_BIT(reverse)  for record of bitstring>
5223
5224 <STATIC>
5225
5226 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5227 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5228
5229 type bitstring BIT3
5230 with { encode "RAW"; variant "FIELDLENGTH(3)"};
5231
5232 type record of BIT3 RAW_PDU
5233 with { encode "RAW"; variant "EXTENSION_BIT(reverse)"};
5234
5235 const RAW_PDU           i := {'111'B, '000'B, '111'B}
5236 const octetstring       o := 'E700'O
5237
5238 <TTCN_TC:EXEC>
5239
5240 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5241 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5242
5243 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
5244
5245 <RESULT>
5246
5247 Overall verdict: pass
5248
5249 <END_TC>
5250
5251 :exmp.
5252
5253 *---------------------------------------------------------------------*
5254 :h3.   EXTENSION_BIT(yes)  for set of bitstring
5255 .*---------------------------------------------------------------------*
5256 :xmp tab=0.
5257
5258 <TC-    EXTENSION_BIT(yes)  for set of bitstring>
5259
5260 <STATIC>
5261
5262 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5263 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5264
5265 type bitstring BIT3
5266 with { encode "RAW"; variant "FIELDLENGTH(3)"};
5267
5268 type set of BIT3 RAW_PDU
5269 with { encode "RAW"; variant "EXTENSION_BIT(yes)"};
5270
5271 const RAW_PDU           i := {'111'B, '000'B, '111'B}
5272 const octetstring       o := 'C301'O
5273
5274 <TTCN_TC:EXEC>
5275
5276 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5277 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5278
5279 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
5280
5281 <RESULT>
5282
5283 Overall verdict: pass
5284
5285 <END_TC>
5286
5287 :exmp.
5288
5289 *---------------------------------------------------------------------*
5290 :h3.   EXTENSION_BIT(reverse)  for set of bitstring
5291 .*---------------------------------------------------------------------*
5292 :xmp tab=0.
5293
5294 <TC-    EXTENSION_BIT(reverse)  for set of bitstring>
5295
5296 <STATIC>
5297
5298 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5299 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5300
5301 type bitstring BIT3
5302 with { encode "RAW"; variant "FIELDLENGTH(3)"};
5303
5304 type set of BIT3 RAW_PDU
5305 with { encode "RAW"; variant "EXTENSION_BIT(reverse)"};
5306
5307 const RAW_PDU           i := {'111'B, '000'B, '111'B}
5308 const octetstring       o := 'E700'O
5309
5310 <TTCN_TC:EXEC>
5311
5312 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5313 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5314
5315 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
5316
5317 <RESULT>
5318
5319 Overall verdict: pass
5320
5321 <END_TC>
5322
5323 :exmp.
5324
5325 *---------------------------------------------------------------------*
5326 :h3.   EXTENSION_BIT(yes)  for set of hexstring
5327 .*---------------------------------------------------------------------*
5328 :xmp tab=0.
5329
5330 <TC-    EXTENSION_BIT(yes)  for set of hexstring>
5331
5332 <STATIC>
5333
5334 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5335 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5336
5337 type set of hexstring RAW_PDU
5338 with { encode "RAW"; variant "EXTENSION_BIT(yes)"};
5339
5340 const RAW_PDU           i := {'F'H, '0'H, 'F'H}
5341 const octetstring       o := '070F'O
5342
5343 <TTCN_TC:EXEC>
5344
5345 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5346 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5347
5348 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
5349
5350 <RESULT>
5351
5352 Overall verdict: pass
5353
5354 <END_TC>
5355
5356 :exmp.
5357
5358 *---------------------------------------------------------------------*
5359 :h3.   EXTENSION_BIT(reverse)  for set of hexstring
5360 .*---------------------------------------------------------------------*
5361 :xmp tab=0.
5362
5363 <TC-    EXTENSION_BIT(reverse)  for set of hexstring>
5364
5365 <STATIC>
5366
5367 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5368 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5369
5370 type set of hexstring RAW_PDU
5371 with { encode "RAW"; variant "EXTENSION_BIT(reverse)"};
5372
5373 const RAW_PDU           i := {'F'H, '00'H, 'FFF'H}
5374 const octetstring       o := '0FF87F'O
5375
5376 <TTCN_TC:EXEC>
5377
5378 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5379 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5380
5381 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
5382
5383 <RESULT>
5384
5385 Overall verdict: pass
5386
5387 <END_TC>
5388
5389 :exmp.
5390
5391
5392 .*---------------------------------------------------------------------*
5393 :h3. Test of  record with EXTENSION_BIT
5394 .*---------------------------------------------------------------------*
5395 :xmp tab=0.
5396
5397 <TC-  Test of  record with EXTENSION_BIT >
5398
5399 <STATIC>
5400
5401 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5402 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5403
5404 group RAW_group{
5405
5406 type bitstring BIT1
5407 with { variant "FIELDLENGTH(1)" } ;
5408
5409 type bitstring BIT7
5410 with { variant "FIELDLENGTH(7)" } ;
5411
5412 type octetstring OCT3
5413 with { variant "FIELDLENGTH(3)" } ;
5414
5415
5416 type record Rec1
5417 { BIT7          data ,
5418   BIT1          extensionbit   }
5419  with { variant "EXTENSION_BIT (yes)"};
5420
5421
5422 type record Rec2
5423 { BIT7          data ,
5424   BIT1          extensionbit   }
5425  with { variant "EXTENSION_BIT (yes)"};
5426
5427
5428 type record Rec3
5429 { BIT7          data ,
5430   BIT1          extensionbit   }
5431  with { variant "EXTENSION_BIT (yes)"};
5432
5433
5434
5435
5436 type record Octet1
5437 { BIT7          data ,
5438   BIT1          extensionbit ,
5439   Rec1          rec1 ,
5440   octetstring   more_extension  optional  }
5441  with { variant "EXTENSION_BIT (yes)" ;
5442         variant (more_extension) "EXTENSION_BIT (yes)"};
5443
5444
5445
5446 type record Octet2
5447 { BIT7          data ,
5448   BIT1          extensionbit ,
5449   Rec2          rec2 ,
5450   octetstring   more_extension  optional  }
5451  with { variant "EXTENSION_BIT (yes)";
5452         variant (more_extension) "EXTENSION_BIT (yes)"};
5453
5454
5455
5456 type record Octet3
5457 { BIT7          data ,
5458   BIT1          extensionbit ,
5459   Rec3          rec3 ,
5460   octetstring   more_extension  optional  }
5461  with { variant "EXTENSION_BIT (yes)";
5462         variant (more_extension) "EXTENSION_BIT (yes)"};
5463
5464
5465
5466
5467 type record RAW_PDU
5468 { OCT3                octstr ,
5469   integer             length1 ,
5470   Octet1              oct1 ,
5471   Octet2              oct2 optional ,
5472   Octet3              oct3 optional }
5473    with { variant  (length1) "LENGTHTO(oct1 , oct2 , oct3   )" }
5474
5475 } with {encode "RAW"}
5476
5477
5478
5479 const RAW_PDU
5480     i := { octstr :=  '123456'O ,
5481            length1 :=      15 ,
5482            oct1 :=
5483                { data :=           '0000001'B ,
5484                  extensionbit :=   '0'B ,
5485                  rec1 :=
5486                    { data :=           '0000001'B ,
5487                      extensionbit :=   '0'B   } ,
5488                  more_extension :=  '000080'O      } ,
5489            oct2 :=
5490                { data :=           '0000010'B ,
5491                  extensionbit :=   '0'B ,
5492                  rec2 :=
5493                    { data :=           '0000010'B ,
5494                      extensionbit :=   '0'B   } ,
5495                  more_extension :=  '000080'O      } ,
5496            oct3 :=
5497                { data :=           '0000011'B ,
5498                  extensionbit :=   '0'B ,
5499                  rec3 :=
5500                    { data :=           '0000011'B ,
5501                      extensionbit :=   '0'B   } ,
5502                  more_extension :=  '000080'O      }     }
5503
5504
5505
5506 const octetstring   o :='1234560F010100008002020000800303000080'O
5507
5508
5509
5510 <TTCN_TC:EXEC>
5511
5512 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5513 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5514
5515 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
5516   else {setverdict(fail);}
5517
5518 <RESULT>
5519
5520 Overall verdict: pass
5521
5522 <END_TC>
5523
5524 :exmp.
5525
5526 .*---------------------------------------------------------------------*
5527 :h3. Test of  record with EXTENSION_BIT
5528 .*---------------------------------------------------------------------*
5529 :xmp tab=0.
5530
5531 <TC-  Test of  record with EXTENSION_BIT >
5532
5533 <STATIC>
5534
5535 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5536 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5537
5538 group RAW_group{
5539
5540 type bitstring BIT1
5541 with { variant "FIELDLENGTH(1)" } ;
5542
5543 type bitstring BIT7
5544 with { variant "FIELDLENGTH(7)" } ;
5545
5546 type octetstring OCT3
5547 with { variant "FIELDLENGTH(3)" } ;
5548
5549
5550 type record Rec1
5551 { BIT7          data ,
5552   BIT1          extensionbit   }
5553  with { variant "EXTENSION_BIT (yes)"};
5554
5555
5556 type record Rec2
5557 { BIT7          data ,
5558   BIT1          extensionbit   }
5559  with { variant "EXTENSION_BIT (yes)"};
5560
5561
5562 type record Rec3
5563 { BIT7          data ,
5564   BIT1          extensionbit   }
5565  with { variant "EXTENSION_BIT (yes)"};
5566
5567
5568
5569
5570 type record Octet1
5571 { BIT7          data ,
5572   BIT1          extensionbit ,
5573   Rec1          rec1 ,
5574   octetstring   more_extension  optional  }
5575  with { variant "EXTENSION_BIT (yes)" ;
5576         variant (more_extension) "EXTENSION_BIT (yes)"};
5577
5578
5579
5580 type record Octet2
5581 { BIT7          data ,
5582   BIT1          extensionbit ,
5583   Rec2          rec2 ,
5584   octetstring   more_extension  optional  }
5585  with { variant "EXTENSION_BIT (yes)";
5586         variant (more_extension) "EXTENSION_BIT (yes)"};
5587
5588
5589
5590 type record Octet3
5591 { BIT7          data ,
5592   BIT1          extensionbit ,
5593   Rec3          rec3 ,
5594   octetstring   more_extension  optional  }
5595  with { variant "EXTENSION_BIT (yes)";
5596         variant (more_extension) "EXTENSION_BIT (yes)"};
5597
5598
5599
5600
5601 type record RAW_PDU
5602 { OCT3                octstr ,
5603   integer             length1 ,
5604   Octet1              oct1 ,
5605   Octet2              oct2 optional ,
5606   Octet3              oct3 optional }
5607    with { variant  (length1) "LENGTHTO(oct1 , oct2 , oct3   )" }
5608
5609 } with {encode "RAW"}
5610
5611
5612
5613
5614 const RAW_PDU
5615     i := { octstr :=  '123456'O ,
5616            length1 :=      12 ,
5617            oct1 :=
5618                { data :=           '0000001'B ,
5619                  extensionbit :=   '0'B ,
5620                  rec1 :=
5621                    { data :=           '0000001'B ,
5622                      extensionbit :=   '0'B   } ,
5623                  more_extension :=  '000080'O      } ,
5624            oct2 :=
5625                { data :=           '0000010'B ,
5626                  extensionbit :=   '0'B ,
5627                  rec2 :=
5628                    { data :=           '0000010'B ,
5629                      extensionbit :=   '1'B   } ,
5630                  more_extension :=  omit      } ,
5631            oct3 :=
5632                { data :=           '0000011'B ,
5633                  extensionbit :=   '0'B ,
5634                  rec3 :=
5635                    { data :=           '0000011'B ,
5636                      extensionbit :=   '0'B   } ,
5637                  more_extension :=  '000080'O      }     }
5638
5639
5640
5641 const octetstring   o :='1234560C010100008002820303000080'O
5642
5643
5644
5645 <TTCN_TC:EXEC>
5646
5647 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5648 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5649
5650 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
5651   else {setverdict(fail);}
5652
5653 <RESULT>
5654
5655 Overall verdict: pass
5656
5657 <END_TC>
5658
5659 :exmp.
5660
5661 .*---------------------------------------------------------------------*
5662 :h3. Test of  record with EXTENSION_BIT
5663 .*---------------------------------------------------------------------*
5664 :xmp tab=0.
5665
5666 <TC-  Test of  record with EXTENSION_BIT >
5667
5668 <STATIC>
5669
5670 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5671 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5672
5673 group RAW_group{
5674
5675 type bitstring BIT1
5676 with { variant "FIELDLENGTH(1)" } ;
5677
5678 type bitstring BIT7
5679 with { variant "FIELDLENGTH(7)" } ;
5680
5681 type octetstring OCT3
5682 with { variant "FIELDLENGTH(3)" } ;
5683
5684
5685 type record Rec1
5686 { BIT7          data ,
5687   BIT1          extensionbit   }
5688  with { variant "EXTENSION_BIT (yes)"};
5689
5690
5691 type record Rec2
5692 { BIT7          data ,
5693   BIT1          extensionbit   }
5694  with { variant "EXTENSION_BIT (yes)"};
5695
5696
5697 type record Rec3
5698 { BIT7          data ,
5699   BIT1          extensionbit   }
5700  with { variant "EXTENSION_BIT (yes)"};
5701
5702
5703
5704
5705 type record Octet1
5706 { BIT7          data ,
5707   BIT1          extensionbit ,
5708   Rec1          rec1 ,
5709   octetstring   more_extension  optional  }
5710  with { variant "EXTENSION_BIT (yes)" ;
5711         variant (more_extension) "EXTENSION_BIT (yes)"};
5712
5713
5714
5715 type record Octet2
5716 { BIT7          data ,
5717   BIT1          extensionbit ,
5718   Rec2          rec2 ,
5719   octetstring   more_extension  optional  }
5720  with { variant "EXTENSION_BIT (yes)";
5721         variant (more_extension) "EXTENSION_BIT (yes)"};
5722
5723
5724
5725 type record Octet3
5726 { BIT7          data ,
5727   BIT1          extensionbit ,
5728   Rec3          rec3 ,
5729   octetstring   more_extension  optional  }
5730  with { variant "EXTENSION_BIT (yes)";
5731         variant (more_extension) "EXTENSION_BIT (yes)"};
5732
5733
5734
5735
5736 type record RAW_PDU
5737 { OCT3                octstr ,
5738   integer             length1 ,
5739   Octet1              oct1 ,
5740   Octet2              oct2 optional ,
5741   Octet3              oct3 optional }
5742    with { variant  (length1) "LENGTHTO(oct1 , oct2 , oct3   )" }
5743
5744 } with {encode "RAW"}
5745
5746
5747
5748
5749 const RAW_PDU
5750     i := { octstr :=  '123456'O ,
5751            length1 :=      9 ,
5752            oct1 :=
5753                { data :=           '0000001'B ,
5754                  extensionbit :=   '0'B ,
5755                  rec1 :=
5756                    { data :=           '0000001'B ,
5757                      extensionbit :=   '0'B   } ,
5758                  more_extension :=  '000080'O      } ,
5759            oct2 :=
5760                { data :=           '0000010'B ,
5761                  extensionbit :=   '0'B ,
5762                  rec2 :=
5763                    { data :=           '0000010'B ,
5764                      extensionbit :=   '1'B   } ,
5765                  more_extension :=  omit      } ,
5766            oct3 :=
5767                { data :=           '0000011'B ,
5768                  extensionbit :=   '0'B ,
5769                  rec3 :=
5770                    { data :=           '0000011'B ,
5771                      extensionbit :=   '1'B   } ,
5772                  more_extension :=  omit      }          }
5773
5774
5775
5776 const octetstring   o :='12345609010100008002820383'O
5777
5778
5779
5780 <TTCN_TC:EXEC>
5781
5782 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5783 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5784
5785 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
5786   else {setverdict(fail);}
5787
5788 <RESULT>
5789
5790 Overall verdict: pass
5791
5792 <END_TC>
5793
5794 :exmp.
5795
5796 .*---------------------------------------------------------------------*
5797 :h3. Test of  record with EXTENSION_BIT
5798 .*---------------------------------------------------------------------*
5799 :xmp tab=0.
5800
5801 <TC-  Test of  record with EXTENSION_BIT >
5802
5803 <STATIC>
5804
5805 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5806 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5807
5808 group RAW_group{
5809
5810 type bitstring BIT1
5811 with { variant "FIELDLENGTH(1)" } ;
5812
5813 type bitstring BIT7
5814 with { variant "FIELDLENGTH(7)" } ;
5815
5816 type octetstring OCT3
5817 with { variant "FIELDLENGTH(3)" } ;
5818
5819
5820 type record Rec1
5821 { BIT7          data ,
5822   BIT1          extensionbit   }
5823  with { variant "EXTENSION_BIT (yes)"};
5824
5825
5826 type record Rec2
5827 { BIT7          data ,
5828   BIT1          extensionbit   }
5829  with { variant "EXTENSION_BIT (yes)"};
5830
5831
5832 type record Rec3
5833 { BIT7          data ,
5834   BIT1          extensionbit   }
5835  with { variant "EXTENSION_BIT (yes)"};
5836
5837
5838
5839
5840 type record Octet1
5841 { BIT7          data ,
5842   BIT1          extensionbit ,
5843   Rec1          rec1 ,
5844   octetstring   more_extension  optional  }
5845  with { variant "EXTENSION_BIT (yes)" ;
5846         variant (more_extension) "EXTENSION_BIT (yes)"};
5847
5848
5849
5850 type record Octet2
5851 { BIT7          data ,
5852   BIT1          extensionbit ,
5853   Rec2          rec2 ,
5854   octetstring   more_extension  optional  }
5855  with { variant "EXTENSION_BIT (yes)";
5856         variant (more_extension) "EXTENSION_BIT (yes)"};
5857
5858
5859
5860 type record Octet3
5861 { BIT7          data ,
5862   BIT1          extensionbit ,
5863   Rec3          rec3 ,
5864   octetstring   more_extension  optional  }
5865  with { variant "EXTENSION_BIT (yes)";
5866         variant (more_extension) "EXTENSION_BIT (yes)"};
5867
5868
5869
5870
5871 type record RAW_PDU
5872 { OCT3                octstr ,
5873   integer             length1 ,
5874   Octet1              oct1 ,
5875   Octet2              oct2 optional ,
5876   Octet3              oct3 optional }
5877    with { variant  (length1) "LENGTHTO(oct1 , oct2 , oct3   )" }
5878
5879 } with {encode "RAW"}
5880
5881
5882
5883
5884 const RAW_PDU
5885     i := { octstr :=  '123456'O ,
5886            length1 :=      6 ,
5887            oct1 :=
5888                { data :=           '0000001'B ,
5889                  extensionbit :=   '0'B ,
5890                  rec1 :=
5891                    { data :=           '0000001'B ,
5892                      extensionbit :=   '1'B   } ,
5893                  more_extension :=  omit     } ,
5894            oct2 :=
5895                { data :=           '0000010'B ,
5896                  extensionbit :=   '0'B ,
5897                  rec2 :=
5898                    { data :=           '0000010'B ,
5899                      extensionbit :=   '1'B   } ,
5900                  more_extension :=  omit      } ,
5901            oct3 :=
5902                { data :=           '0000011'B ,
5903                  extensionbit :=   '0'B ,
5904                  rec3 :=
5905                    { data :=           '0000011'B ,
5906                      extensionbit :=   '1'B   } ,
5907                  more_extension :=  omit      }          }
5908
5909
5910
5911 const octetstring   o :='12345606018102820383'O
5912
5913
5914
5915 <TTCN_TC:EXEC>
5916
5917 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
5918 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
5919
5920 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
5921   else {setverdict(fail);}
5922
5923 <RESULT>
5924
5925 Overall verdict: pass
5926
5927 <END_TC>
5928
5929 :exmp.
5930
5931 .*---------------------------------------------------------------------*
5932 :h3. Test of  record with EXTENSION_BIT
5933 .*---------------------------------------------------------------------*
5934 :xmp tab=0.
5935
5936 <TC-  Test of  record with EXTENSION_BIT >
5937
5938 <STATIC>
5939
5940 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
5941 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
5942
5943 group RAW_group{
5944
5945 type bitstring BIT1
5946 with { variant "FIELDLENGTH(1)" } ;
5947
5948 type bitstring BIT7
5949 with { variant "FIELDLENGTH(7)" } ;
5950
5951 type octetstring OCT3
5952 with { variant "FIELDLENGTH(3)" } ;
5953
5954
5955 type record Rec1
5956 { BIT7          data ,
5957   BIT1          extensionbit   }
5958  with { variant "EXTENSION_BIT (yes)"};
5959
5960
5961 type record Rec2
5962 { BIT7          data ,
5963   BIT1          extensionbit   }
5964  with { variant "EXTENSION_BIT (yes)"};
5965
5966
5967 type record Rec3
5968 { BIT7          data ,
5969   BIT1          extensionbit   }
5970  with { variant "EXTENSION_BIT (yes)"};
5971
5972
5973
5974
5975 type record Octet1
5976 { BIT7          data ,
5977   BIT1          extensionbit ,
5978   Rec1          rec1 ,
5979   octetstring   more_extension  optional  }
5980  with { variant "EXTENSION_BIT (yes)" ;
5981         variant (more_extension) "EXTENSION_BIT (yes)"};
5982
5983
5984
5985 type record Octet2
5986 { BIT7          data ,
5987   BIT1          extensionbit ,
5988   Rec2          rec2 ,
5989   octetstring   more_extension  optional  }
5990  with { variant "EXTENSION_BIT (yes)";
5991         variant (more_extension) "EXTENSION_BIT (yes)"};
5992
5993
5994
5995 type record Octet3
5996 { BIT7          data ,
5997   BIT1          extensionbit ,
5998   Rec3          rec3 ,
5999   octetstring   more_extension  optional  }
6000  with { variant "EXTENSION_BIT (yes)";
6001         variant (more_extension) "EXTENSION_BIT (yes)"};
6002
6003
6004
6005
6006 type record RAW_PDU
6007 { OCT3                octstr ,
6008   integer             length1 ,
6009   Octet1              oct1 ,
6010   Octet2              oct2 optional ,
6011   Octet3              oct3 optional }
6012    with { variant  (length1) "LENGTHTO(oct1 , oct2 , oct3   )" }
6013
6014 } with {encode "RAW"}
6015
6016
6017
6018
6019 const RAW_PDU
6020     i := { octstr :=  '123456'O ,
6021            length1 :=      4 ,
6022            oct1 :=
6023                { data :=           '0000001'B ,
6024                  extensionbit :=   '0'B ,
6025                  rec1 :=
6026                    { data :=           '0000001'B ,
6027                      extensionbit :=   '1'B   } ,
6028                  more_extension :=  omit     } ,
6029            oct2 :=
6030                { data :=           '0000010'B ,
6031                  extensionbit :=   '0'B ,
6032                  rec2 :=
6033                    { data :=           '0000010'B ,
6034                      extensionbit :=   '1'B   } ,
6035                  more_extension :=  omit      } ,
6036            oct3 :=  omit         }
6037
6038
6039
6040 const octetstring   o :='1234560401810282'O
6041
6042
6043
6044 <TTCN_TC:EXEC>
6045
6046 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6047 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6048
6049 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
6050   else {setverdict(fail);}
6051
6052 <RESULT>
6053
6054 Overall verdict: pass
6055
6056 <END_TC>
6057
6058 :exmp.
6059
6060 .*---------------------------------------------------------------------*
6061 :h3. Test of  record with EXTENSION_BIT
6062 .*---------------------------------------------------------------------*
6063 :xmp tab=0.
6064
6065 <TC-  Test of  record with EXTENSION_BIT >
6066
6067 <STATIC>
6068
6069 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6070 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6071
6072 group RAW_group{
6073
6074 type bitstring BIT1
6075 with { variant "FIELDLENGTH(1)" } ;
6076
6077 type bitstring BIT7
6078 with { variant "FIELDLENGTH(7)" } ;
6079
6080 type octetstring OCT3
6081 with { variant "FIELDLENGTH(3)" } ;
6082
6083
6084 type record Rec1
6085 { BIT7          data ,
6086   BIT1          extensionbit   }
6087  with { variant "EXTENSION_BIT (yes)"};
6088
6089
6090 type record Rec2
6091 { BIT7          data ,
6092   BIT1          extensionbit   }
6093  with { variant "EXTENSION_BIT (yes)"};
6094
6095
6096 type record Rec3
6097 { BIT7          data ,
6098   BIT1          extensionbit   }
6099  with { variant "EXTENSION_BIT (yes)"};
6100
6101
6102
6103
6104 type record Octet1
6105 { BIT7          data ,
6106   BIT1          extensionbit ,
6107   Rec1          rec1 ,
6108   octetstring   more_extension  optional  }
6109  with { variant "EXTENSION_BIT (yes)" ;
6110         variant (more_extension) "EXTENSION_BIT (yes)"};
6111
6112
6113
6114 type record Octet2
6115 { BIT7          data ,
6116   BIT1          extensionbit ,
6117   Rec2          rec2 ,
6118   octetstring   more_extension  optional  }
6119  with { variant "EXTENSION_BIT (yes)";
6120         variant (more_extension) "EXTENSION_BIT (yes)"};
6121
6122
6123
6124 type record Octet3
6125 { BIT7          data ,
6126   BIT1          extensionbit ,
6127   Rec3          rec3 ,
6128   octetstring   more_extension  optional  }
6129  with { variant "EXTENSION_BIT (yes)";
6130         variant (more_extension) "EXTENSION_BIT (yes)"};
6131
6132
6133
6134
6135 type record RAW_PDU
6136 { OCT3                octstr ,
6137   integer             length1 ,
6138   Octet1              oct1 ,
6139   Octet2              oct2 optional ,
6140   Octet3              oct3 optional }
6141    with { variant  (length1) "LENGTHTO(oct1 , oct2 , oct3   )" }
6142
6143 } with {encode "RAW"}
6144
6145
6146
6147 const RAW_PDU
6148     i := { octstr :=  '123456'O ,
6149            length1 :=      2 ,
6150            oct1 :=
6151                { data :=           '0000001'B ,
6152                  extensionbit :=   '0'B ,
6153                  rec1 :=
6154                    { data :=           '0000001'B ,
6155                      extensionbit :=   '1'B   } ,
6156                  more_extension :=  omit     } ,
6157            oct2 :=  omit ,
6158            oct3 :=  omit         }
6159
6160
6161
6162 const octetstring   o :='123456020181'O
6163
6164
6165
6166 <TTCN_TC:EXEC>
6167
6168 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6169 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6170
6171 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
6172   else {setverdict(fail);}
6173
6174 <RESULT>
6175
6176 Overall verdict: pass
6177
6178 <END_TC>
6179
6180 :exmp.
6181
6182 .*---------------------------------------------------------------------*
6183 :h3. Test of  record with EXTENSION_BIT
6184 .*---------------------------------------------------------------------*
6185 :xmp tab=0.
6186
6187 <TC-  Test of  record with EXTENSION_BIT >
6188
6189 <STATIC>
6190
6191 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6192 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6193
6194 group RAW_group{
6195
6196 type bitstring BIT1
6197 with { variant "FIELDLENGTH(1)" } ;
6198
6199 type bitstring BIT7
6200 with { variant "FIELDLENGTH(7)" } ;
6201
6202 type octetstring OCT3
6203 with { variant "FIELDLENGTH(3)" } ;
6204
6205
6206 type record Rec1
6207 { BIT7          data ,
6208   BIT1          extensionbit   }
6209  with { variant ""};
6210
6211
6212 type record Rec2
6213 { BIT7          data ,
6214   BIT1          extensionbit   }
6215  with { variant ""};
6216
6217
6218 type record Rec3
6219 { BIT7          data ,
6220   BIT1          extensionbit   }
6221  with { variant ""};
6222
6223
6224
6225
6226 type record Octet1
6227 { BIT7          data ,
6228   BIT1          extensionbit ,
6229   Rec1          rec1 ,
6230   octetstring   more_extension  optional  }
6231  with { variant "EXTENSION_BIT (yes)" ;};
6232
6233
6234
6235 type record Octet2
6236 { BIT7          data ,
6237   BIT1          extensionbit ,
6238   Rec2          rec2 ,
6239   octetstring   more_extension  optional  }
6240  with { variant "EXTENSION_BIT (yes)"};
6241
6242
6243
6244 type record Octet3
6245 { BIT7          data ,
6246   BIT1          extensionbit ,
6247   Rec3          rec3 ,
6248   octetstring   more_extension  optional  }
6249  with { variant "EXTENSION_BIT (yes)"};
6250
6251
6252
6253
6254 type record RAW_PDU
6255 { OCT3                octstr ,
6256   integer             length1 ,
6257   Octet1              oct1 ,
6258   Octet2              oct2 optional ,
6259   Octet3              oct3 optional }
6260    with { variant  (length1) "LENGTHTO(oct1 , oct2 , oct3   )" }
6261
6262 } with {encode "RAW"}
6263
6264
6265
6266
6267 const RAW_PDU
6268     i := { octstr :=  '123456'O ,
6269            length1 :=      15 ,
6270            oct1 :=
6271                { data :=           '0000001'B ,
6272                  extensionbit :=   '0'B ,
6273                  rec1 :=
6274                    { data :=           '0000001'B ,
6275                      extensionbit :=   '0'B   } ,
6276                  more_extension :=  '000080'O      } ,
6277            oct2 :=
6278                { data :=           '0000010'B ,
6279                  extensionbit :=   '0'B ,
6280                  rec2 :=
6281                    { data :=           '0000010'B ,
6282                      extensionbit :=   '0'B   } ,
6283                  more_extension :=  '000080'O      } ,
6284            oct3 :=
6285                { data :=           '0000011'B ,
6286                  extensionbit :=   '0'B ,
6287                  rec3 :=
6288                    { data :=           '0000011'B ,
6289                      extensionbit :=   '0'B   } ,
6290                  more_extension :=  '000080'O      }     }
6291
6292
6293
6294 const octetstring   o :='1234560F010100008002020000800303000080'O
6295
6296
6297
6298 <TTCN_TC:EXEC>
6299
6300 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6301 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6302
6303 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
6304   else {setverdict(fail);}
6305
6306 <RESULT>
6307
6308 Overall verdict: pass
6309
6310 <END_TC>
6311
6312 :exmp.
6313
6314 .*---------------------------------------------------------------------*
6315 :h3. Test of  record with EXTENSION_BIT
6316 .*---------------------------------------------------------------------*
6317 :xmp tab=0.
6318
6319 <TC-  Test of  record with EXTENSION_BIT >
6320
6321 <STATIC>
6322
6323 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6324 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6325
6326 group RAW_group{
6327
6328 type bitstring BIT1
6329 with { variant "FIELDLENGTH(1)" } ;
6330
6331 type bitstring BIT7
6332 with { variant "FIELDLENGTH(7)" } ;
6333
6334 type octetstring OCT3
6335 with { variant "FIELDLENGTH(3)" } ;
6336
6337
6338 type record Rec1
6339 { BIT7          data ,
6340   BIT1          extensionbit   }
6341  with { variant ""};
6342
6343
6344 type record Rec2
6345 { BIT7          data ,
6346   BIT1          extensionbit   }
6347  with { variant ""};
6348
6349
6350 type record Rec3
6351 { BIT7          data ,
6352   BIT1          extensionbit   }
6353  with { variant ""};
6354
6355
6356
6357
6358 type record Octet1
6359 { BIT7          data ,
6360   BIT1          extensionbit ,
6361   Rec1          rec1 ,
6362   octetstring   more_extension  optional  }
6363  with { variant "EXTENSION_BIT (yes)" ;};
6364
6365
6366
6367 type record Octet2
6368 { BIT7          data ,
6369   BIT1          extensionbit ,
6370   Rec2          rec2 ,
6371   octetstring   more_extension  optional  }
6372  with { variant "EXTENSION_BIT (yes)"};
6373
6374
6375
6376 type record Octet3
6377 { BIT7          data ,
6378   BIT1          extensionbit ,
6379   Rec3          rec3 ,
6380   octetstring   more_extension  optional  }
6381  with { variant "EXTENSION_BIT (yes)"};
6382
6383
6384
6385
6386 type record RAW_PDU
6387 { OCT3                octstr ,
6388   integer             length1 ,
6389   Octet1              oct1 ,
6390   Octet2              oct2 optional ,
6391   Octet3              oct3 optional }
6392    with { variant  (length1) "LENGTHTO(oct1 , oct2 , oct3   )" }
6393
6394 }with{encode "RAW"}
6395
6396
6397
6398
6399 const RAW_PDU
6400     i := { octstr :=  '123456'O ,
6401            length1 :=      5 ,
6402            oct1 :=
6403                { data :=           '0000001'B ,
6404                  extensionbit :=   '0'B ,
6405                  rec1 :=
6406                    { data :=           '0000001'B ,
6407                      extensionbit :=   '0'B   } ,
6408                  more_extension :=  '000080'O      } ,
6409            oct2 :=  omit ,
6410            oct3 :=  omit      }
6411
6412
6413
6414 const octetstring   o :='123456050101000080'O
6415
6416
6417
6418 <TTCN_TC:EXEC>
6419
6420 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6421 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6422
6423 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
6424   else {setverdict(fail);}
6425
6426 <RESULT>
6427
6428 Overall verdict: pass
6429
6430 <END_TC>
6431
6432 :exmp.
6433
6434 .*---------------------------------------------------------------------*
6435 :h3. Test of  record with EXTENSION_BIT
6436 .*---------------------------------------------------------------------*
6437 :xmp tab=0.
6438
6439 <TC-  Test of  record with EXTENSION_BIT >
6440
6441 <STATIC>
6442
6443 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6444 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6445
6446 group RAW_group{
6447
6448 type bitstring BIT1
6449 with { variant "FIELDLENGTH(1)" } ;
6450
6451 type bitstring BIT7
6452 with { variant "FIELDLENGTH(7)" } ;
6453
6454 type octetstring OCT3
6455 with { variant "FIELDLENGTH(3)" } ;
6456
6457
6458 type record Rec1
6459 { BIT7          data ,
6460   BIT1          extensionbit   }
6461  with { variant ""};
6462
6463
6464 type record Rec2
6465 { BIT7          data ,
6466   BIT1          extensionbit   }
6467  with { variant ""};
6468
6469
6470 type record Rec3
6471 { BIT7          data ,
6472   BIT1          extensionbit   }
6473  with { variant ""};
6474
6475
6476
6477
6478 type record Octet1
6479 { BIT7          data ,
6480   BIT1          extensionbit ,
6481   Rec1          rec1 ,
6482   octetstring   more_extension  optional  }
6483  with { variant "EXTENSION_BIT (yes)" ;};
6484
6485
6486
6487 type record Octet2
6488 { BIT7          data ,
6489   BIT1          extensionbit ,
6490   Rec2          rec2 ,
6491   octetstring   more_extension  optional  }
6492  with { variant "EXTENSION_BIT (yes)"};
6493
6494
6495
6496 type record Octet3
6497 { BIT7          data ,
6498   BIT1          extensionbit ,
6499   Rec3          rec3 ,
6500   octetstring   more_extension  optional  }
6501  with { variant "EXTENSION_BIT (yes)"};
6502
6503
6504
6505
6506 type record RAW_PDU
6507 { OCT3                octstr ,
6508   integer             length1 ,
6509   Octet1              oct1 ,
6510   Octet2              oct2 optional ,
6511   Octet3              oct3 optional }
6512    with { variant  (length1) "LENGTHTO(oct1 , oct2 , oct3   )" }
6513
6514 }with{encode "RAW"}
6515
6516
6517
6518
6519 const RAW_PDU
6520     i := { octstr :=  '123456'O ,
6521            length1 :=      10 ,
6522            oct1 :=
6523                { data :=           '0000001'B ,
6524                  extensionbit :=   '0'B ,
6525                  rec1 :=
6526                    { data :=           '0000001'B ,
6527                      extensionbit :=   '0'B   } ,
6528                  more_extension :=  '000080'O      } ,
6529            oct2 :=
6530                { data :=           '0000010'B ,
6531                  extensionbit :=   '0'B ,
6532                  rec2 :=
6533                    { data :=           '0000010'B ,
6534                      extensionbit :=   '0'B   } ,
6535                  more_extension :=  '000080'O      } ,
6536            oct3 :=  omit      }
6537
6538
6539
6540 const octetstring   o :='1234560A01010000800202000080'O
6541
6542
6543
6544 <TTCN_TC:EXEC>
6545
6546 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6547 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6548
6549 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
6550   else {setverdict(fail);}
6551
6552 <RESULT>
6553
6554 Overall verdict: pass
6555
6556 <END_TC>
6557
6558 :exmp.
6559
6560
6561 .*---------------------------------------------------------------------*
6562 :h2.Testing EXTENSION_BIT_GROUP Attribute
6563 .*---------------------------------------------------------------------*
6564
6565 .*---------------------------------------------------------------------*
6566 :h3.   EXTENSION_BIT_GROUP(no)
6567 .*---------------------------------------------------------------------*
6568 :xmp tab=0.
6569
6570 <TC-    EXTENSION_BIT_GROUP(no)>
6571
6572 <STATIC>
6573
6574 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6575 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6576
6577 group RAW_group{
6578
6579 type bitstring BIT1 length(1);
6580 type bitstring BIT7 length(7);
6581
6582 type record RAW_PDU {
6583         BIT7    field1,
6584         BIT1    ext1,
6585         BIT7    field2,
6586         BIT1    ext2,
6587         BIT7    field3,
6588         BIT1    ext3
6589 }with { variant "EXTENSION_BIT_GROUP(no, field1, ext3)"};
6590
6591 }with {encode "RAW"}
6592
6593 const RAW_PDU   i := {'1111111'B, '0'B, '1110000'B, '0'B,'0001111'B,'0'B}
6594 const octetstring o := '7F700F'O
6595
6596 <TTCN_TC:EXEC>
6597
6598 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6599 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6600
6601 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
6602
6603 <RESULT>
6604
6605 Overall verdict: pass
6606
6607 <END_TC>
6608
6609 :exmp.
6610
6611 .*---------------------------------------------------------------------*
6612 :h3.   EXTENSION_BIT_GROUP(yes)
6613 .*---------------------------------------------------------------------*
6614 :xmp tab=0.
6615
6616 <TC-    EXTENSION_BIT_GROUP(yes)>
6617
6618 <STATIC>
6619
6620 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6621 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6622
6623 group RAW_group{
6624
6625 type bitstring BIT1 length(1);
6626 type bitstring BIT7 length(7);
6627
6628 type record RAW_PDU {
6629         BIT7    field1,
6630         BIT1    ext1,
6631         BIT7    field2,
6632         BIT1    ext2,
6633         BIT7    field3,
6634         BIT1    ext3
6635 }with { variant "EXTENSION_BIT_GROUP(yes, field1, ext2)"};
6636
6637 }with{encode "RAW"}
6638
6639 const RAW_PDU   i := {'1111111'B, '0'B, '1110000'B, '0'B,'0001111'B,'0'B}
6640 const octetstring o := '7FF00F'O
6641
6642 <TTCN_TC:EXEC>
6643
6644 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6645 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6646
6647 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
6648
6649 <RESULT>
6650
6651 Overall verdict: pass
6652
6653 <END_TC>
6654
6655 :exmp.
6656
6657 .*---------------------------------------------------------------------*
6658 :h3.   EXTENSION_BIT_GROUP(yes) - two groups
6659 .*---------------------------------------------------------------------*
6660 :xmp tab=0.
6661
6662 <TC-    EXTENSION_BIT_GROUP(yes) - two groups>
6663
6664 <STATIC>
6665 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6666 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6667
6668 group RAW_group{
6669
6670 type bitstring BIT1 length(1);
6671 type bitstring BIT7 length(7);
6672
6673 type record RAW_PDU {
6674         BIT7    field1,
6675         BIT1    ext1,
6676         BIT7    field2,
6677         BIT1    ext2,
6678         BIT7    field3,
6679         BIT1    ext3,
6680         BIT7    field4,
6681         BIT1    ext4
6682
6683 }with { variant "EXTENSION_BIT_GROUP(yes, field1, ext2)"
6684         variant "EXTENSION_BIT_GROUP(yes, field3, ext4)"};
6685
6686 }with{encode "RAW"}
6687
6688 const RAW_PDU   i := {'1111111'B, '0'B, '1110000'B, '0'B,'0001111'B,'0'B, '1111111'B, '0'B}
6689 const octetstring o := '7FF00FFF'O
6690
6691 <TTCN_TC:EXEC>
6692
6693 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6694 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6695
6696 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
6697
6698
6699 <RESULT>
6700
6701 Overall verdict: pass
6702
6703 <END_TC>
6704
6705 :exmp.
6706
6707
6708 .*---------------------------------------------------------------------*
6709 :h3.   EXTENSION_BIT_GROUP(yes, reverse) - two groups
6710 .*---------------------------------------------------------------------*
6711 :xmp tab=0.
6712
6713 <TC-    EXTENSION_BIT_GROUP(yes, reverse) - two groups>
6714
6715 <STATIC>
6716 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6717 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6718
6719 group RAW_group{
6720
6721 type bitstring BIT1 length(1);
6722 type bitstring BIT7 length(7);
6723
6724 type record RAW_PDU {
6725         BIT7    field1,
6726         BIT1    ext1,
6727         BIT7    field2,
6728         BIT1    ext2,
6729         BIT7    field3,
6730         BIT1    ext3,
6731         BIT7    field4,
6732         BIT1    ext4
6733
6734 }with { variant "EXTENSION_BIT_GROUP(yes, field1, ext2)"
6735         variant "EXTENSION_BIT_GROUP(reverse, field3, ext4)"};
6736
6737 }with{encode "RAW"}
6738
6739 const RAW_PDU   i := {'1111111'B, '0'B, '1110000'B, '0'B,'0001111'B,'0'B, '1111111'B, '0'B}
6740 const octetstring o := '7FF08F7F'O
6741
6742 <TTCN_TC:EXEC>
6743
6744 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6745 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6746
6747 if (enc_RAW_PDU(i) == o) {setverdict(pass);} else {setverdict(fail);}
6748
6749
6750 <RESULT>
6751
6752 Overall verdict: pass
6753
6754 <END_TC>
6755
6756 :exmp.
6757
6758
6759 .*---------------------------------------------------------------------*
6760 :h2.Testing ALIGN Attribute
6761 .*---------------------------------------------------------------------*
6762
6763 .*---------------------------------------------------------------------*
6764 :h3.   ALIGN(right) for octetstring
6765 .*---------------------------------------------------------------------*
6766 :xmp tab=0.
6767
6768 <TC-    ALIGN(right) for octetstring>
6769
6770 <STATIC>
6771
6772 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6773 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6774
6775 type octetstring RAW_PDU
6776 with { encode "RAW";
6777        variant "FIELDLENGTH(4)";
6778        variant "ALIGN (right)"
6779      };
6780
6781 const RAW_PDU           i := '123456'O
6782 const octetstring       o := '12345600'O
6783
6784 <TTCN_TC:EXEC>
6785
6786 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6787 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6788
6789 if ((enc_RAW_PDU(i) == o)and((dec_RAW_PDU(o) == i & '00'O))) {setverdict(pass);}
6790   else {setverdict(fail);}
6791
6792 <RESULT>
6793
6794 Overall verdict: pass
6795
6796 <END_TC>
6797
6798 :exmp.
6799
6800 .*---------------------------------------------------------------------*
6801 :h3.   ALIGN(left)  for octetstring
6802 .*---------------------------------------------------------------------*
6803 :xmp tab=0.
6804
6805 <TC-    ALIGN(left)  for octetstring>
6806
6807 <STATIC>
6808
6809 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6810 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6811
6812 type octetstring RAW_PDU
6813 with { encode "RAW";
6814        variant "FIELDLENGTH(4)";
6815        variant "ALIGN (left)"
6816      };
6817
6818 const RAW_PDU           i := '123456'O
6819 const octetstring       o := '00123456'O
6820
6821 <TTCN_TC:EXEC>
6822
6823 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6824 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6825
6826 if ((enc_RAW_PDU(i) == o)and((dec_RAW_PDU(o) =='00'O & i ))) {setverdict(pass);}
6827   else {setverdict(fail);}
6828
6829 <RESULT>
6830
6831 Overall verdict: pass
6832
6833 <END_TC>
6834
6835 :exmp.
6836
6837 .*---------------------------------------------------------------------*
6838 :h3.   ALIGN(right) for bitstring
6839 .*---------------------------------------------------------------------*
6840 :xmp tab=0.
6841
6842 <TC-    ALIGN(right) for bitstring>
6843
6844 <STATIC>
6845
6846 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6847 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6848
6849 type bitstring RAW_PDU
6850 with { encode "RAW";
6851        variant "FIELDLENGTH(16)";
6852        variant "ALIGN (right)"
6853      };
6854
6855 const RAW_PDU           i := '11111111'B
6856 const octetstring       o := 'FF00'O
6857
6858 <TTCN_TC:EXEC>
6859
6860 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6861 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6862
6863 if ((enc_RAW_PDU(i) == o)and((dec_RAW_PDU(o) == '00000000'B & i))) {setverdict(pass);}
6864   else {setverdict(fail);}
6865
6866 <RESULT>
6867
6868 Overall verdict: pass
6869
6870 <END_TC>
6871
6872 :exmp.
6873
6874 .*---------------------------------------------------------------------*
6875 :h3.   ALIGN(left)  for bitstring
6876 .*---------------------------------------------------------------------*
6877 :xmp tab=0.
6878
6879 <TC-    ALIGN(left)  for bitstring>
6880
6881 <STATIC>
6882
6883 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6884 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6885
6886 type bitstring RAW_PDU
6887 with { encode "RAW";
6888        variant "FIELDLENGTH(16)";
6889        variant "ALIGN (left)"
6890      };
6891
6892 const RAW_PDU           i := '11111111'B
6893 const octetstring       o := '00FF'O
6894
6895 <TTCN_TC:EXEC>
6896
6897 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6898 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6899
6900 if ((enc_RAW_PDU(i) == o)and((dec_RAW_PDU(o) ==i & '00000000'B ))) {setverdict(pass);}
6901   else {setverdict(fail);}
6902
6903 <RESULT>
6904
6905 Overall verdict: pass
6906
6907 <END_TC>
6908
6909 :exmp.
6910
6911 .*---------------------------------------------------------------------*
6912 :h2.Testing Compound types
6913 .*---------------------------------------------------------------------*
6914
6915 .*---------------------------------------------------------------------*
6916 :h3. Test of  record with integer and octetstring
6917 .*---------------------------------------------------------------------*
6918 :xmp tab=0.
6919
6920 <TC-  Test of  record with integer and octetstring>
6921
6922 <STATIC>
6923
6924 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6925 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6926
6927 group RAW_group{
6928
6929 type record RAW_PDU
6930 {  integer       int ,
6931    octetstring   octstr }
6932 with { variant (int) "FIELDLENGTH(8)" ;
6933        variant (octstr) "FIELDLENGTH(2)" } ;
6934
6935 }with{encode "RAW"}
6936
6937 const RAW_PDU
6938     i := { int :=              20 ,
6939            octstr :=      '1234'O   }
6940
6941
6942
6943 const octetstring       o := '141234'O
6944
6945
6946
6947 <TTCN_TC:EXEC>
6948
6949 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6950 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6951
6952 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
6953   else {setverdict(fail);}
6954
6955 <RESULT>
6956
6957 Overall verdict: pass
6958
6959 <END_TC>
6960
6961 :exmp.
6962
6963 .*---------------------------------------------------------------------*
6964 :h3. Test of  record with default values in field
6965 .*---------------------------------------------------------------------*
6966 :xmp tab=0.
6967
6968 <TC-  Test of  record with default values in field>
6969
6970 <STATIC>
6971
6972 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
6973 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
6974
6975 group RAW_group{
6976
6977 type record RAW_PDU
6978 {  integer       int ,
6979    octetstring   octstr }
6980 with { variant (int) "" ;
6981        variant (octstr) "FIELDLENGTH(2)" } ;
6982
6983 const RAW_PDU
6984     i := { int :=              20 ,
6985            octstr :=      '1234'O   }
6986
6987 }with{encode "RAW"}
6988
6989 const octetstring       o := '141234'O
6990
6991
6992
6993 <TTCN_TC:EXEC>
6994
6995 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
6996 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
6997
6998 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
6999   else {setverdict(fail);}
7000
7001 <RESULT>
7002
7003 Overall verdict: pass
7004
7005 <END_TC>
7006
7007 :exmp.
7008
7009 .*---------------------------------------------------------------------*
7010 :h3. Test of  record with bitstring
7011 .*---------------------------------------------------------------------*
7012 :xmp tab=0.
7013
7014 <TC-  Test of  record with bitstring>
7015
7016 <STATIC>
7017
7018 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7019 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7020
7021 group RAW_group{
7022
7023 type record RAW_PDU
7024 {  integer       int ,
7025    octetstring   octstr ,
7026    bitstring     bit6 ,
7027    bitstring     bit2 }
7028
7029 with { variant (int) "" ;
7030        variant (octstr) "FIELDLENGTH(2)" ;
7031        variant (bit6) "FIELDLENGTH(6)" ;
7032        variant (bit2) "FIELDLENGTH(2)"
7033      } ;
7034
7035 }with{encode "RAW"}
7036
7037
7038 const RAW_PDU
7039     i := { int :=              20 ,
7040            octstr :=      '1234'O ,
7041            bit6 :=      '111111'B ,
7042            bit2 :=          '00'B
7043          }
7044
7045
7046
7047 const octetstring       o := '1412343F'O
7048
7049
7050
7051 <TTCN_TC:EXEC>
7052
7053 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
7054 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
7055
7056 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
7057   else {setverdict(fail);}
7058
7059 <RESULT>
7060
7061 Overall verdict: pass
7062
7063 <END_TC>
7064
7065 :exmp.
7066
7067 .*---------------------------------------------------------------------*
7068 :h3. Test of  record with enumerated and fieldlength calculation
7069 .*---------------------------------------------------------------------*
7070 :xmp tab=0.
7071
7072 <TC-  Test of  record with enumerated and fieldlength calculation>
7073
7074 <STATIC>
7075
7076 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7077 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7078
7079 group RAW_group{
7080
7081 type enumerated enum
7082 { zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
7083 tenth }
7084 with { variant ""};
7085
7086
7087
7088
7089 type record RAW_PDU
7090  { integer       int ,
7091    octetstring   octstr ,
7092    bitstring     bit6 ,
7093    bitstring     bit2 ,
7094    enum          enum1 ,
7095    integer       length1 ,
7096    octetstring   octN    }
7097
7098 with {variant (int) "" ;
7099       variant (octstr) "FIELDLENGTH(2)" ;
7100       variant (bit6) "FIELDLENGTH(6)" ;
7101       variant (bit2) "FIELDLENGTH(2)" ;
7102       variant (enum1) "FIELDLENGTH(8)" ;
7103       variant (length1) "LENGTHTO(octN)" ;
7104       variant (octN) ""
7105      } ;
7106
7107 }with{encode "RAW"}
7108
7109 const RAW_PDU
7110     i := { int :=              20 ,
7111            octstr :=      '1234'O ,
7112            bit6 :=      '111111'B ,
7113            bit2 :=          '00'B ,
7114            enum1 :=         tenth ,
7115            length1:=            3 ,
7116            octN :=      '123456'O
7117
7118          }
7119
7120
7121
7122 const octetstring       o := '1412343F0A03123456'O
7123
7124
7125
7126 <TTCN_TC:EXEC>
7127
7128 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
7129 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
7130
7131 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
7132   else {setverdict(fail);}
7133
7134 <RESULT>
7135
7136 Overall verdict: pass
7137
7138 <END_TC>
7139
7140 :exmp.
7141
7142 .*---------------------------------------------------------------------*
7143 :h3. Test of record called from record
7144 .*---------------------------------------------------------------------*
7145 :xmp tab=0.
7146
7147 <TC-  Test of record called from record>
7148
7149 <STATIC>
7150
7151 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7152 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7153
7154 group RAW_encode{
7155
7156 type enumerated enum
7157 { zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
7158 tenth }
7159 with { variant ""} ;
7160
7161
7162 type record record1
7163  { bitstring       bit1 ,
7164    bitstring       bit3 ,
7165    bitstring       bit4 ,
7166    integer         int  ,
7167    integer         length1 ,
7168    octetstring     octN  }
7169 with { variant (bit1) "FIELDLENGTH(1)" ;
7170        variant (bit3) "FIELDLENGTH(3)" ;
7171        variant (bit4) "FIELDLENGTH(4)" ;
7172        variant (int) "FIELDLENGTH(16)" ;
7173        variant (length1) "LENGTHTO(octN)" ;
7174        variant (octN) ""
7175      }
7176
7177
7178
7179
7180 type record RAW_PDU
7181  { integer       int ,
7182    octetstring   octstr ,
7183    bitstring     bit6 ,
7184    bitstring     bit2 ,
7185    enum          enum1 ,
7186    integer       length1 ,
7187    octetstring   octN ,
7188    integer       length2 ,
7189    record1       rec1    }
7190
7191 with { variant (int) "" ;
7192        variant (octstr) "FIELDLENGTH(2)" ;
7193        variant (bit6) "FIELDLENGTH(6)" ;
7194        variant (bit2) "FIELDLENGTH(2)" ;
7195        variant (enum1) "FIELDLENGTH(8)" ;
7196        variant (length1) "LENGTHTO(octN)" ;
7197        variant (octN) ""  ;
7198        variant (length2) "LENGTHTO(rec1)" ;
7199        variant (rec1) ""
7200      } ;
7201
7202 }with{encode "RAW"}
7203
7204
7205 const RAW_PDU
7206     i := { int :=              20 ,
7207            octstr :=      '1234'O ,
7208            bit6 :=      '111111'B ,
7209            bit2 :=          '00'B ,
7210            enum1 :=         tenth ,
7211            length1:=            3 ,
7212            octN :=      '123456'O  ,
7213            length2:=            7 ,
7214            rec1 :=    {   bit1 :=      '1'B ,
7215                           bit3 :=    '000'B ,
7216                           bit4 :=   '1111'B ,
7217                           int :=       4660 ,
7218                           length1 :=      3 ,
7219                           octN :=  'FFFFFF'O     }
7220
7221          }
7222
7223
7224
7225 const octetstring       o := '1412343F0A0312345607F1341203FFFFFF'O
7226
7227
7228
7229 <TTCN_TC:EXEC>
7230
7231 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
7232 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
7233
7234 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
7235   else {setverdict(fail);}
7236
7237 <RESULT>
7238
7239 Overall verdict: pass
7240
7241 <END_TC>
7242
7243 :exmp.
7244
7245 .*---------------------------------------------------------------------*
7246 :h3. Test of union called from record with CROSSTAG
7247 .*---------------------------------------------------------------------*
7248 :xmp tab=0.
7249
7250 <TC-  Test of union called from record with CROSSTAG>
7251
7252 <STATIC>
7253
7254 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7255 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7256
7257
7258 group RAW_group{
7259
7260 type enumerated enum
7261 { zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
7262 tenth }
7263 with { variant ""} ;
7264
7265
7266 type record record1
7267  { bitstring       bit1 ,
7268    bitstring       bit3 ,
7269    bitstring       bit4 ,
7270    integer         int  ,
7271    integer         length1 ,
7272    octetstring     octN  }
7273 with { variant (bit1) "FIELDLENGTH(1)" ;
7274        variant (bit3) "FIELDLENGTH(3)" ;
7275        variant (bit4) "FIELDLENGTH(4)" ;
7276        variant (int) "FIELDLENGTH(16)" ;
7277        variant (length1) "LENGTHTO(octN)" ;
7278        variant (octN) ""
7279      }
7280
7281
7282
7283 type union optionalpart
7284 { integer  one ,
7285  integer  two ,
7286  integer  three ,
7287  integer  four ,
7288  integer  five }
7289 with { variant (one) "" ;
7290        variant (two) "" ;
7291        variant (three) "" ;
7292        variant (four) "" ;
7293        variant (five) "" ;
7294      }
7295
7296
7297
7298
7299
7300 type record RAW_PDU
7301  { integer       int ,
7302    octetstring   octstr ,
7303    bitstring     bit6 ,
7304    bitstring     bit2 ,
7305    enum          enum1 ,
7306    integer       length1 ,
7307    octetstring   octN ,
7308    integer       length2 ,
7309    record1       rec1 ,
7310    integer       id ,
7311    integer       opt_part_ptr ,
7312    optionalpart  opt_part ,
7313    octetstring   eop        }
7314
7315 with { variant (int) "" ;
7316        variant (octstr) "FIELDLENGTH(2)" ;
7317        variant (bit6) "FIELDLENGTH(6)" ;
7318        variant (bit2) "FIELDLENGTH(2)" ;
7319        variant (enum1) "FIELDLENGTH(8)" ;
7320        variant (length1) "LENGTHTO(octN)" ;
7321        variant (octN) ""  ;
7322        variant (length2) "LENGTHTO(rec1)" ;
7323        variant (rec1) "" ;
7324        variant (id) "" ;
7325        variant (opt_part_ptr) "POINTERTO ( opt_part)";
7326        variant (opt_part) "CROSSTAG  (
7327                                         one ,    id = 1 ;
7328                                         two ,    id = 2 ;
7329                                         three ,  id = 3 ;
7330                                         four ,   id = 4 ;
7331                                         five ,   id = 5       ) ";
7332
7333        variant (eop) "FIELDLENGTH(1)" ;
7334      } ;
7335
7336 }with{encode "RAW"}
7337
7338
7339 const RAW_PDU
7340     i := { int :=              20 ,
7341            octstr :=      '1234'O ,
7342            bit6 :=      '111111'B ,
7343            bit2 :=          '00'B ,
7344            enum1 :=         tenth ,
7345            length1:=            3 ,
7346            octN :=      '123456'O ,
7347            length2:=            7 ,
7348            rec1 :=    {   bit1 :=      '1'B ,
7349                           bit3 :=    '000'B ,
7350                           bit4 :=   '1111'B ,
7351                           int :=       4660 ,
7352                           length1 :=      3 ,
7353                           octN :=  'FFFFFF'O     } ,
7354            id :=                5 ,
7355            opt_part_ptr:=            1 ,
7356            opt_part :=  { five :=  5  } ,
7357            eop :=             '00'O
7358          }
7359
7360
7361
7362 const octetstring       o := '1412343F0A0312345607F1341203FFFFFF05010500'O
7363
7364
7365
7366 <TTCN_TC:EXEC>
7367
7368 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
7369 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
7370
7371 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
7372   else {setverdict(fail);}
7373
7374 <RESULT>
7375
7376 Overall verdict: pass
7377
7378 <END_TC>
7379
7380 :exmp.
7381
7382 .*---------------------------------------------------------------------*
7383 :h3. Test of union called from record with CROSSTAG, OTHERWISE
7384 .*---------------------------------------------------------------------*
7385 :xmp tab=0.
7386
7387 <TC-  Test of union called from record with CROSSTAG, OTHERWISE>
7388
7389 <STATIC>
7390
7391 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7392 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7393
7394
7395 group RAW_group{
7396
7397 type enumerated enum
7398 { zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
7399 tenth }
7400 with { variant ""} ;
7401
7402
7403 type record record1
7404  { bitstring       bit1 ,
7405    bitstring       bit3 ,
7406    bitstring       bit4 ,
7407    integer         int  ,
7408    integer         length1 ,
7409    octetstring     octN  }
7410 with { variant (bit1) "FIELDLENGTH(1)" ;
7411        variant (bit3) "FIELDLENGTH(3)" ;
7412        variant (bit4) "FIELDLENGTH(4)" ;
7413        variant (int) "FIELDLENGTH(16)" ;
7414        variant (length1) "LENGTHTO(octN)" ;
7415        variant (octN) ""
7416      }
7417
7418
7419
7420 type union optionalpart
7421 { integer  one ,
7422  integer  two ,
7423  integer  three ,
7424  integer  four ,
7425  integer  five }
7426 with { variant (one) "" ;
7427        variant (two) "" ;
7428        variant (three) "" ;
7429        variant (four) "" ;
7430        variant (five) "" ;
7431      }
7432
7433
7434
7435
7436
7437 type record RAW_PDU
7438  { integer       int ,
7439    octetstring   octstr ,
7440    bitstring     bit6 ,
7441    bitstring     bit2 ,
7442    enum          enum1 ,
7443    integer       length1 ,
7444    octetstring   octN ,
7445    integer       length2 ,
7446    record1       rec1 ,
7447    integer       id ,
7448    integer       opt_part_ptr ,
7449    optionalpart  opt_part ,
7450    octetstring   eop        }
7451
7452 with { variant (int) "" ;
7453        variant (octstr) "FIELDLENGTH(2)" ;
7454        variant (bit6) "FIELDLENGTH(6)" ;
7455        variant (bit2) "FIELDLENGTH(2)" ;
7456        variant (enum1) "FIELDLENGTH(8)" ;
7457        variant (length1) "LENGTHTO(octN)" ;
7458        variant (octN) ""  ;
7459        variant (length2) "LENGTHTO(rec1)" ;
7460        variant (rec1) "" ;
7461        variant (id) "" ;
7462        variant (opt_part_ptr) "POINTERTO ( opt_part)";
7463        variant (opt_part) "CROSSTAG  (
7464                                         one ,    id = 1 ;
7465                                         two ,    id = 2 ;
7466                                         three ,  id = 3 ;
7467                                         four ,   id = 4 ;
7468                                         five ,   OTHERWISE      ) ";
7469
7470        variant (eop) "FIELDLENGTH(1)" ;
7471      } ;
7472
7473 }with{encode "RAW"}
7474
7475
7476 const RAW_PDU
7477     i := { int :=              20 ,
7478            octstr :=      '1234'O ,
7479            bit6 :=      '111111'B ,
7480            bit2 :=          '00'B ,
7481            enum1 :=         tenth ,
7482            length1:=            3 ,
7483            octN :=      '123456'O ,
7484            length2:=            7 ,
7485            rec1 :=    {   bit1 :=      '1'B ,
7486                           bit3 :=    '000'B ,
7487                           bit4 :=   '1111'B ,
7488                           int :=       4660 ,
7489                           length1 :=      3 ,
7490                           octN :=  'FFFFFF'O     } ,
7491            id :=                5 ,
7492            opt_part_ptr:=            1 ,
7493            opt_part :=  { five :=  5  } ,
7494            eop :=             '00'O
7495          }
7496
7497
7498
7499 const octetstring       o := '1412343F0A0312345607F1341203FFFFFF05010500'O
7500
7501
7502
7503 <TTCN_TC:EXEC>
7504
7505 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
7506 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
7507
7508 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
7509   else {setverdict(fail);}
7510
7511 <RESULT>
7512
7513 Overall verdict: pass
7514
7515 <END_TC>
7516
7517 :exmp.
7518
7519
7520
7521 .*---------------------------------------------------------------------*
7522 :h3. Test of record without specifying the default attributes for fields
7523 .*---------------------------------------------------------------------*
7524 :xmp tab=0.
7525
7526 <TC-  Test of record without specifying the default attributes for fields>
7527
7528 <STATIC>
7529
7530 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7531 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7532
7533
7534 group RAW_group{
7535
7536 type enumerated enum
7537 { zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
7538 tenth }
7539 with { variant ""} ;
7540
7541
7542 type record record1
7543  { bitstring       bit1 ,
7544    bitstring       bit3 ,
7545    bitstring       bit4 ,
7546    integer         int  ,
7547    integer         length1 ,
7548    octetstring     octN  }
7549 with { variant (bit1) "FIELDLENGTH(1)" ;
7550        variant (bit3) "FIELDLENGTH(3)" ;
7551        variant (bit4) "FIELDLENGTH(4)" ;
7552        variant (int) "FIELDLENGTH(16)" ;
7553        variant (length1) "LENGTHTO(octN)"
7554      }
7555
7556
7557
7558 type union optionalpart
7559 { integer  one ,
7560  integer  two ,
7561  integer  three ,
7562  integer  four ,
7563  integer  five }
7564 with { variant "" }
7565
7566
7567
7568
7569
7570 type record RAW_PDU
7571  { integer       int ,
7572    octetstring   octstr ,
7573    bitstring     bit6 ,
7574    bitstring     bit2 ,
7575    enum          enum1 ,
7576    integer       length1 ,
7577    octetstring   octN ,
7578    integer       length2 ,
7579    record1       rec1 ,
7580    integer       id ,
7581    integer       opt_part_ptr ,
7582    optionalpart  opt_part ,
7583    octetstring   eop        }
7584
7585 with { variant (octstr) "FIELDLENGTH(2)" ;
7586        variant (bit6) "FIELDLENGTH(6)" ;
7587        variant (bit2) "FIELDLENGTH(2)" ;
7588        variant (enum1) "FIELDLENGTH(8)" ;
7589        variant (length1) "LENGTHTO(octN)" ;
7590        variant (length2) "LENGTHTO(rec1)" ;
7591        variant (opt_part_ptr) "POINTERTO ( opt_part)";
7592        variant (opt_part) "CROSSTAG  (
7593                                         one ,    id = 1 ;
7594                                         two ,    id = 2 ;
7595                                         three ,  id = 3 ;
7596                                         four ,   id = 4 ;
7597                                         five ,   id = 5      ) ";
7598
7599        variant (eop) "FIELDLENGTH(1)" ;
7600      } ;
7601
7602 }with{encode "RAW"}
7603
7604
7605 const RAW_PDU
7606     i := { int :=              20 ,
7607            octstr :=      '1234'O ,
7608            bit6 :=      '111111'B ,
7609            bit2 :=          '00'B ,
7610            enum1 :=         tenth ,
7611            length1:=            3 ,
7612            octN :=      '123456'O ,
7613            length2:=            7 ,
7614            rec1 :=    {   bit1 :=      '1'B ,
7615                           bit3 :=    '000'B ,
7616                           bit4 :=   '1111'B ,
7617                           int :=       4660 ,
7618                           length1 :=      3 ,
7619                           octN :=  'FFFFFF'O     } ,
7620            id :=                5 ,
7621            opt_part_ptr:=            1 ,
7622            opt_part :=  { five :=  5  } ,
7623            eop :=             '00'O
7624          }
7625
7626
7627
7628 const octetstring       o := '1412343F0A0312345607F1341203FFFFFF05010500'O
7629
7630
7631
7632 <TTCN_TC:EXEC>
7633
7634 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
7635 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
7636
7637 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
7638   else {setverdict(fail);}
7639
7640 <RESULT>
7641
7642 Overall verdict: pass
7643
7644 <END_TC>
7645
7646 :exmp.
7647
7648 .*---------------------------------------------------------------------*
7649 :h3. Test of record of called from record
7650 .*---------------------------------------------------------------------*
7651 :xmp tab=0.
7652
7653 <TC-  Test of record of called from record>
7654
7655 <STATIC>
7656
7657 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7658 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7659
7660
7661
7662 group RAW_group{
7663
7664 type record record2
7665  { octetstring       oct1 ,
7666    integer         length2 ,
7667    octetstring       octN  }
7668 with { variant (oct1) "FIELDLENGTH(1)";
7669        variant (length2) "LENGTHTO(octN)"
7670
7671      }
7672
7673
7674
7675 type record of record2 Rec2list
7676 with { variant "" };
7677
7678
7679
7680
7681 type record RAW_PDU
7682  { integer       length1 ,
7683    Rec2list      rec2list   }
7684
7685 with { variant (length1) "LENGTHTO(rec2list)"   } ;
7686
7687 }with{encode "RAW"}
7688
7689
7690 const RAW_PDU
7691     i := { length1:=            8 ,
7692            rec2list :=  {  {  oct1 :=     '12'O ,
7693                               length2 :=      2 ,
7694                               octN :=   '3456'O     } ,
7695                            {  oct1 :=     '12'O ,
7696                               length2 :=      2 ,
7697                               octN :=   '7890'O     }    }
7698          }
7699
7700
7701
7702 const octetstring       o := '081202345612027890'O
7703
7704
7705
7706 <TTCN_TC:EXEC>
7707
7708 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
7709 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
7710
7711 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
7712   else {setverdict(fail);}
7713
7714 <RESULT>
7715
7716 Overall verdict: pass
7717
7718 <END_TC>
7719
7720 :exmp.
7721
7722 .*---------------------------------------------------------------------*
7723 :h3. Test of set with TAG
7724 .*---------------------------------------------------------------------*
7725 :xmp tab=0.
7726
7727 <TC-  Test of set with TAG >
7728
7729 <STATIC>
7730
7731 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7732 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7733
7734 group RAW_group{
7735
7736 type record intrec
7737  { integer  tag ,
7738    integer  intfield }
7739 with { variant ""} ;
7740
7741
7742 type record octrec
7743  { integer  tag ,
7744    octetstring  octfield }
7745 with { variant (octfield) "FIELDLENGTH(2)"} ;
7746
7747
7748 type record bitrec
7749  { integer  tag ,
7750    bitstring  bit8field }
7751 with { variant (bit8field) "FIELDLENGTH(8)"} ;
7752
7753
7754
7755 type set RAW_PDU
7756  { intrec       int ,
7757    octrec   octstr ,
7758    bitrec     bit8  }
7759
7760 with { variant "TAG (
7761                       int ,      tag=1 ;
7762                       octstr ,   tag=2 ;
7763                       bit8 ,     tag=3     )"
7764      } ;
7765
7766 }with{encode "RAW"}
7767
7768
7769 const RAW_PDU
7770     i := {  octstr :=  { tag := 2 ,
7771                         octfield := '1234'O } ,
7772             int :=   {  tag := 1 ,
7773                        intfield :=  15  } ,
7774             bit8 :=   {  tag := 3 ,
7775                         bit8field :=   '11111111'B }
7776          }
7777
7778
7779
7780 const octetstring       o := '010F02123403FF'O
7781
7782
7783
7784 <TTCN_TC:EXEC>
7785
7786 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
7787 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
7788
7789 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
7790   else {setverdict(fail);}
7791
7792 <RESULT>
7793
7794 Overall verdict: pass
7795
7796 <END_TC>
7797
7798 :exmp.
7799
7800 .*---------------------------------------------------------------------*
7801 :h3. Test of union with TAG , first element called
7802 .*---------------------------------------------------------------------*
7803 :xmp tab=0.
7804
7805 <TC-  Test of union with TAG , first element called>
7806
7807 <STATIC>
7808
7809 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7810 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7811
7812 group RAW_group{
7813
7814 type record intrec
7815  { integer  tag ,
7816    integer  intfield }
7817 with { variant ""} ;
7818
7819
7820 type record octrec
7821  { integer  tag ,
7822    octetstring  octfield }
7823 with { variant (octfield) "FIELDLENGTH(2)"} ;
7824
7825
7826 type record bitrec
7827  { integer  tag ,
7828    bitstring  bit8field }
7829 with { variant (bit8field) "FIELDLENGTH(8)"} ;
7830
7831
7832
7833 type union RAW_PDU
7834  { intrec      int ,
7835    octrec   octstr ,
7836    bitrec     bit8  }
7837
7838 with { variant "TAG (
7839                       int ,      tag=1 ;
7840                       octstr ,   tag=2 ;
7841                       bit8 ,     tag=3     )"
7842      } ;
7843
7844 }with{encode "RAW"}
7845
7846
7847 const RAW_PDU
7848     i := { int :=   {  tag := 1 ,
7849                        intfield :=  15  }
7850          }
7851
7852
7853
7854 const octetstring       o := '010F'O
7855
7856
7857
7858 <TTCN_TC:EXEC>
7859
7860 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
7861 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
7862
7863 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
7864   else {setverdict(fail);}
7865
7866 <RESULT>
7867
7868 Overall verdict: pass
7869
7870 <END_TC>
7871
7872 :exmp.
7873
7874 .*---------------------------------------------------------------------*
7875 :h3. Test of union with TAG , second element called
7876 .*---------------------------------------------------------------------*
7877 :xmp tab=0.
7878
7879 <TC-  Test of union with TAG , second element called>
7880
7881 <STATIC>
7882
7883 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7884 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7885
7886 group RAW_group{
7887
7888 type record intrec
7889  { integer  tag ,
7890    integer  intfield }
7891 with { variant ""} ;
7892
7893
7894 type record octrec
7895  { integer  tag ,
7896    octetstring  octfield }
7897 with { variant (octfield) "FIELDLENGTH(2)"} ;
7898
7899
7900 type record bitrec
7901  { integer  tag ,
7902    bitstring  bit8field }
7903 with { variant (bit8field) "FIELDLENGTH(8)"} ;
7904
7905
7906
7907 type union RAW_PDU
7908  { intrec      int ,
7909    octrec   octstr ,
7910    bitrec     bit8  }
7911
7912 with { variant "TAG (
7913                       int ,      tag=1 ;
7914                       octstr ,   tag=2 ;
7915                       bit8 ,     tag=3)"
7916      } ;
7917
7918 }with{encode "RAW"}
7919
7920
7921 const RAW_PDU
7922     i := {  octstr :=  { tag := 2 ,
7923                         octfield := '1234'O }
7924          }
7925
7926
7927
7928 const octetstring       o := '021234'O
7929
7930
7931
7932
7933 <TTCN_TC:EXEC>
7934
7935 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
7936 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
7937
7938 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
7939   else {setverdict(fail);}
7940
7941 <RESULT>
7942
7943 Overall verdict: pass
7944
7945 <END_TC>
7946
7947 :exmp.
7948
7949 .*---------------------------------------------------------------------*
7950 :h3. Test of union with TAG , third element called
7951 .*---------------------------------------------------------------------*
7952 :xmp tab=0.
7953
7954 <TC-  Test of union with TAG , third element called>
7955
7956 <STATIC>
7957
7958 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
7959 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
7960
7961 group RAW_group{
7962
7963 type record intrec
7964  { integer  tag ,
7965    integer  intfield }
7966 with { variant ""} ;
7967
7968
7969 type record octrec
7970  { integer  tag ,
7971    octetstring  octfield }
7972 with { variant (octfield) "FIELDLENGTH(2)"} ;
7973
7974
7975 type record bitrec
7976  { integer  tag ,
7977    bitstring  bit8field }
7978 with { variant (bit8field) "FIELDLENGTH(8)"} ;
7979
7980
7981
7982 type union RAW_PDU
7983  { intrec      int ,
7984    octrec   octstr ,
7985    bitrec     bit8  }
7986
7987 with { variant "TAG (
7988                       int ,      tag=1 ;
7989                       octstr ,   tag=2 ;
7990                       bit8 ,     tag=3     )"
7991      } ;
7992
7993 }with{encode "RAW"}
7994
7995
7996 const RAW_PDU
7997     i := { bit8 :=   {  tag := 3 ,
7998                         bit8field :=   '11111111'B }
7999          }
8000
8001
8002
8003 const octetstring       o := '03FF'O
8004
8005
8006
8007 <TTCN_TC:EXEC>
8008
8009 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
8010 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
8011
8012 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
8013   else {setverdict(fail);}
8014
8015 <RESULT>
8016
8017 Overall verdict: pass
8018
8019 <END_TC>
8020
8021 :exmp.
8022
8023 .*---------------------------------------------------------------------*
8024 :h3. Test of union with TAG , third element called with OTHERWISE
8025 .*---------------------------------------------------------------------*
8026 :xmp tab=0.
8027
8028 <TC-  Test of union with TAG , third element called with OTHERWISE>
8029
8030 <STATIC>
8031
8032 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
8033 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
8034
8035 group RAW_group{
8036
8037 type record intrec
8038  { integer  tag ,
8039    integer  intfield }
8040 with { variant ""} ;
8041
8042
8043 type record octrec
8044  { integer  tag ,
8045    octetstring  octfield }
8046 with { variant (octfield) "FIELDLENGTH(2)"} ;
8047
8048
8049 type record bitrec
8050  { integer  tag ,
8051    bitstring  bit8field }
8052 with { variant (bit8field) "FIELDLENGTH(8)"} ;
8053
8054
8055
8056 type union RAW_PDU
8057  { intrec      field1 ,
8058    octrec      field2 ,
8059    bitrec      field3}
8060
8061 with { variant "TAG (
8062                       field1,      tag=1 ;
8063                       field2,      tag=2 ;
8064                       field3,      OTHERWISE)"};
8065
8066 }with{encode "RAW"}
8067
8068
8069 const RAW_PDU
8070     i := { field3 :=   {  tag := 3,
8071                         bit8field :=   '11111111'B }
8072          }
8073
8074
8075
8076 const octetstring       o := '03FF'O
8077
8078
8079
8080 <TTCN_TC:EXEC>
8081
8082 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
8083 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
8084
8085 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
8086   else {setverdict(fail);}
8087
8088 <RESULT>
8089
8090 Overall verdict: pass
8091
8092 <END_TC>
8093
8094 :exmp.
8095
8096
8097 .*---------------------------------------------------------------------*
8098 :h3. Test of set of called from record
8099 .*---------------------------------------------------------------------*
8100 :xmp tab=0.
8101
8102 <TC-  Test of set of called from record>
8103
8104 <STATIC>
8105
8106 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
8107 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
8108
8109
8110
8111 group RAW_group{
8112
8113 type record record2
8114  { octetstring       oct1 ,
8115    integer         length2 ,
8116    octetstring       octN  }
8117 with { variant (oct1) "FIELDLENGTH(1)";
8118        variant (length2) "LENGTHTO(octN)"
8119
8120      }
8121
8122 type set of record2 Rec2list
8123 with { variant "" };
8124
8125 type record RAW_PDU
8126  { integer       length1 ,
8127    Rec2list      rec2list   }
8128
8129 with { variant (length1) "LENGTHTO(rec2list)"   } ;
8130
8131 }with{encode "RAW"}
8132
8133
8134 const RAW_PDU
8135     i := { length1:=            8 ,
8136            rec2list :=  {  {  oct1 :=     '12'O ,
8137                               length2 :=      2 ,
8138                               octN :=   '3456'O     } ,
8139                            {  oct1 :=     '12'O ,
8140                               length2 :=      2 ,
8141                               octN :=   '7890'O     }    }
8142          }
8143
8144
8145
8146 const octetstring       o := '081202345612027890'O
8147
8148
8149
8150 <TTCN_TC:EXEC>
8151
8152 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
8153 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
8154
8155 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
8156   else {setverdict(fail);}
8157
8158 <RESULT>
8159
8160 Overall verdict: pass
8161
8162 <END_TC>
8163
8164 :exmp.
8165
8166 .*---------------------------------------------------------------------*
8167 :h3. Test of record with optional field with PRESENCE
8168 .*---------------------------------------------------------------------*
8169 :xmp tab=0.
8170
8171 <TC-  Test of record with optional field with PRESENCE>
8172
8173 <STATIC>
8174
8175 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
8176 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
8177
8178
8179 group RAW_group{
8180
8181 type enumerated enum
8182 { zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
8183 tenth }
8184 with { variant ""} ;
8185
8186
8187 type record record1
8188  { bitstring       bit1 ,
8189    bitstring       bit3 ,
8190    bitstring       bit4 ,
8191    integer         int  ,
8192    integer         length1 ,
8193    octetstring     octN  }
8194 with { variant (bit1) "FIELDLENGTH(1)" ;
8195        variant (bit3) "FIELDLENGTH(3)" ;
8196        variant (bit4) "FIELDLENGTH(4)" ;
8197        variant (int) "FIELDLENGTH(16)" ;
8198        variant (length1) "LENGTHTO(octN)"
8199      }
8200
8201
8202 type union optionalpart
8203 { integer  one ,
8204  integer  two ,
8205  integer  three ,
8206  integer  four ,
8207  integer  five }
8208 with { variant "" }
8209
8210
8211 type record record2
8212  { octetstring       oct1 ,
8213    integer         length2 ,
8214    octetstring       octN  }
8215 with { variant (oct1) "FIELDLENGTH(1)";
8216        variant (length2) "LENGTHTO(octN)"
8217
8218      }
8219
8220
8221 type record of record2 Rec2list
8222 with { variant "" };
8223
8224 type record RAW_PDU
8225  { integer       int ,
8226    octetstring   octstr ,
8227    bitstring     bit6 ,
8228    bitstring     bit2 ,
8229    enum          enum1 ,
8230    integer       length1 ,
8231    octetstring   octN ,
8232    integer       length2 ,
8233    record1       rec1 ,
8234    integer       length3 ,
8235    Rec2list      rec2list ,
8236    integer       id ,
8237    integer       opt_part_ptr ,
8238    integer       presenceid ,
8239    optionalpart  opt_part optional ,
8240    octetstring   eop   optional     }
8241
8242 with { variant (octstr) "FIELDLENGTH(2)" ;
8243        variant (bit6) "FIELDLENGTH(6)" ;
8244        variant (bit2) "FIELDLENGTH(2)" ;
8245        variant (enum1) "FIELDLENGTH(8)" ;
8246        variant (length1) "LENGTHTO(octN)" ;
8247        variant (length2) "LENGTHTO(rec1)" ;
8248        variant (length3) "LENGTHTO(rec2list)"
8249        variant (opt_part_ptr) "POINTERTO ( opt_part)";
8250        variant (opt_part) "PRESENCE (presenceid= 1)" ;
8251        variant (opt_part) "CROSSTAG  (
8252                                         one ,    id = 1 ;
8253                                         two ,    id = 2 ;
8254                                         three ,  id = 3 ;
8255                                         four ,   id = 4 ;
8256                                         five ,   id = 5      ) ";
8257
8258        variant (eop) "FIELDLENGTH(1)" ;
8259      } ;
8260
8261 }with{encode "RAW"}
8262
8263
8264 const RAW_PDU
8265     i := { int :=              20 ,
8266            octstr :=      '1234'O ,
8267            bit6 :=      '111111'B ,
8268            bit2 :=          '00'B ,
8269            enum1 :=         tenth ,
8270            length1:=            3 ,
8271            octN :=      '123456'O ,
8272            length2:=            7 ,
8273            rec1 :=    {   bit1 :=      '1'B ,
8274                           bit3 :=    '000'B ,
8275                           bit4 :=   '1111'B ,
8276                           int :=       4660 ,
8277                           length1 :=      3 ,
8278                           octN :=  'FFFFFF'O     } ,
8279            length3:=            8 ,
8280            rec2list :=  {  {  oct1 :=     '12'O ,
8281                               length2 :=      2 ,
8282                               octN :=   '3456'O     } ,
8283                            {  oct1 :=     '12'O ,
8284                               length2 :=      2 ,
8285                               octN :=   '7890'O     } }  ,
8286            id :=                5 ,
8287            opt_part_ptr:=            2 ,
8288            presenceid := 1 ,
8289            opt_part :=  { five :=  5  } ,
8290            eop :=             '00'O
8291          }
8292
8293
8294
8295 const octetstring       o := '1412343F0A0312345607F1341203FFFFFF0812023456120278900502010500'O
8296
8297
8298
8299 <TTCN_TC:EXEC>
8300
8301 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
8302 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
8303
8304 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
8305   else {setverdict(fail);}
8306
8307 <RESULT>
8308
8309 Overall verdict: pass
8310
8311 <END_TC>
8312
8313 :exmp.
8314
8315 .*---------------------------------------------------------------------*
8316 :h3. Test of  record with UNIT
8317 .*---------------------------------------------------------------------*
8318 :xmp tab=0.
8319
8320 <TC-  Test of  record with UNIT>
8321
8322 <STATIC>
8323
8324 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
8325 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
8326
8327 group RAW_group{
8328
8329 type integer INT1
8330 with { variant "" } ;
8331
8332
8333
8334 type record RAW_PDU
8335 { INT1      length1 ,
8336   octetstring   octstr }
8337 with { variant (length1) "LENGTHTO(octstr)" ;
8338        variant (length1) "UNIT(8)" } ;
8339
8340 }with{encode "RAW"}
8341
8342 const RAW_PDU
8343     i := { length1 :=           4   ,
8344            octstr :=      '12345678'O   }
8345
8346
8347
8348 const octetstring       o := '0412345678'O
8349
8350
8351
8352 <TTCN_TC:EXEC>
8353
8354 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
8355 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
8356
8357 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
8358   else {setverdict(fail);}
8359
8360 <RESULT>
8361
8362 Overall verdict: pass
8363
8364 <END_TC>
8365
8366 :exmp.
8367
8368 .*---------------------------------------------------------------------*
8369 :h3. Test of  record with PTRUNIT
8370 .*---------------------------------------------------------------------*
8371 :xmp tab=0.
8372
8373 <TC-  Test of  record with PTRUNIT>
8374
8375 <STATIC>
8376
8377 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
8378 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
8379
8380 group RAW_group{
8381
8382 type record RAW_PDU
8383 { integer      pointer1 ,
8384   integer      pointer2 ,
8385   integer      pointer3 ,
8386   octetstring   octstr1 ,
8387   octetstring   octstr2 ,
8388   octetstring   octstr3 }
8389 with { variant (pointer1) "POINTERTO(octstr1)" ;
8390        variant (pointer1) "PTRUNIT(1)" ;
8391        variant (pointer2) "POINTERTO(octstr2)" ;
8392        variant (pointer3) "POINTERTO(octstr3)" ;
8393        variant (octstr1) "FIELDLENGTH(3)" ;
8394        variant (octstr2) "FIELDLENGTH(3)" ;
8395        variant (octstr3) "FIELDLENGTH(3)" ;
8396      } ;
8397
8398 }with{encode "RAW"}
8399
8400 const RAW_PDU
8401     i := { pointer1 :=         24 ,
8402            pointer2 :=         5 ,
8403            pointer3 :=         7 ,
8404            octstr1 :=      '010203'O  ,
8405            octstr2 :=      '040506'O  ,
8406            octstr3 :=      '070809'O   }
8407
8408
8409
8410 const octetstring       o := '180507010203040506070809'O
8411
8412
8413
8414 <TTCN_TC:EXEC>
8415
8416 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
8417 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
8418
8419 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
8420   else {setverdict(fail);}
8421
8422 <RESULT>
8423
8424 Overall verdict: pass
8425
8426 <END_TC>
8427
8428 :exmp.
8429
8430 .*---------------------------------------------------------------------*
8431 :h3. Test of  record with PTROFFSET
8432 .*---------------------------------------------------------------------*
8433 :xmp tab=0.
8434
8435 <TC-  Test of  record with PTROFFSET>
8436
8437 <STATIC>
8438
8439 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
8440 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
8441
8442 group RAW_group{
8443
8444 type record RAW_PDU
8445 { integer      pointer1 ,
8446   integer      pointer2 ,
8447   integer      pointer3 ,
8448   octetstring   octstr1 ,
8449   octetstring   octstr2 ,
8450   octetstring   octstr3 }
8451 with { variant (pointer1) "POINTERTO(octstr1)" ;
8452        variant (pointer1) "PTROFFSET(0)" ;
8453        variant (pointer2) "POINTERTO(octstr2)" ;
8454        variant (pointer3) "POINTERTO(octstr3)" ;
8455        variant (octstr1) "FIELDLENGTH(3)" ;
8456        variant (octstr2) "FIELDLENGTH(3)" ;
8457        variant (octstr3) "FIELDLENGTH(3)" ;
8458      } ;
8459
8460 }with{encode "RAW"}
8461
8462 const RAW_PDU
8463     i := { pointer1 :=         3 ,
8464            pointer2 :=         5 ,
8465            pointer3 :=         7 ,
8466            octstr1 :=      '010203'O  ,
8467            octstr2 :=      '040506'O  ,
8468            octstr3 :=      '070809'O   }
8469
8470
8471
8472 const octetstring       o := '030507010203040506070809'O
8473
8474
8475
8476 <TTCN_TC:EXEC>
8477
8478 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
8479 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
8480
8481 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
8482   else {setverdict(fail);}
8483
8484 <RESULT>
8485
8486 Overall verdict: pass
8487
8488 <END_TC>
8489
8490 :exmp.
8491
8492 .*---------------------------------------------------------------------*
8493 :h2. Complicated structured types
8494 .*---------------------------------------------------------------------*
8495
8496 .*---------------------------------------------------------------------*
8497 :h3. Test of  structured types - 1
8498 .*---------------------------------------------------------------------*
8499 :xmp tab=0.
8500
8501 <TC-  Test of  structured types - 1 >
8502
8503 <STATIC>
8504
8505 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
8506 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
8507
8508 group RAW_group{
8509
8510 type record Rec1field
8511 { bitstring  bit7 ,
8512   bitstring  bit1 ,
8513   octetstring oct1 }
8514 with { variant (bit7) "FIELDLENGTH (7)" ;
8515        variant (bit1) "FIELDLENGTH (1)" ;
8516        variant (oct1) "FIELDLENGTH (1)" ;
8517      };
8518
8519 type enumerated Enum1
8520 {zero, first, second, third, fourth, fifth }
8521 with { variant "FIELDLENGTH (8)" };
8522
8523
8524 type record Rec3
8525 { integer  int ,
8526   octetstring octstr ,
8527   bitstring  bitstr   }
8528 with { variant (octstr) "FIELDLENGTH (1)" ;
8529        variant (bitstr) "FIELDLENGTH (8)" ;
8530      };
8531
8532
8533 type record of Rec3  Recof
8534 with { variant "" };
8535
8536 type record Rec5
8537 { integer length1 ,
8538   octetstring octN  }
8539 with { variant (length1) "LENGTHTO (octN)" };
8540
8541
8542
8543 type union Rec2content
8544 { Enum1   enum1 ,
8545   Recof   recof ,
8546   Rec5   rec5    }
8547 with { variant "" };
8548
8549
8550
8551 type record Rec2data
8552 {  octetstring     id ,
8553    integer       length1 ,
8554    octetstring    octN ,
8555    integer       length2 ,
8556    Rec2content   content  }
8557 with { variant (id) "FIELDLENGTH (1)" ;
8558        variant (length1) "LENGTHTO (octN)" ;
8559        variant (length2) "LENGTHTO (content)" ;
8560        variant (content) "CROSSTAG (
8561                                     enum1 ,    id='01'O ;
8562                                     recof ,    id='02'O ;
8563                                     rec5 ,     id='03'O   ) "
8564       };
8565
8566
8567
8568
8569
8570
8571
8572 type set of Rec2data Rec2datas
8573       with { variant "" };
8574
8575
8576
8577 type record RAW_PDU
8578 { integer      length1 ,
8579   Rec1field    rec1field1 ,
8580   integer      length2 ,
8581   Rec1field    rec1field2 ,
8582   Rec2datas      datas  }
8583 with { variant (length1) "LENGTHTO(rec1field1)" ;
8584        variant (length2) "LENGTHTO(rec1field2)"
8585      } ;
8586
8587 }with{encode "RAW"}
8588
8589 const RAW_PDU
8590     i := {  length1 :=    2 ,
8591             rec1field1 :=   { bit7 := '0000001'B ,
8592                               bit1 := '1'B ,
8593                               oct1:=  'FF'O } ,
8594             length2 :=    2 ,
8595             rec1field2 :=   { bit7 := '0000010'B ,
8596                               bit1 := '1'B ,
8597                               oct1:=  'FF'O } ,
8598             datas :={  { id := '01'O ,
8599                          length1 :=   2 ,
8600                          octN :=  '1234'O ,
8601                          length2 :=   1 ,
8602                          content := { enum1 := fifth }    },
8603                        { id := '02'O ,
8604                          length1 :=   2 ,
8605                          octN :=  '5678'O,
8606                          length2 :=   6 ,
8607                          content := { recof := { { int :=  1 ,
8608                                                    octstr := 'FF'O ,
8609                                                    bitstr := '00000000'B  } ,
8610                                                  { int :=  2 ,
8611                                                    octstr := 'FF'O ,
8612                                                    bitstr := '00000000'B    } } } } ,
8613                        { id := '03'O ,
8614                          length1 :=   2 ,
8615                          octN :=  '9012'O,
8616                          length2 :=   6 ,
8617                          content := { rec5 := { length1 :=  5 ,
8618                                                  octN := '1234567890'O  } } } } }
8619
8620
8621
8622 const octetstring       o := '0281FF0282FF010212340105020256780601FF0002FF000302901206051234567890'O
8623
8624
8625
8626 <TTCN_TC:EXEC>
8627
8628 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
8629 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
8630
8631 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
8632   else {setverdict(fail);}
8633
8634 <RESULT>
8635
8636 Overall verdict: pass
8637
8638 <END_TC>
8639
8640 :exmp.
8641
8642 .*---------------------------------------------------------------------*
8643 :h3.  Test of  structured types - 2
8644 .*---------------------------------------------------------------------*
8645 :xmp tab=0.
8646
8647 <TC-   Test of  structured types - 2 >
8648
8649 <STATIC>
8650
8651 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
8652 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
8653
8654 group RAW_group{
8655
8656 type octetstring end_of_optional_parameters_indicator
8657 with { variant "FIELDLENGTH(1)"};
8658
8659 type integer pointer
8660 with { variant "" };
8661
8662 type integer INT1
8663 with { variant "" };
8664
8665 type record Rec1
8666 {  bitstring   bit4 ,
8667    bitstring   bit1 ,
8668    bitstring   bit3 ,
8669    INT1     length1 ,
8670    octetstring octN optional    }
8671 with { variant (bit4) "FIELDLENGTH(4)" ;
8672        variant (bit1) "FIELDLENGTH(1)" ;
8673        variant (bit3) "FIELDLENGTH(3)" ;
8674        variant (length1) "LENGTHTO(octN)" ;
8675      };
8676
8677
8678
8679 type record Rec2
8680 {  bitstring   bit8 ,
8681    INT1     length1 ,
8682    octetstring octN optional    }
8683 with { variant (bit8) "FIELDLENGTH(8)" ;
8684        variant (length1) "LENGTHTO(octN)" ;
8685      };
8686
8687
8688 type record Rec3
8689 {  bitstring   bit4 ,
8690    bitstring   bit1 ,
8691    bitstring   bit3 ,
8692    integer     int ,
8693    octetstring oct2 optional    }
8694 with { variant (bit4) "FIELDLENGTH(4)" ;
8695        variant (bit1) "FIELDLENGTH(1)" ;
8696        variant (bit3) "FIELDLENGTH(3)" ;
8697        variant (oct2) "FIELDLENGTH(2)" ;
8698      };
8699
8700
8701
8702 type record Rec4
8703 {  integer     int ,
8704    octetstring oct5 optional    }
8705 with { variant (oct5) "FIELDLENGTH(5)"};
8706
8707
8708
8709
8710 type union opt_par_union
8711 { octetstring  octstr ,
8712   Rec2         rec2 ,
8713   Rec3         rec3 ,
8714   Rec4         rec4       }
8715  with { variant (octstr) "FIELDLENGTH(2)" };
8716
8717
8718 type record opt_par
8719 {  integer   id ,
8720    integer   length1 ,
8721    opt_par_union  par  }
8722 with { variant (length1) "LENGTHTO(par)" ;
8723        variant (par) "CROSSTAG(
8724                                 octstr ,  id=1 ;
8725                                 rec2  ,   id=2 ;
8726                                 rec3  ,   id=3 ;
8727                                 rec4  ,   id=4 ;  )"
8728      } ;
8729
8730
8731 type set of opt_par optional_part
8732     with { variant "" };
8733
8734
8735 type record RAW_PDU
8736 {  pointer var_part_ptr,
8737    pointer opt_part_ptr,
8738    INT1 length1,
8739    Rec1 rec1 optional,
8740    optional_part opt_part optional,
8741    end_of_optional_parameters_indicator EndOP optional
8742 } with { variant (var_part_ptr) "POINTERTO (length1)";
8743          variant (opt_part_ptr) "POINTERTO (opt_part)";
8744          variant (length1) "LENGTHTO (rec1)" };
8745
8746 }with{encode "RAW"}
8747
8748
8749 const RAW_PDU
8750         i := { var_part_ptr :=      2 ,
8751                opt_part_ptr :=      2 ,
8752                length1 :=        0 ,
8753                rec1 :=   omit ,
8754                opt_part :=   {   { id :=   1 ,      // opt_part := omit
8755                                    length1 :=   2 ,
8756                                    par := { octstr := 'FFFF'O }  }   } ,
8757                EndOP := '00'O     }  // EndOP = omit
8758
8759
8760
8761 const octetstring       o := '0202000102FFFF00'O
8762
8763 <TTCN_TC:EXEC>
8764
8765 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
8766 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
8767
8768 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
8769   else {setverdict(fail);}
8770
8771 <RESULT>
8772
8773 Overall verdict: pass
8774
8775 <END_TC>
8776
8777 :exmp.
8778
8779 .*---------------------------------------------------------------------*
8780 :h3.  Test of  structured types - 3
8781 .*---------------------------------------------------------------------*
8782 :xmp tab=0.
8783
8784 <TC-   Test of  structured types - 3>
8785
8786 <STATIC>
8787
8788 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
8789 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
8790
8791 group RAW_group{
8792
8793 type octetstring end_of_optional_parameters_indicator
8794 with { variant "FIELDLENGTH(1)"};
8795
8796 type integer pointer
8797 with { variant "" };
8798
8799 type integer INT1
8800 with { variant "" };
8801
8802 type record Rec1
8803 {  bitstring   bit4 ,
8804    bitstring   bit1 ,
8805    bitstring   bit3 ,
8806    INT1     length1 ,
8807    octetstring octN optional    }
8808 with { variant (bit4) "FIELDLENGTH(4)" ;
8809        variant (bit1) "FIELDLENGTH(1)" ;
8810        variant (bit3) "FIELDLENGTH(3)" ;
8811        variant (length1) "LENGTHTO(octN)" ;
8812      };
8813
8814
8815
8816 type record Rec2
8817 {  bitstring   bit8 ,
8818    INT1     length1 ,
8819    octetstring octN optional    }
8820 with { variant (bit8) "FIELDLENGTH(8)" ;
8821        variant (length1) "LENGTHTO(octN)" ;
8822      };
8823
8824
8825 type record Rec3
8826 {  bitstring   bit4 ,
8827    bitstring   bit1 ,
8828    bitstring   bit3 ,
8829    integer     int ,
8830    octetstring oct2 optional    }
8831 with { variant (bit4) "FIELDLENGTH(4)" ;
8832        variant (bit1) "FIELDLENGTH(1)" ;
8833        variant (bit3) "FIELDLENGTH(3)" ;
8834        variant (oct2) "FIELDLENGTH(2)" ;
8835      };
8836
8837
8838
8839 type record Rec4
8840 {  integer     int ,
8841    octetstring oct5 optional    }
8842 with { variant (oct5) "FIELDLENGTH(5)"};
8843
8844
8845
8846
8847 type union opt_par_union
8848 { octetstring  octstr ,
8849   Rec2         rec2 ,
8850   Rec3         rec3 ,
8851   Rec4         rec4       }
8852  with { variant (octstr) "FIELDLENGTH(2)" };
8853
8854
8855 type record opt_par
8856 {  integer   id ,
8857    integer   length1 ,
8858    opt_par_union  par  }
8859 with { variant (length1) "LENGTHTO(par)" ;
8860        variant (par) "CROSSTAG(
8861                                 octstr ,  id=1 ;
8862                                 rec2  ,   id=2 ;
8863                                 rec3  ,   id=3 ;
8864                                 rec4  ,   id=4 ;  )"
8865      } ;
8866
8867
8868 type set of opt_par optional_part
8869     with { variant "" };
8870
8871
8872 type record RAW_PDU
8873 {  pointer var_part_ptr,
8874    pointer opt_part_ptr,
8875    INT1 length1,
8876    Rec1 rec1 optional,
8877    optional_part opt_part optional,
8878    end_of_optional_parameters_indicator EndOP optional
8879 } with { variant (var_part_ptr) "POINTERTO (length1)";
8880          variant (opt_part_ptr) "POINTERTO (opt_part)";
8881          variant (length1) "LENGTHTO (rec1)" };
8882
8883 }with{encode "RAW"}
8884
8885
8886 const RAW_PDU
8887         i := { var_part_ptr :=      2 ,
8888                opt_part_ptr :=      7 ,
8889                length1 :=        5 ,
8890                rec1 :=   {  bit4 := '1111'B ,      // rec1 := omit
8891                             bit1 := '1'B ,
8892                             bit3 := '000'B ,
8893                             length1 := 3 ,
8894                             octN :=  '123456'O   } , // octN := omit
8895                opt_part :=   {   { id :=   1 ,      // opt_part := omit
8896                                    length1 :=   2 ,
8897                                    par := { octstr := 'FFFF'O }  }   } ,
8898                EndOP := '00'O     }  // EndOP = omit
8899
8900
8901
8902 const octetstring       o := '0207051F031234560102FFFF00'O
8903
8904 <TTCN_TC:EXEC>
8905
8906 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
8907 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
8908
8909 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
8910   else {setverdict(fail);}
8911
8912 <RESULT>
8913
8914 Overall verdict: pass
8915
8916 <END_TC>
8917
8918 :exmp.
8919
8920 .*---------------------------------------------------------------------*
8921 :h3.  Test of  structured types - 4
8922 .*---------------------------------------------------------------------*
8923 :xmp tab=0.
8924
8925 <TC-   Test of  structured types - 4>
8926
8927 <STATIC>
8928
8929 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
8930 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
8931
8932 group RAW_group{
8933
8934 type octetstring end_of_optional_parameters_indicator
8935 with { variant "FIELDLENGTH(1)"};
8936
8937 type integer pointer
8938 with { variant "" };
8939
8940 type integer INT1
8941 with { variant "" };
8942
8943 type record Rec1
8944 {  bitstring   bit4 ,
8945    bitstring   bit1 ,
8946    bitstring   bit3 ,
8947    INT1     length1 ,
8948    octetstring octN optional    }
8949 with { variant (bit4) "FIELDLENGTH(4)" ;
8950        variant (bit1) "FIELDLENGTH(1)" ;
8951        variant (bit3) "FIELDLENGTH(3)" ;
8952        variant (length1) "LENGTHTO(octN)" ;
8953      };
8954
8955
8956
8957 type record Rec2
8958 {  bitstring   bit8 ,
8959    INT1     length1 ,
8960    octetstring octN optional    }
8961 with { variant (bit8) "FIELDLENGTH(8)" ;
8962        variant (length1) "LENGTHTO(octN)" ;
8963      };
8964
8965
8966 type record Rec3
8967 {  bitstring   bit4 ,
8968    bitstring   bit1 ,
8969    bitstring   bit3 ,
8970    integer     int ,
8971    octetstring oct2 optional    }
8972 with { variant (bit4) "FIELDLENGTH(4)" ;
8973        variant (bit1) "FIELDLENGTH(1)" ;
8974        variant (bit3) "FIELDLENGTH(3)" ;
8975        variant (oct2) "FIELDLENGTH(2)" ;
8976      };
8977
8978
8979
8980 type record Rec4
8981 {  integer     int ,
8982    octetstring oct5 optional    }
8983 with { variant (oct5) "FIELDLENGTH(5)"};
8984
8985
8986
8987
8988 type union opt_par_union
8989 { octetstring  octstr ,
8990   Rec2         rec2 ,
8991   Rec3         rec3 ,
8992   Rec4         rec4       }
8993  with { variant (octstr) "FIELDLENGTH(2)" };
8994
8995
8996 type record opt_par
8997 {  integer   id ,
8998    integer   length1 ,
8999    opt_par_union  par  }
9000 with { variant (length1) "LENGTHTO(par)" ;
9001        variant (par) "CROSSTAG(
9002                                 octstr ,  id=1 ;
9003                                 rec2  ,   id=2 ;
9004                                 rec3  ,   id=3 ;
9005                                 rec4  ,   id=4 ;  )"
9006      } ;
9007
9008
9009 type set of opt_par optional_part
9010     with { variant "" };
9011
9012
9013 type record RAW_PDU
9014 {  pointer var_part_ptr,
9015    pointer opt_part_ptr,
9016    INT1 length1,
9017    Rec1 rec1 optional,
9018    optional_part opt_part optional,
9019    end_of_optional_parameters_indicator EndOP optional
9020 } with { variant (var_part_ptr) "POINTERTO (length1)";
9021          variant (opt_part_ptr) "POINTERTO (opt_part)";
9022          variant (length1) "LENGTHTO (rec1)" };
9023
9024 }with{encode "RAW"}
9025
9026
9027 const RAW_PDU
9028         i := { var_part_ptr :=      2 ,
9029                opt_part_ptr :=      7 ,
9030                length1 :=        5 ,
9031                rec1 :=   {  bit4 := '1111'B ,      // rec1 := omit
9032                             bit1 := '1'B ,
9033                             bit3 := '000'B ,
9034                             length1 := 3 ,
9035                             octN :=  '123456'O   } , // octN := omit
9036                opt_part :=   {   { id :=   1 ,      // opt_part := omit
9037                                    length1 :=   2 ,
9038                                    par := { octstr := 'FFFF'O }  } ,
9039                                  { id :=   2 ,
9040                                    length1 :=   7 ,
9041                                    par := { rec2:=  { bit8 := '00000000'B ,
9042                                                       length1 :=   5 ,
9043                                                       octN := '1234567890'O } } } ,  //  octN := omit
9044                                  { id :=   3 ,
9045                                    length1 :=   4 ,
9046                                    par :=  { rec3 := { bit4 := '1111'B ,
9047                                                        bit1 := '0'B ,
9048                                                        bit3 := '100'B ,
9049                                                        int :=   15 ,
9050                                                        oct2 := '1234'O } } } ,  //  oct2 := omit
9051                                  { id :=   4 ,
9052                                    length1 :=   6 ,
9053                                    par := { rec4:=  { int :=   15 ,
9054                                                       oct5 := '1234567890'O } } } } ,  //  oct5 := omit
9055                EndOP := '00'O     }  // EndOP = omit
9056
9057
9058
9059 const octetstring       o := '0207051F031234560102FFFF02070005123456789003048F0F123404060F123456789000'O
9060
9061 <TTCN_TC:EXEC>
9062
9063 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
9064 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
9065
9066 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
9067   else {setverdict(fail);}
9068
9069 <RESULT>
9070
9071 Overall verdict: pass
9072
9073 <END_TC>
9074
9075 :exmp.
9076
9077 .*---------------------------------------------------------------------*
9078 :h3.  Test of  structured types - 5
9079 .*---------------------------------------------------------------------*
9080 :xmp tab=0.
9081
9082 <TC-   Test of  structured types - 5>
9083
9084 <STATIC>
9085
9086 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
9087 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
9088
9089 group RAW_group{
9090
9091 type octetstring end_of_optional_parameters_indicator
9092 with { variant "FIELDLENGTH(1)"};
9093
9094 type integer pointer
9095 with { variant "" };
9096
9097 type integer INT1
9098 with { variant "" };
9099
9100 type record Rec1
9101 {  bitstring   bit4 ,
9102    bitstring   bit1 ,
9103    bitstring   bit3 ,
9104    INT1     length1 ,
9105    octetstring octN optional    }
9106 with { variant (bit4) "FIELDLENGTH(4)" ;
9107        variant (bit1) "FIELDLENGTH(1)" ;
9108        variant (bit3) "FIELDLENGTH(3)" ;
9109        variant (length1) "LENGTHTO(octN)" ;
9110      };
9111
9112
9113 type record Rec2
9114 {  bitstring   bit8 ,
9115    INT1     length1 ,
9116    octetstring octN optional    }
9117 with { variant (bit8) "FIELDLENGTH(8)" ;
9118        variant (length1) "LENGTHTO(octN)" ;
9119      };
9120
9121
9122 type record Rec3
9123 {  bitstring   bit4 ,
9124    bitstring   bit1 ,
9125    bitstring   bit3 ,
9126    integer     int ,
9127    octetstring oct2 optional    }
9128 with { variant (bit4) "FIELDLENGTH(4)" ;
9129        variant (bit1) "FIELDLENGTH(1)" ;
9130        variant (bit3) "FIELDLENGTH(3)" ;
9131        variant (oct2) "FIELDLENGTH(2)" ;
9132      };
9133
9134
9135
9136 type record Rec4
9137 {  integer     int ,
9138    octetstring oct5 optional    }
9139 with { variant (oct5) "FIELDLENGTH(5)" };
9140
9141
9142 type union opt_par_union
9143 { octetstring  octstr ,
9144   Rec2         rec2 ,
9145   Rec3         rec3 ,
9146   Rec4         rec4       }
9147  with { variant (octstr) "FIELDLENGTH(2)" };
9148
9149
9150 type record opt_par
9151 {  integer   id ,
9152    integer   length1 ,
9153    opt_par_union  par  }
9154 with { variant (length1) "LENGTHTO(par)" ;
9155        variant (par) "CROSSTAG(
9156                                 octstr ,  id=1 ;
9157                                 rec2  ,   id=2 ;
9158                                 rec3  ,   id=3 ;
9159                                 rec4  ,   id=4 ;  )"
9160      } ;
9161
9162
9163
9164
9165 type set of opt_par optional_part
9166     with { variant "" };
9167
9168
9169 type record RAW_PDU
9170 {  pointer var_part_ptr,
9171    pointer opt_part_ptr,
9172    INT1 length1,
9173    Rec1 rec1 optional,
9174    optional_part opt_part optional,
9175    end_of_optional_parameters_indicator EndOP optional
9176 } with { variant (var_part_ptr) "POINTERTO (length1)";
9177          variant (opt_part_ptr) "POINTERTO (opt_part)";
9178          variant (length1) "LENGTHTO (rec1)" };
9179
9180 }with{encode "RAW"}
9181
9182 const RAW_PDU
9183         i := { var_part_ptr :=      2 ,
9184                opt_part_ptr :=      4 ,
9185                length1 :=        2 ,
9186                rec1 :=   {  bit4 := '1111'B ,      // rec1 := omit
9187                             bit1 := '1'B ,
9188                             bit3 := '000'B ,
9189                             length1 := 0 ,
9190                             octN :=  omit   } ,
9191                opt_part :=   {   { id :=   1 ,      // opt_part := omit
9192                                    length1 :=   2 ,
9193                                    par := { octstr := 'FFFF'O }  } ,
9194                                  { id :=   2 ,
9195                                    length1 :=   7 ,
9196                                    par := { rec2:=  { bit8 := '00000000'B ,
9197                                                       length1 :=   5 ,
9198                                                       octN := '1234567890'O } } } ,  //  octN := omit
9199                                  { id :=   3 ,
9200                                    length1 :=   4 ,
9201                                    par :=  { rec3 := { bit4 := '1111'B ,
9202                                                        bit1 := '0'B ,
9203                                                        bit3 := '100'B ,
9204                                                        int :=   15 ,
9205                                                        oct2 := '1234'O } } } ,  //  oct2 := omit
9206                                  { id :=   4 ,
9207                                    length1 :=   6 ,
9208                                    par := { rec4:=  { int :=   15 ,
9209                                                       oct5 := '1234567890'O } } } } ,  //  oct5 := omit
9210                EndOP := '00'O     }  // EndOP = omit
9211
9212
9213
9214 const octetstring       o := '0204021F000102FFFF02070005123456789003048F0F123404060F123456789000'O
9215
9216 <TTCN_TC:EXEC>
9217
9218 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
9219 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
9220
9221 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
9222   else {setverdict(fail);}
9223
9224 <RESULT>
9225
9226 Overall verdict: pass
9227
9228 <END_TC>
9229
9230 :exmp.
9231
9232 .*---------------------------------------------------------------------*
9233 :h3.  Test of  structured types - 6
9234 .*---------------------------------------------------------------------*
9235 :xmp tab=0.
9236
9237 <TC-   Test of  structured types - 6>
9238
9239 <STATIC>
9240
9241 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
9242 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
9243
9244 group RAW_group{
9245
9246 type octetstring end_of_optional_parameters_indicator
9247 with { variant "FIELDLENGTH(1)"};
9248
9249 type integer pointer
9250 with { variant "" };
9251
9252 type integer INT1
9253 with { variant "" };
9254
9255 type record Rec1
9256 {  bitstring   bit4 ,
9257    bitstring   bit1 ,
9258    bitstring   bit3 ,
9259    INT1     length1 ,
9260    octetstring octN optional    }
9261 with { variant (bit4) "FIELDLENGTH(4)" ;
9262        variant (bit1) "FIELDLENGTH(1)" ;
9263        variant (bit3) "FIELDLENGTH(3)" ;
9264        variant (length1) "LENGTHTO(octN)" ;
9265      };
9266
9267 type record Rec2
9268 {  bitstring   bit8 ,
9269    INT1     length1 ,
9270    octetstring octN optional    }
9271 with { variant (bit8) "FIELDLENGTH(8)" ;
9272        variant (length1) "LENGTHTO(octN)" ;
9273      };
9274
9275
9276 type record Rec3
9277 {  bitstring   bit4 ,
9278    bitstring   bit1 ,
9279    bitstring   bit3 ,
9280    integer     int ,
9281    octetstring oct2 optional    }
9282 with { variant (bit4) "FIELDLENGTH(4)" ;
9283        variant (bit1) "FIELDLENGTH(1)" ;
9284        variant (bit3) "FIELDLENGTH(3)" ;
9285        variant (oct2) "FIELDLENGTH(2)" ;
9286      };
9287
9288
9289
9290 type record Rec4
9291 {  integer     int ,
9292    octetstring oct5 optional    }
9293 with { variant (oct5) "FIELDLENGTH(5)"};
9294
9295 type union opt_par_union
9296 { octetstring  octstr ,
9297   Rec2         rec2 ,
9298   Rec3         rec3 ,
9299   Rec4         rec4       }
9300  with { variant (octstr) "FIELDLENGTH(2)" };
9301
9302
9303 type record opt_par
9304 {  integer   id ,
9305    integer   length1 ,
9306    opt_par_union  par  }
9307 with { variant (length1) "LENGTHTO(par)" ;
9308        variant (par) "CROSSTAG(
9309                                 octstr ,  id=1 ;
9310                                 rec2  ,   id=2 ;
9311                                 rec3  ,   id=3 ;
9312                                 rec4  ,   id=4 ;  )"
9313      } ;
9314
9315
9316 type set of opt_par optional_part
9317     with { variant "" };
9318
9319
9320 type record RAW_PDU
9321 {  pointer var_part_ptr,
9322    pointer opt_part_ptr,
9323    INT1 length1,
9324    Rec1 rec1 optional,
9325    optional_part opt_part optional,
9326    end_of_optional_parameters_indicator EndOP optional
9327 } with { variant (var_part_ptr) "POINTERTO (length1)";
9328          variant (opt_part_ptr) "POINTERTO (opt_part)";
9329          variant (length1) "LENGTHTO (rec1)" };
9330
9331 }with{encode "RAW"}
9332
9333
9334 const RAW_PDU
9335         i := { var_part_ptr :=      2 ,
9336                opt_part_ptr :=      2 ,
9337                length1 :=        0 ,
9338                rec1 :=  omit ,
9339                opt_part :=   {   { id :=   1 ,      // opt_part := omit
9340                                    length1 :=   2 ,
9341                                    par := { octstr := 'FFFF'O }  } ,
9342                                  { id :=   2 ,
9343                                    length1 :=   7 ,
9344                                    par := { rec2:=  { bit8 := '00000000'B ,
9345                                                       length1 :=   5 ,
9346                                                       octN := '1234567890'O } } } ,  //  octN := omit
9347                                  { id :=   3 ,
9348                                    length1 :=   4 ,
9349                                    par :=  { rec3 := { bit4 := '1111'B ,
9350                                                        bit1 := '0'B ,
9351                                                        bit3 := '100'B ,
9352                                                        int :=   15 ,
9353                                                        oct2 := '1234'O } } } ,  //  oct2 := omit
9354                                  { id :=   4 ,
9355                                    length1 :=   6 ,
9356                                    par := { rec4:=  { int :=   15 ,
9357                                                       oct5 := '1234567890'O } } } } ,  //  oct5 := omit
9358                EndOP := '00'O     }  // EndOP = omit
9359
9360
9361
9362 const octetstring       o := '0202000102FFFF02070005123456789003048F0F123404060F123456789000'O
9363
9364 <TTCN_TC:EXEC>
9365
9366 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
9367 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
9368
9369 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
9370   else {setverdict(fail);}
9371
9372 <RESULT>
9373
9374 Overall verdict: pass
9375
9376 <END_TC>
9377
9378 :exmp.
9379
9380 .*---------------------------------------------------------------------*
9381 :h3.  Test of  structured types - 7
9382 .*---------------------------------------------------------------------*
9383 :xmp tab=0.
9384
9385 <TC-   Test of  structured types - 7 >
9386
9387 <STATIC>
9388
9389 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
9390 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
9391
9392 group RAW_group{
9393
9394 type octetstring end_of_optional_parameters_indicator
9395 with { variant "FIELDLENGTH(1)"};
9396
9397 type integer pointer
9398 with { variant "" };
9399
9400 type integer INT1
9401 with { variant "" };
9402
9403 type record Rec1
9404 {  bitstring   bit4 ,
9405    bitstring   bit1 ,
9406    bitstring   bit3 ,
9407    INT1     length1 ,
9408    octetstring octN optional    }
9409 with { variant (bit4) "FIELDLENGTH(4)" ;
9410        variant (bit1) "FIELDLENGTH(1)" ;
9411        variant (bit3) "FIELDLENGTH(3)" ;
9412        variant (length1) "LENGTHTO(octN)" ;
9413      };
9414
9415
9416 type record Rec2
9417 {  bitstring   bit8 ,
9418    INT1     length1 ,
9419    octetstring octN optional    }
9420 with { variant (bit8) "FIELDLENGTH(8)" ;
9421        variant (length1) "LENGTHTO(octN)" ;
9422      };
9423
9424
9425 type record Rec3
9426 {  bitstring   bit4 ,
9427    bitstring   bit1 ,
9428    bitstring   bit3 ,
9429    integer     int ,
9430    octetstring oct2 optional    }
9431 with { variant (bit4) "FIELDLENGTH(4)" ;
9432        variant (bit1) "FIELDLENGTH(1)" ;
9433        variant (bit3) "FIELDLENGTH(3)" ;
9434        variant (oct2) "FIELDLENGTH(2)" ;
9435      };
9436
9437
9438
9439 type record Rec4
9440 {  integer     int ,
9441    octetstring oct5 optional    }
9442 with { variant (oct5) "FIELDLENGTH(5)"};
9443
9444
9445 type union opt_par_union
9446 { octetstring  octstr ,
9447   Rec2         rec2 ,
9448   Rec3         rec3 ,
9449   Rec4         rec4       }
9450  with { variant (octstr) "FIELDLENGTH(2)" };
9451
9452
9453 type record opt_par
9454 {  integer   id ,
9455    integer   length1 ,
9456    opt_par_union  par  }
9457 with { variant (length1) "LENGTHTO(par)" ;
9458        variant (par) "CROSSTAG(
9459                                 octstr ,  id=1 ;
9460                                 rec2  ,   id=2 ;
9461                                 rec3  ,   id=3 ;
9462                                 rec4  ,   id=4 ;  )"
9463      } ;
9464
9465
9466 type set of opt_par optional_part
9467     with { variant "" };
9468
9469
9470 type record RAW_PDU
9471 {  pointer var_part_ptr,
9472    pointer opt_part_ptr,
9473    INT1 length1,
9474    Rec1 rec1 optional,
9475    optional_part opt_part optional,
9476    end_of_optional_parameters_indicator EndOP optional
9477 } with { variant (var_part_ptr) "POINTERTO (length1)";
9478          variant (opt_part_ptr) "POINTERTO (opt_part)";
9479          variant (length1) "LENGTHTO (rec1)" };
9480
9481 }with{encode "RAW"}
9482
9483
9484 const RAW_PDU
9485         i := { var_part_ptr :=      2 ,
9486                opt_part_ptr :=      2 ,
9487                length1 :=        0 ,
9488                rec1 :=  omit ,
9489                opt_part :=   {   { id :=   1 ,      // opt_part := omit
9490                                    length1 :=   2 ,
9491                                    par := { octstr := 'FFFF'O }  } ,
9492                                  { id :=   2 ,
9493                                    length1 :=   2 ,
9494                                    par := { rec2:=  { bit8 := '00000000'B ,
9495                                                       length1 :=   0 ,
9496                                                       octN := omit } } } ,
9497                                  { id :=   3 ,
9498                                    length1 :=   2 ,
9499                                    par :=  { rec3 := { bit4 := '1111'B ,
9500                                                        bit1 := '0'B ,
9501                                                        bit3 := '100'B ,
9502                                                        int :=   15 ,
9503                                                        oct2 := omit } } } ,
9504                                  { id :=   4 ,
9505                                    length1 :=   1 ,
9506                                    par := { rec4:=  { int :=   15 ,
9507                                                       oct5 := omit } } } } ,
9508                EndOP := '00'O     }  // EndOP = omit
9509
9510
9511
9512 const octetstring       o := '0202000102FFFF0202000003028F0F04010F00'O
9513
9514 <TTCN_TC:EXEC>
9515
9516 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
9517 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
9518
9519 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
9520   else {setverdict(fail);}
9521
9522 <RESULT>
9523
9524 Overall verdict: pass
9525
9526 <END_TC>
9527
9528 :exmp.
9529
9530 .*---------------------------------------------------------------------*
9531 :h3.  Test of  structured types - 8
9532 .*---------------------------------------------------------------------*
9533 :xmp tab=0.
9534
9535 <TC-   Test of  structured types - 8>
9536
9537 <STATIC>
9538
9539 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
9540 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
9541
9542 group RAW_group{
9543
9544 type octetstring end_of_optional_parameters_indicator
9545 with { variant "FIELDLENGTH(1)"};
9546
9547 type integer pointer
9548 with { variant "" };
9549
9550 type integer INT1
9551 with { variant "" };
9552
9553 type record Rec1
9554 {  bitstring   bit4 ,
9555    bitstring   bit1 ,
9556    bitstring   bit3 ,
9557    INT1     length1 ,
9558    octetstring octN optional    }
9559 with { variant (bit4) "FIELDLENGTH(4)" ;
9560        variant (bit1) "FIELDLENGTH(1)" ;
9561        variant (bit3) "FIELDLENGTH(3)" ;
9562        variant (length1) "LENGTHTO(octN)" ;
9563      };
9564
9565
9566 type record Rec2
9567 {  bitstring   bit8 ,
9568    INT1     length1 ,
9569    octetstring octN optional    }
9570 with { variant (bit8) "FIELDLENGTH(8)" ;
9571        variant (length1) "LENGTHTO(octN)" ;
9572      };
9573
9574
9575 type record Rec3
9576 {  bitstring   bit4 ,
9577    bitstring   bit1 ,
9578    bitstring   bit3 ,
9579    integer     int ,
9580    octetstring oct2 optional    }
9581 with { variant (bit4) "FIELDLENGTH(4)" ;
9582        variant (bit1) "FIELDLENGTH(1)" ;
9583        variant (bit3) "FIELDLENGTH(3)" ;
9584        variant (oct2) "FIELDLENGTH(2)" ;
9585      };
9586
9587
9588 type record Rec4
9589 {  integer     int ,
9590    octetstring oct5 optional    }
9591 with { variant (oct5) "FIELDLENGTH(5)"};
9592
9593
9594 type union opt_par_union
9595 { octetstring  octstr ,
9596   Rec2         rec2 ,
9597   Rec3         rec3 ,
9598   Rec4         rec4       }
9599  with { variant (octstr) "FIELDLENGTH(2)" };
9600
9601
9602 type record opt_par
9603 {  integer   id ,
9604    integer   length1 ,
9605    opt_par_union  par  }
9606 with { variant (length1) "LENGTHTO(par)" ;
9607        variant (par) "CROSSTAG(
9608                                 octstr ,  id=1 ;
9609                                 rec2  ,   id=2 ;
9610                                 rec3  ,   id=3 ;
9611                                 rec4  ,   id=4 ;  )"
9612      } ;
9613
9614
9615 type set of opt_par optional_part
9616     with { variant "" };
9617
9618
9619 type record RAW_PDU
9620 {  pointer var_part_ptr,
9621    pointer opt_part_ptr,
9622    INT1 length1,
9623    Rec1 rec1 optional,
9624    optional_part opt_part optional,
9625    end_of_optional_parameters_indicator EndOP optional
9626 } with { variant (var_part_ptr) "POINTERTO (length1)";
9627          variant (opt_part_ptr) "POINTERTO (opt_part)";
9628          variant (length1) "LENGTHTO (rec1)" };
9629
9630 }with{encode "RAW"}
9631
9632
9633 const RAW_PDU
9634         i := { var_part_ptr :=      2 ,
9635                opt_part_ptr :=      0 ,
9636                length1 :=        0 ,
9637                rec1 :=  omit ,
9638                opt_part :=   omit ,
9639                EndOP := '00'O     }  // EndOP = omit
9640
9641
9642
9643 const octetstring       o := '02000000'O
9644
9645 <TTCN_TC:EXEC>
9646
9647 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
9648 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
9649
9650 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
9651   else {setverdict(fail);}
9652
9653 <RESULT>
9654
9655 Overall verdict: pass
9656
9657 <END_TC>
9658
9659 :exmp.
9660
9661 .*---------------------------------------------------------------------*
9662 :h3.  Test of  structured types - 9
9663 .*---------------------------------------------------------------------*
9664 :xmp tab=0.
9665
9666 <TC-   Test of  structured types - 9>
9667
9668 <STATIC>
9669
9670 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
9671 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
9672
9673 group RAW_group{
9674
9675 type octetstring end_of_optional_parameters_indicator
9676 with { variant "FIELDLENGTH(1)"};
9677
9678 type integer pointer
9679 with { variant "" };
9680
9681 type integer INT1
9682 with { variant "" };
9683
9684 type record Rec1
9685 {  bitstring   bit4 ,
9686    bitstring   bit1 ,
9687    bitstring   bit3 ,
9688    INT1     length1 ,
9689    octetstring octN optional    }
9690 with { variant (bit4) "FIELDLENGTH(4)" ;
9691        variant (bit1) "FIELDLENGTH(1)" ;
9692        variant (bit3) "FIELDLENGTH(3)" ;
9693        variant (length1) "LENGTHTO(octN)" ;
9694      };
9695
9696
9697 type record Rec2
9698 {  bitstring   bit8 ,
9699    INT1     length1 ,
9700    octetstring octN optional    }
9701 with { variant (bit8) "FIELDLENGTH(8)" ;
9702        variant (length1) "LENGTHTO(octN)" ;
9703      };
9704
9705
9706 type record Rec3
9707 {  bitstring   bit4 ,
9708    bitstring   bit1 ,
9709    bitstring   bit3 ,
9710    integer     int ,
9711    octetstring oct2 optional    }
9712 with { variant (bit4) "FIELDLENGTH(4)" ;
9713        variant (bit1) "FIELDLENGTH(1)" ;
9714        variant (bit3) "FIELDLENGTH(3)" ;
9715        variant (oct2) "FIELDLENGTH(2)" ;
9716      };
9717
9718
9719
9720 type record Rec4
9721 {  integer     int ,
9722    octetstring oct5 optional    }
9723 with { variant (oct5) "FIELDLENGTH(5)"};
9724
9725
9726 type union opt_par_union
9727 { octetstring  octstr ,
9728   Rec2         rec2 ,
9729   Rec3         rec3 ,
9730   Rec4         rec4       }
9731  with { variant (octstr) "FIELDLENGTH(2)" };
9732
9733
9734 type record opt_par
9735 {  integer   id ,
9736    integer   length1 ,
9737    opt_par_union  par  }
9738 with { variant (length1) "LENGTHTO(par)" ;
9739        variant (par) "CROSSTAG(
9740                                 octstr ,  id=1 ;
9741                                 rec2  ,   id=2 ;
9742                                 rec3  ,   id=3 ;
9743                                 rec4  ,   id=4 ;  )"
9744      } ;
9745
9746
9747 type set of opt_par optional_part
9748     with { variant "" };
9749
9750
9751 type record RAW_PDU
9752 {  pointer var_part_ptr,
9753    pointer opt_part_ptr,
9754    INT1 length1,
9755    Rec1 rec1 optional,
9756    optional_part opt_part optional,
9757    end_of_optional_parameters_indicator EndOP optional
9758 } with { variant (var_part_ptr) "POINTERTO (length1)";
9759          variant (opt_part_ptr) "POINTERTO (opt_part)";
9760          variant (length1) "LENGTHTO (rec1)" };
9761
9762 }with{encode "RAW"}
9763
9764
9765 const RAW_PDU
9766         i := { var_part_ptr :=      2 ,
9767                opt_part_ptr :=      0 ,
9768                length1 :=        0 ,
9769                rec1 :=  omit ,
9770                opt_part :=   omit ,
9771                EndOP := omit     }
9772
9773
9774
9775 const octetstring       o := '020000'O
9776
9777 <TTCN_TC:EXEC>
9778
9779 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
9780 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
9781
9782 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
9783   else {setverdict(fail);}
9784
9785 <RESULT>
9786
9787 Overall verdict: pass
9788
9789 <END_TC>
9790
9791 :exmp.
9792
9793 .*---------------------------------------------------------------------*
9794 :h3. Test of  structured types - 10
9795 .*---------------------------------------------------------------------*
9796 :xmp tab=0.
9797
9798 <TC-  Test of  structured types - 10>
9799
9800 <STATIC>
9801
9802 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
9803 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
9804
9805 group RAW_group{
9806
9807 type integer Pointer
9808 with { variant "" } ;
9809
9810 type octetstring EndOfOptionalPart
9811 with { variant "FIELDLENGTH(1)" } ;
9812
9813 type integer INT1
9814 with { variant "" } ;
9815
9816 type bitstring BIT1
9817 with { variant "FIELDLENGTH(1)" } ;
9818
9819 type bitstring BIT7
9820 with { variant "FIELDLENGTH(7)" } ;
9821
9822 type octetstring OCT3
9823 with { variant "FIELDLENGTH(3)" } ;
9824
9825 type hexstring HEX2
9826 with { variant "FIELDLENGTH(2)" } ;
9827
9828 type enumerated  MessageType
9829   { e1(1),      e2(2),      e3(3),    e4(4),    e5(5) }
9830    with { variant "FIELDLENGTH(8)" }
9831
9832
9833 type enumerated  ParamName
9834   { name1(1),      name2(2),      name3(3),    name4(4) }
9835    with { variant "FIELDLENGTH(8)" }
9836
9837 type record Param1
9838 { ParamName           paramName  ,
9839   integer             paramLength ,
9840   OCT3                octstr ,
9841   BIT7                bit7 ,
9842   BIT1                bit1 ,
9843   HEX2                hexstr ,
9844   INT1                int }
9845 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int  )" }
9846
9847 type record Param2
9848 { ParamName           paramName ,
9849   integer             paramLength ,
9850   OCT3                octstr ,
9851   BIT7                bit7 ,
9852   BIT1                bit1 ,
9853   HEX2                hexstr ,
9854   INT1                int }
9855 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
9856
9857 type record Param3
9858 { ParamName           paramName  ,
9859   integer             paramLength ,
9860   OCT3                octstr ,
9861   BIT7                bit7 ,
9862   BIT1                bit1 ,
9863   HEX2                hexstr ,
9864   INT1                int }
9865 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
9866
9867 type record Param4
9868 { ParamName           paramName  ,
9869   integer             paramLength ,
9870   OCT3                octstr ,
9871   BIT7                bit7 ,
9872   BIT1                bit1 ,
9873   HEX2                hexstr ,
9874   INT1                int }
9875 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
9876
9877 type set Optional_part
9878 { Param1    param1 optional ,
9879   Param2    param2 optional ,
9880   Param3    param3 optional ,
9881   Param4    param4 optional   }
9882    with { variant "TAG (
9883                          param1 ,           paramName= name1;
9884                          param2 ,           paramName= name2;
9885                          param3 ,           paramName= name3;
9886                          param4 ,           paramName= name4  )"   }
9887
9888
9889
9890 type record Elem1
9891 { MessageType        messageType ,
9892   OCT3               octstr ,
9893   BIT7               bit7 ,
9894   BIT1               bit1 ,
9895   HEX2               hexstr ,
9896   INT1               int ,
9897   Pointer            pointer1 ,
9898   Pointer            pointer2 ,
9899   integer            length1 ,
9900   octetstring        octN ,
9901   Optional_part      opt_part   ,
9902   EndOfOptionalPart  eop   optional    }
9903    with { variant (pointer1) "POINTERTO(length1)";
9904           variant (pointer2) "POINTERTO(opt_part)" ;
9905           variant (length1) "LENGTHTO(octN)"
9906
9907             //Note, that optional part itself is mandatory but it may be empty!
9908         }
9909
9910
9911 type record Elem2
9912 { MessageType        messageType ,
9913   OCT3               octstr ,
9914   BIT7               bit7 ,
9915   BIT1               bit1 ,
9916   HEX2               hexstr ,
9917   INT1               int ,
9918   Pointer            pointer1 ,
9919   Pointer            pointer2 ,
9920   integer            length1 ,
9921   octetstring        octN ,
9922   Optional_part      opt_part   ,
9923   EndOfOptionalPart  eop   optional    }
9924    with { variant (pointer1) "POINTERTO(length1)";
9925           variant (pointer2) "POINTERTO(opt_part)" ;
9926           variant (length1) "LENGTHTO(octN)"
9927
9928             //Note, that optional part itself is mandatory but it may be empty!
9929         }
9930
9931
9932 type record Elem3
9933 { MessageType        messageType ,
9934   OCT3               octstr ,
9935   BIT7               bit7 ,
9936   BIT1               bit1 ,
9937   HEX2               hexstr ,
9938   INT1               int ,
9939   Pointer            pointer1 ,
9940   Pointer            pointer2 ,
9941   integer            length1 ,
9942   octetstring        octN ,
9943   Optional_part      opt_part   ,
9944   EndOfOptionalPart  eop   optional    }
9945    with { variant (pointer1) "POINTERTO(length1)";
9946           variant (pointer2) "POINTERTO(opt_part)" ;
9947           variant (length1) "LENGTHTO(octN)"
9948
9949             //Note, that optional part itself is mandatory but it may be empty!
9950         }
9951
9952
9953 type record Elem4
9954 { MessageType        messageType ,
9955   OCT3               octstr ,
9956   BIT7               bit7 ,
9957   BIT1               bit1 ,
9958   HEX2               hexstr ,
9959   INT1               int ,
9960   Pointer            pointer1 ,
9961   Pointer            pointer2 ,
9962   integer            length1 ,
9963   octetstring        octN ,
9964   Optional_part      opt_part   ,
9965   EndOfOptionalPart  eop   optional    }
9966    with { variant (pointer1) "POINTERTO(length1)";
9967           variant (pointer2) "POINTERTO(opt_part)" ;
9968           variant (length1) "LENGTHTO(octN)"
9969
9970             //Note, that optional part itself is mandatory but it may be empty!
9971         }
9972
9973
9974 type record Elem5
9975 { MessageType        messageType ,
9976   OCT3               octstr ,
9977   BIT7               bit7 ,
9978   BIT1               bit1 ,
9979   HEX2               hexstr ,
9980   INT1               int ,
9981   Pointer            pointer1 ,
9982   Pointer            pointer2 ,
9983   integer            length1 ,
9984   octetstring        octN ,
9985   Optional_part      opt_part   ,
9986   EndOfOptionalPart  eop   optional    }
9987    with { variant (pointer1) "POINTERTO(length1)";
9988           variant (pointer2) "POINTERTO(opt_part)" ;
9989           variant (length1) "LENGTHTO(octN)"
9990
9991             //Note, that optional part itself is mandatory but it may be empty!
9992         }
9993
9994
9995 type union RAW_PDU
9996 { Elem1      elem1 ,
9997   Elem2      elem2 ,
9998   Elem3      elem3 ,
9999   Elem4      elem4 ,
10000   Elem5      elem5  }
10001 with { variant "TAG (
10002                       elem1 ,       messageType = e1 ;
10003                       elem2 ,       messageType = e2 ;
10004                       elem3 ,       messageType = e3 ;
10005                       elem4 ,       messageType = e4 ;
10006                       elem5 ,       messageType = e5   ) "
10007      } ;
10008
10009 }with{encode "RAW"}
10010
10011 const RAW_PDU
10012     i := { elem1 :=
10013              {  messageType :=       e1 ,
10014                 octstr :=            '123456'O ,
10015                 bit7 :=              '0000000'B ,
10016                 bit1 :=              '1'B ,
10017                 hexstr :=            'FF'H ,
10018                 int :=               1 ,
10019                 pointer1 :=          2 ,
10020                 pointer2 :=          7 ,
10021                 length1 :=           5 ,
10022                 octN :=              '1234567890'O ,
10023                 opt_part :=
10024                      { param1 :=
10025                            { paramName :=         name1 ,
10026                              paramLength :=       6 ,
10027                              octstr :=            '123456'O ,
10028                              bit7 :=              '0000000'B ,
10029                              bit1 :=              '1'B ,
10030                              hexstr :=            'FF'H ,
10031                              int :=               1 }  ,
10032                        param4 :=
10033                            { paramName :=         name4 ,
10034                              paramLength :=       6 ,
10035                              octstr :=            '123456'O ,
10036                              bit7 :=              '0000000'B ,
10037                              bit1 :=              '1'B ,
10038                              hexstr :=            'FF'H ,
10039                              int :=               1 }  ,
10040                        param3 :=
10041                            { paramName :=         name3 ,
10042                              paramLength :=       6 ,
10043                              octstr :=            '123456'O ,
10044                              bit7 :=              '0000000'B ,
10045                              bit1 :=              '1'B ,
10046                              hexstr :=            'FF'H ,
10047                              int :=               1 }  ,
10048                        param2 :=
10049                            { paramName :=         name2 ,
10050                              paramLength :=       6 ,
10051                              octstr :=            '123456'O ,
10052                              bit7 :=              '0000000'B ,
10053                              bit1 :=              '1'B ,
10054                              hexstr :=            'FF'H ,
10055                              int :=               1 }     },
10056                 eop :=               '00'O            } }
10057
10058
10059
10060 const octetstring       o := '0112345680FF010207051234567890010612345680FF01020612345680FF01030612345680FF01040612345680FF0100'O
10061
10062
10063
10064 <TTCN_TC:EXEC>
10065
10066 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
10067 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
10068
10069 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
10070   else {setverdict(fail);}
10071
10072 <RESULT>
10073
10074 Overall verdict: pass
10075
10076 <END_TC>
10077
10078 :exmp.
10079
10080 .*---------------------------------------------------------------------*
10081 :h3. Test of  structured types - 11
10082 .*---------------------------------------------------------------------*
10083 :xmp tab=0.
10084
10085 <TC-  Test of  structured types - 11>
10086
10087 <STATIC>
10088
10089 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
10090 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
10091
10092 group RAW_group{
10093
10094 type integer Pointer
10095 with { variant "" } ;
10096
10097 type octetstring EndOfOptionalPart
10098 with { variant "FIELDLENGTH(1)" } ;
10099
10100 type integer INT1
10101 with { variant "" } ;
10102
10103 type bitstring BIT1
10104 with { variant "FIELDLENGTH(1)" } ;
10105
10106 type bitstring BIT7
10107 with { variant "FIELDLENGTH(7)" } ;
10108
10109 type octetstring OCT3
10110 with { variant "FIELDLENGTH(3)" } ;
10111
10112 type hexstring HEX2
10113 with { variant "FIELDLENGTH(2)" } ;
10114
10115 type enumerated  MessageType
10116   { e1(1),      e2(2),      e3(3),    e4(4),    e5(5) }
10117    with { variant "FIELDLENGTH(8)" }
10118
10119
10120 type enumerated  ParamName
10121   { name1(1),      name2(2),      name3(3),    name4(4) }
10122    with { variant "FIELDLENGTH(8)" }
10123
10124 type record Param1
10125 { ParamName           paramName  ,
10126   integer             paramLength ,
10127   OCT3                octstr ,
10128   BIT7                bit7 ,
10129   BIT1                bit1 ,
10130   HEX2                hexstr ,
10131   INT1                int }
10132 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10133
10134 type record Param2
10135 { ParamName           paramName ,
10136   integer             paramLength ,
10137   OCT3                octstr ,
10138   BIT7                bit7 ,
10139   BIT1                bit1 ,
10140   HEX2                hexstr ,
10141   INT1                int }
10142 with {variant  (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10143
10144 type record Param3
10145 { ParamName           paramName  ,
10146   integer             paramLength ,
10147   OCT3                octstr ,
10148   BIT7                bit7 ,
10149   BIT1                bit1 ,
10150   HEX2                hexstr ,
10151   INT1                int }
10152 with {variant  (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10153
10154 type record Param4
10155 { ParamName           paramName  ,
10156   integer             paramLength ,
10157   OCT3                octstr ,
10158   BIT7                bit7 ,
10159   BIT1                bit1 ,
10160   HEX2                hexstr ,
10161   INT1                int }
10162 with {variant  (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10163
10164 type set Optional_part
10165 { Param1    param1 optional ,
10166   Param2    param2 optional ,
10167   Param3    param3 optional ,
10168   Param4    param4 optional   }
10169    with { variant "TAG (
10170                          param1 ,           paramName= name1;
10171                          param2 ,           paramName= name2;
10172                          param3 ,           paramName= name3;
10173                          param4 ,           paramName= name4  )"   }
10174
10175
10176 type record Elem1
10177 { MessageType        messageType ,
10178   OCT3               octstr ,
10179   BIT7               bit7 ,
10180   BIT1               bit1 ,
10181   HEX2               hexstr ,
10182   INT1               int ,
10183   Pointer            pointer1 ,
10184   Pointer            pointer2 ,
10185   integer            length1 ,
10186   octetstring        octN ,
10187   Optional_part      opt_part   ,
10188   EndOfOptionalPart  eop   optional    }
10189    with { variant (pointer1) "POINTERTO(length1)";
10190           variant (pointer2) "POINTERTO(opt_part)" ;
10191           variant (length1) "LENGTHTO(octN)"
10192
10193             //Note, that optional part itself is mandatory but it may be empty!
10194         }
10195
10196
10197 type record Elem2
10198 { MessageType        messageType ,
10199   OCT3               octstr ,
10200   BIT7               bit7 ,
10201   BIT1               bit1 ,
10202   HEX2               hexstr ,
10203   INT1               int ,
10204   Pointer            pointer1 ,
10205   Pointer            pointer2 ,
10206   integer            length1 ,
10207   octetstring        octN ,
10208   Optional_part      opt_part   ,
10209   EndOfOptionalPart  eop   optional    }
10210    with { variant (pointer1) "POINTERTO(length1)";
10211           variant (pointer2) "POINTERTO(opt_part)" ;
10212           variant (length1) "LENGTHTO(octN)"
10213
10214             //Note, that optional part itself is mandatory but it may be empty!
10215         }
10216
10217
10218 type record Elem3
10219 { MessageType        messageType ,
10220   OCT3               octstr ,
10221   BIT7               bit7 ,
10222   BIT1               bit1 ,
10223   HEX2               hexstr ,
10224   INT1               int ,
10225   Pointer            pointer1 ,
10226   Pointer            pointer2 ,
10227   integer            length1 ,
10228   octetstring        octN ,
10229   Optional_part      opt_part   ,
10230   EndOfOptionalPart  eop   optional    }
10231    with { variant (pointer1) "POINTERTO(length1)";
10232           variant (pointer2) "POINTERTO(opt_part)" ;
10233           variant (length1) "LENGTHTO(octN)"
10234
10235             //Note, that optional part itself is mandatory but it may be empty!
10236         }
10237
10238
10239 type record Elem4
10240 { MessageType        messageType ,
10241   OCT3               octstr ,
10242   BIT7               bit7 ,
10243   BIT1               bit1 ,
10244   HEX2               hexstr ,
10245   INT1               int ,
10246   Pointer            pointer1 ,
10247   Pointer            pointer2 ,
10248   integer            length1 ,
10249   octetstring        octN ,
10250   Optional_part      opt_part   ,
10251   EndOfOptionalPart  eop   optional    }
10252    with { variant (pointer1) "POINTERTO(length1)";
10253           variant (pointer2) "POINTERTO(opt_part)" ;
10254           variant (length1) "LENGTHTO(octN)"
10255
10256             //Note, that optional part itself is mandatory but it may be empty!
10257         }
10258
10259
10260 type record Elem5
10261 { MessageType        messageType ,
10262   OCT3               octstr ,
10263   BIT7               bit7 ,
10264   BIT1               bit1 ,
10265   HEX2               hexstr ,
10266   INT1               int ,
10267   Pointer            pointer1 ,
10268   Pointer            pointer2 ,
10269   integer            length1 ,
10270   octetstring        octN ,
10271   Optional_part      opt_part   ,
10272   EndOfOptionalPart  eop   optional    }
10273    with { variant (pointer1) "POINTERTO(length1)";
10274           variant (pointer2) "POINTERTO(opt_part)" ;
10275           variant (length1) "LENGTHTO(octN)"
10276
10277             //Note, that optional part itself is mandatory but it may be empty!
10278         }
10279
10280
10281 type union RAW_PDU
10282 { Elem1      elem1 ,
10283   Elem2      elem2 ,
10284   Elem3      elem3 ,
10285   Elem4      elem4 ,
10286   Elem5      elem5  }
10287 with { variant "TAG (
10288                       elem1 ,       messageType = e1 ;
10289                       elem2 ,       messageType = e2 ;
10290                       elem3 ,       messageType = e3 ;
10291                       elem4 ,       messageType = e4 ;
10292                       elem5 ,       messageType = e5   ) "
10293      } ;
10294
10295 }with{encode "RAW"}
10296
10297 const RAW_PDU
10298     i := { elem1 :=
10299              {  messageType :=       e1 ,
10300                 octstr :=            '123456'O ,
10301                 bit7 :=              '0000000'B ,
10302                 bit1 :=              '1'B ,
10303                 hexstr :=            'FF'H ,
10304                 int :=               1 ,
10305                 pointer1 :=          2 ,
10306                 pointer2 :=          7 ,
10307                 length1 :=           5 ,
10308                 octN :=              '1234567890'O ,
10309                 opt_part :=
10310                      { param1 := omit ,
10311                        param4 := omit ,
10312                        param3 := omit ,
10313                        param2 := omit       },
10314                 eop :=   omit         } }
10315
10316
10317
10318 const octetstring       o := '0112345680FF010207051234567890'O
10319
10320
10321
10322 <TTCN_TC:EXEC>
10323
10324 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
10325 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
10326
10327 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
10328   else {setverdict(fail);}
10329
10330 <RESULT>
10331
10332 Overall verdict: pass
10333
10334 <END_TC>
10335
10336 :exmp.
10337
10338 .*---------------------------------------------------------------------*
10339 :h3. Test of  structured types - 12
10340 .*---------------------------------------------------------------------*
10341 :xmp tab=0.
10342
10343 <TC-  Test of  structured types - 12 >
10344
10345 <STATIC>
10346
10347 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
10348 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
10349
10350 group RAW_group{
10351
10352 type integer Pointer
10353 with { variant "" } ;
10354
10355 type octetstring EndOfOptionalPart
10356 with { variant "FIELDLENGTH(1)" } ;
10357
10358 type integer INT1
10359 with { variant "" } ;
10360
10361 type bitstring BIT1
10362 with { variant "FIELDLENGTH(1)" } ;
10363
10364 type bitstring BIT7
10365 with { variant "FIELDLENGTH(7)" } ;
10366
10367 type octetstring OCT3
10368 with { variant "FIELDLENGTH(3)" } ;
10369
10370 type hexstring HEX2
10371 with { variant "FIELDLENGTH(2)" } ;
10372
10373 type enumerated  MessageType
10374   { e1(1),      e2(2),      e3(3),    e4(4),    e5(5) }
10375    with { variant "FIELDLENGTH(8)" }
10376
10377
10378 type enumerated  ParamName
10379   { name1(1),      name2(2),      name3(3),    name4(4) }
10380    with { variant "FIELDLENGTH(8)" }
10381
10382 type record Param1
10383 { ParamName           paramName  ,
10384   integer             paramLength ,
10385   OCT3                octstr ,
10386   BIT7                bit7 ,
10387   BIT1                bit1 ,
10388   HEX2                hexstr ,
10389   INT1                int }
10390 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10391
10392 type record Param2
10393 { ParamName           paramName ,
10394   integer             paramLength ,
10395   OCT3                octstr ,
10396   BIT7                bit7 ,
10397   BIT1                bit1 ,
10398   HEX2                hexstr ,
10399   INT1                int }
10400 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10401
10402 type record Param3
10403 { ParamName           paramName  ,
10404   integer             paramLength ,
10405   OCT3                octstr ,
10406   BIT7                bit7 ,
10407   BIT1                bit1 ,
10408   HEX2                hexstr ,
10409   INT1                int }
10410 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10411
10412 type record Param4
10413 { ParamName           paramName  ,
10414   integer             paramLength ,
10415   OCT3                octstr ,
10416   BIT7                bit7 ,
10417   BIT1                bit1 ,
10418   HEX2                hexstr ,
10419   INT1                int }
10420 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10421
10422 type set Optional_part
10423 { Param1    param1 optional ,
10424   Param2    param2 optional ,
10425   Param3    param3 optional ,
10426   Param4    param4 optional   }
10427    with { variant "TAG (
10428                          param1 ,           paramName= name1;
10429                          param2 ,           paramName= name2;
10430                          param3 ,           paramName= name3;
10431                          param4 ,           paramName= name4  )"   }
10432
10433
10434 type record Elem1
10435 { MessageType        messageType ,
10436   OCT3               octstr ,
10437   BIT7               bit7 ,
10438   BIT1               bit1 ,
10439   HEX2               hexstr ,
10440   INT1               int ,
10441   Pointer            pointer1 ,
10442   Pointer            pointer2 ,
10443   integer            length1 ,
10444   octetstring        octN ,
10445   Optional_part      opt_part   ,
10446   EndOfOptionalPart  eop   optional    }
10447    with { variant (pointer1) "POINTERTO(length1)";
10448           variant (pointer2) "POINTERTO(opt_part)" ;
10449           variant (length1) "LENGTHTO(octN)"
10450
10451             //Note, that optional part itself is mandatory but it may be empty!
10452         }
10453
10454
10455 type record Elem2
10456 { MessageType        messageType ,
10457   OCT3               octstr ,
10458   BIT7               bit7 ,
10459   BIT1               bit1 ,
10460   HEX2               hexstr ,
10461   INT1               int ,
10462   Pointer            pointer1 ,
10463   Pointer            pointer2 ,
10464   integer            length1 ,
10465   octetstring        octN ,
10466   Optional_part      opt_part   ,
10467   EndOfOptionalPart  eop   optional    }
10468    with { variant (pointer1) "POINTERTO(length1)";
10469           variant (pointer2) "POINTERTO(opt_part)" ;
10470           variant (length1) "LENGTHTO(octN)"
10471
10472             //Note, that optional part itself is mandatory but it may be empty!
10473         }
10474
10475
10476 type record Elem3
10477 { MessageType        messageType ,
10478   OCT3               octstr ,
10479   BIT7               bit7 ,
10480   BIT1               bit1 ,
10481   HEX2               hexstr ,
10482   INT1               int ,
10483   Pointer            pointer1 ,
10484   Pointer            pointer2 ,
10485   integer            length1 ,
10486   octetstring        octN ,
10487   Optional_part      opt_part   ,
10488   EndOfOptionalPart  eop   optional    }
10489    with { variant (pointer1) "POINTERTO(length1)";
10490           variant (pointer2) "POINTERTO(opt_part)" ;
10491           variant (length1) "LENGTHTO(octN)"
10492
10493             //Note, that optional part itself is mandatory but it may be empty!
10494         }
10495
10496
10497 type record Elem4
10498 { MessageType        messageType ,
10499   OCT3               octstr ,
10500   BIT7               bit7 ,
10501   BIT1               bit1 ,
10502   HEX2               hexstr ,
10503   INT1               int ,
10504   Pointer            pointer1 ,
10505   Pointer            pointer2 ,
10506   integer            length1 ,
10507   octetstring        octN ,
10508   Optional_part      opt_part   ,
10509   EndOfOptionalPart  eop   optional    }
10510    with { variant (pointer1) "POINTERTO(length1)";
10511           variant (pointer2) "POINTERTO(opt_part)" ;
10512           variant (length1) "LENGTHTO(octN)"
10513
10514             //Note, that optional part itself is mandatory but it may be empty!
10515         }
10516
10517
10518 type record Elem5
10519 { MessageType        messageType ,
10520   OCT3               octstr ,
10521   BIT7               bit7 ,
10522   BIT1               bit1 ,
10523   HEX2               hexstr ,
10524   INT1               int ,
10525   Pointer            pointer1 ,
10526   Pointer            pointer2 ,
10527   integer            length1 ,
10528   octetstring        octN ,
10529   Optional_part      opt_part   ,
10530   EndOfOptionalPart  eop   optional    }
10531    with { variant (pointer1) "POINTERTO(length1)";
10532           variant (pointer2) "POINTERTO(opt_part)" ;
10533           variant (length1) "LENGTHTO(octN)"
10534
10535             //Note, that optional part itself is mandatory but it may be empty!
10536         }
10537
10538
10539 type union RAW_PDU
10540 { Elem1      elem1 ,
10541   Elem2      elem2 ,
10542   Elem3      elem3 ,
10543   Elem4      elem4 ,
10544   Elem5      elem5  }
10545 with { variant "TAG (
10546                       elem1 ,       messageType = e1 ;
10547                       elem2 ,       messageType = e2 ;
10548                       elem3 ,       messageType = e3 ;
10549                       elem4 ,       messageType = e4 ;
10550                       elem5 ,       messageType = e5   ) "
10551      } ;
10552
10553 }with{encode "RAW"}
10554
10555 const RAW_PDU
10556     i := { elem1 :=
10557              {  messageType :=       e1 ,
10558                 octstr :=            '123456'O ,
10559                 bit7 :=              '0000000'B ,
10560                 bit1 :=              '1'B ,
10561                 hexstr :=            'FF'H ,
10562                 int :=               1 ,
10563                 pointer1 :=          2 ,
10564                 pointer2 :=          7 ,
10565                 length1 :=           5 ,
10566                 octN :=              '1234567890'O ,
10567                 opt_part :=
10568                      { param1 :=
10569                            { paramName :=         name1 ,
10570                              paramLength :=       6 ,
10571                              octstr :=            '123456'O ,
10572                              bit7 :=              '0000000'B ,
10573                              bit1 :=              '1'B ,
10574                              hexstr :=            'FF'H ,
10575                              int :=               1 }  ,
10576                        param4 :=
10577                            { paramName :=         name4 ,
10578                              paramLength :=       6 ,
10579                              octstr :=            '123456'O ,
10580                              bit7 :=              '0000000'B ,
10581                              bit1 :=              '1'B ,
10582                              hexstr :=            'FF'H ,
10583                              int :=               1 }  ,
10584                        param3 :=
10585                            { paramName :=         name3 ,
10586                              paramLength :=       6 ,
10587                              octstr :=            '123456'O ,
10588                              bit7 :=              '0000000'B ,
10589                              bit1 :=              '1'B ,
10590                              hexstr :=            'FF'H ,
10591                              int :=               1 }  ,
10592                        param2 := omit       },
10593                 eop :=               '00'O            } }
10594
10595
10596
10597 const octetstring       o := '0112345680FF010207051234567890010612345680FF01030612345680FF01040612345680FF0100'O
10598
10599
10600
10601 <TTCN_TC:EXEC>
10602
10603 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
10604 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
10605
10606 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
10607   else {setverdict(fail);}
10608
10609 <RESULT>
10610
10611 Overall verdict: pass
10612
10613 <END_TC>
10614
10615 :exmp.
10616
10617 .*---------------------------------------------------------------------*
10618 :h3. Test of  structured types - 13
10619 .*---------------------------------------------------------------------*
10620 :xmp tab=0.
10621
10622 <TC-  Test of  structured types - 13 >
10623
10624 <STATIC>
10625
10626 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
10627 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
10628
10629 group RAW_group{
10630
10631 type integer Pointer
10632 with { variant "" } ;
10633
10634 type octetstring EndOfOptionalPart
10635 with { variant "FIELDLENGTH(1)" } ;
10636
10637 type integer INT1
10638 with { variant "" } ;
10639
10640 type bitstring BIT1
10641 with { variant "FIELDLENGTH(1)" } ;
10642
10643 type bitstring BIT7
10644 with { variant "FIELDLENGTH(7)" } ;
10645
10646 type octetstring OCT3
10647 with { variant "FIELDLENGTH(3)" } ;
10648
10649 type hexstring HEX2
10650 with { variant "FIELDLENGTH(2)" } ;
10651
10652 type enumerated  MessageType
10653   { e1(1),      e2(2),      e3(3),    e4(4),    e5(5) }
10654    with { variant "FIELDLENGTH(8)" }
10655
10656
10657 type enumerated  ParamName
10658   { name1(1),      name2(2),      name3(3),    name4(4) }
10659    with { variant "FIELDLENGTH(8)" }
10660
10661 type record Param1
10662 { ParamName           paramName  ,
10663   integer             paramLength ,
10664   OCT3                octstr ,
10665   BIT7                bit7 ,
10666   BIT1                bit1 ,
10667   HEX2                hexstr ,
10668   INT1                int }
10669 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10670
10671 type record Param2
10672 { ParamName           paramName ,
10673   integer             paramLength ,
10674   OCT3                octstr ,
10675   BIT7                bit7 ,
10676   BIT1                bit1 ,
10677   HEX2                hexstr ,
10678   INT1                int }
10679 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10680
10681 type record Param3
10682 { ParamName           paramName  ,
10683   integer             paramLength ,
10684   OCT3                octstr ,
10685   BIT7                bit7 ,
10686   BIT1                bit1 ,
10687   HEX2                hexstr ,
10688   INT1                int }
10689 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10690
10691 type record Param4
10692 { ParamName           paramName  ,
10693   integer             paramLength ,
10694   OCT3                octstr ,
10695   BIT7                bit7 ,
10696   BIT1                bit1 ,
10697   HEX2                hexstr ,
10698   INT1                int }
10699 with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
10700
10701 type set Optional_part
10702 { Param1    param1 optional ,
10703   Param2    param2 optional ,
10704   Param3    param3 optional ,
10705   Param4    param4 optional   }
10706    with { variant "TAG (
10707                          param1 ,           paramName= name1;
10708                          param2 ,           paramName= name2;
10709                          param3 ,           paramName= name3;
10710                          param4 ,           paramName= name4  )"   }
10711
10712
10713 type record Elem1
10714 { MessageType        messageType ,
10715   OCT3               octstr ,
10716   BIT7               bit7 ,
10717   BIT1               bit1 ,
10718   HEX2               hexstr ,
10719   INT1               int ,
10720   Pointer            pointer1 ,
10721   Pointer            pointer2 ,
10722   integer            length1 ,
10723   octetstring        octN ,
10724   Optional_part      opt_part   ,
10725   EndOfOptionalPart  eop   optional    }
10726    with { variant (pointer1) "POINTERTO(length1)";
10727           variant (pointer2) "POINTERTO(opt_part)" ;
10728           variant (length1) "LENGTHTO(octN)"
10729
10730             //Note, that optional part itself is mandatory but it may be empty!
10731         }
10732
10733
10734 type record Elem2
10735 { MessageType        messageType ,
10736   OCT3               octstr ,
10737   BIT7               bit7 ,
10738   BIT1               bit1 ,
10739   HEX2               hexstr ,
10740   INT1               int ,
10741   Pointer            pointer1 ,
10742   Pointer            pointer2 ,
10743   integer            length1 ,
10744   octetstring        octN ,
10745   Optional_part      opt_part   ,
10746   EndOfOptionalPart  eop   optional    }
10747    with { variant (pointer1) "POINTERTO(length1)";
10748           variant (pointer2) "POINTERTO(opt_part)" ;
10749           variant (length1) "LENGTHTO(octN)"
10750
10751             //Note, that optional part itself is mandatory but it may be empty!
10752         }
10753
10754
10755 type record Elem3
10756 { MessageType        messageType ,
10757   OCT3               octstr ,
10758   BIT7               bit7 ,
10759   BIT1               bit1 ,
10760   HEX2               hexstr ,
10761   INT1               int ,
10762   Pointer            pointer1 ,
10763   Pointer            pointer2 ,
10764   integer            length1 ,
10765   octetstring        octN ,
10766   Optional_part      opt_part   ,
10767   EndOfOptionalPart  eop   optional    }
10768    with { variant (pointer1) "POINTERTO(length1)";
10769           variant (pointer2) "POINTERTO(opt_part)" ;
10770           variant (length1) "LENGTHTO(octN)"
10771
10772             //Note, that optional part itself is mandatory but it may be empty!
10773         }
10774
10775
10776 type record Elem4
10777 { MessageType        messageType ,
10778   OCT3               octstr ,
10779   BIT7               bit7 ,
10780   BIT1               bit1 ,
10781   HEX2               hexstr ,
10782   INT1               int ,
10783   Pointer            pointer1 ,
10784   Pointer            pointer2 ,
10785   integer            length1 ,
10786   octetstring        octN ,
10787   Optional_part      opt_part   ,
10788   EndOfOptionalPart  eop   optional    }
10789    with { variant (pointer1) "POINTERTO(length1)";
10790           variant (pointer2) "POINTERTO(opt_part)" ;
10791           variant (length1) "LENGTHTO(octN)"
10792
10793             //Note, that optional part itself is mandatory but it may be empty!
10794         }
10795
10796
10797 type record Elem5
10798 { MessageType        messageType ,
10799   OCT3               octstr ,
10800   BIT7               bit7 ,
10801   BIT1               bit1 ,
10802   HEX2               hexstr ,
10803   INT1               int ,
10804   Pointer            pointer1 ,
10805   Pointer            pointer2 ,
10806   integer            length1 ,
10807   octetstring        octN ,
10808   Optional_part      opt_part   ,
10809   EndOfOptionalPart  eop   optional    }
10810    with { variant (pointer1) "POINTERTO(length1)";
10811           variant (pointer2) "POINTERTO(opt_part)" ;
10812           variant (length1) "LENGTHTO(octN)"
10813
10814             //Note, that optional part itself is mandatory but it may be empty!
10815         }
10816
10817
10818 type union RAW_PDU
10819 { Elem1      elem1 ,
10820   Elem2      elem2 ,
10821   Elem3      elem3 ,
10822   Elem4      elem4 ,
10823   Elem5      elem5  }
10824 with { variant "TAG (
10825                       elem1 ,       messageType = e1 ;
10826                       elem2 ,       messageType = e2 ;
10827                       elem3 ,       messageType = e3 ;
10828                       elem4 ,       messageType = e4 ;
10829                       elem5 ,       messageType = e5   ) "
10830      } ;
10831
10832 }with{encode "RAW"}
10833
10834 const RAW_PDU
10835     i := { elem2 :=
10836              {  messageType :=       e2 ,
10837                 octstr :=            '123456'O ,
10838                 bit7 :=              '0000000'B ,
10839                 bit1 :=              '1'B ,
10840                 hexstr :=            'FF'H ,
10841                 int :=               1 ,
10842                 pointer1 :=          2 ,
10843                 pointer2 :=          7 ,
10844                 length1 :=           5 ,
10845                 octN :=              '1234567890'O ,
10846                 opt_part :=
10847                      { param1 :=
10848                            { paramName :=         name1 ,
10849                              paramLength :=       6 ,
10850                              octstr :=            '123456'O ,
10851                              bit7 :=              '0000000'B ,
10852                              bit1 :=              '1'B ,
10853                              hexstr :=            'FF'H ,
10854                              int :=               1 }  ,
10855                        param4 := omit ,
10856                        param3 :=
10857                            { paramName :=         name3 ,
10858                              paramLength :=       6 ,
10859                              octstr :=            '123456'O ,
10860                              bit7 :=              '0000000'B ,
10861                              bit1 :=              '1'B ,
10862                              hexstr :=            'FF'H ,
10863                              int :=               1 }  ,
10864                        param2 := omit       },
10865                 eop :=    omit          } }
10866
10867
10868
10869 const octetstring       o := '0212345680FF010207051234567890010612345680FF01030612345680FF01'O
10870
10871
10872
10873 <TTCN_TC:EXEC>
10874
10875 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
10876 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
10877
10878 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
10879   else {setverdict(fail);}
10880
10881 <RESULT>
10882
10883 Overall verdict: pass
10884
10885 <END_TC>
10886
10887 :exmp.
10888
10889 .*---------------------------------------------------------------------*
10890 :h3. Test of  structured types - 14
10891 .*---------------------------------------------------------------------*
10892 :xmp tab=0.
10893
10894 <TC-  Test of  structured types - 14>
10895
10896 <STATIC>
10897
10898 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
10899 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
10900
10901 group RAW_group{
10902
10903 type integer Pointer
10904 with { variant "" } ;
10905
10906 type octetstring EndOfOptionalPart
10907 with { variant "FIELDLENGTH(1)" } ;
10908
10909 type integer INT1
10910 with { variant "" } ;
10911
10912 type bitstring BIT1
10913 with { variant "FIELDLENGTH(1)" } ;
10914
10915 type bitstring BIT7
10916 with { variant "FIELDLENGTH(7)" } ;
10917
10918 type octetstring OCT3
10919 with { variant "FIELDLENGTH(3)" } ;
10920
10921 type hexstring HEX2
10922 with { variant "FIELDLENGTH(2)" } ;
10923
10924 type enumerated  MessageType
10925   { e1(1),      e2(2),      e3(3),    e4(4),    e5(5) }
10926    with { variant "FIELDLENGTH(8)" }
10927
10928
10929 type enumerated  ParamName
10930   { name1(1),      name2(2),      name3(3),    name4(4) }
10931    with { variant "FIELDLENGTH(8)" }
10932
10933 type record Param1
10934 { ParamName           paramName  ,
10935   integer             paramLength ,
10936   OCT3                octstr ,
10937   BIT7                bit7 ,
10938   BIT1                bit1 ,
10939   HEX2                hexstr ,
10940   INT1                int }
10941    with { variant  (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int   )" }
10942
10943 type record Param2
10944 { ParamName           paramName ,
10945   integer             paramLength ,
10946   OCT3                octstr ,
10947   BIT7                bit7 ,
10948   BIT1                bit1 ,
10949   HEX2                hexstr ,
10950   INT1                int }
10951    with { variant  (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int   )" }
10952
10953 type record Param3
10954 { ParamName           paramName  ,
10955   integer             paramLength ,
10956   OCT3                octstr ,
10957   BIT7                bit7 ,
10958   BIT1                bit1 ,
10959   HEX2                hexstr ,
10960   INT1                int }
10961    with { variant  (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int   )" }
10962
10963
10964 type record Field1
10965 { BIT1    field2indic ,
10966   BIT7    field2par   }
10967 with { variant "" }
10968
10969
10970
10971 type union Field2
10972 { OCT3       present_ ,
10973   OCT3       absent   }
10974 with { variant "" }
10975
10976
10977
10978 type record Param4
10979 { ParamName           paramName  ,
10980   integer             paramLength ,
10981   Field1                field1 ,
10982   Field2                field2 ,
10983   HEX2                hexstr ,
10984   INT1                int }
10985    with { variant (field2) "CROSSTAG(
10986                                       present_ ,       field1.field2indic = '1'B ;
10987                                       absent ,        field1.field2indic = '0'B ; )" ;
10988           variant  (paramLength) "LENGTHTO(field1 , field2 , hexstr , int   )" }
10989
10990 type set Optional_part
10991 { Param1    param1 optional ,
10992   Param2    param2 optional ,
10993   Param3    param3 optional ,
10994   Param4    param4 optional   }
10995    with { variant "TAG (
10996                          param1 ,           paramName= name1;
10997                          param2 ,           paramName= name2;
10998                          param3 ,           paramName= name3;
10999                          param4 ,           paramName= name4  )"   }
11000
11001
11002 type record Elem1
11003 { MessageType        messageType ,
11004   OCT3               octstr ,
11005   BIT7               bit7 ,
11006   BIT1               bit1 ,
11007   HEX2               hexstr ,
11008   INT1               int ,
11009   Pointer            pointer1 ,
11010   Pointer            pointer2 ,
11011   integer            length1 ,
11012   octetstring        octN ,
11013   Optional_part      opt_part   ,
11014   EndOfOptionalPart  eop   optional    }
11015    with { variant (pointer1) "POINTERTO(length1)";
11016           variant (pointer2) "POINTERTO(opt_part)" ;
11017           variant (length1) "LENGTHTO(octN)"
11018
11019             //Note, that optional part itself is mandatory but it may be empty!
11020         }
11021
11022
11023 type record Elem2
11024 { MessageType        messageType ,
11025   OCT3               octstr ,
11026   BIT7               bit7 ,
11027   BIT1               bit1 ,
11028   HEX2               hexstr ,
11029   INT1               int ,
11030   Pointer            pointer1 ,
11031   Pointer            pointer2 ,
11032   integer            length1 ,
11033   octetstring        octN ,
11034   Optional_part      opt_part   ,
11035   EndOfOptionalPart  eop   optional    }
11036    with { variant (pointer1) "POINTERTO(length1)";
11037           variant (pointer2) "POINTERTO(opt_part)" ;
11038           variant (length1) "LENGTHTO(octN)"
11039
11040             //Note, that optional part itself is mandatory but it may be empty!
11041         }
11042
11043
11044 type record Elem3
11045 { MessageType        messageType ,
11046   OCT3               octstr ,
11047   BIT7               bit7 ,
11048   BIT1               bit1 ,
11049   HEX2               hexstr ,
11050   INT1               int ,
11051   Pointer            pointer1 ,
11052   Pointer            pointer2 ,
11053   integer            length1 ,
11054   octetstring        octN ,
11055   Optional_part      opt_part   ,
11056   EndOfOptionalPart  eop   optional    }
11057    with { variant (pointer1) "POINTERTO(length1)";
11058           variant (pointer2) "POINTERTO(opt_part)" ;
11059           variant (length1) "LENGTHTO(octN)"
11060
11061             //Note, that optional part itself is mandatory but it may be empty!
11062         }
11063
11064
11065 type record Elem4
11066 { MessageType        messageType ,
11067   OCT3               octstr ,
11068   BIT7               bit7 ,
11069   BIT1               bit1 ,
11070   HEX2               hexstr ,
11071   INT1               int ,
11072   Pointer            pointer1 ,
11073   Pointer            pointer2 ,
11074   integer            length1 ,
11075   octetstring        octN ,
11076   Optional_part      opt_part   ,
11077   EndOfOptionalPart  eop   optional    }
11078    with { variant (pointer1) "POINTERTO(length1)";
11079           variant (pointer2) "POINTERTO(opt_part)" ;
11080           variant (length1) "LENGTHTO(octN)"
11081
11082             //Note, that optional part itself is mandatory but it may be empty!
11083         }
11084
11085
11086 type record Elem5
11087 { MessageType        messageType ,
11088   OCT3               octstr ,
11089   BIT7               bit7 ,
11090   BIT1               bit1 ,
11091   HEX2               hexstr ,
11092   INT1               int ,
11093   Pointer            pointer1 ,
11094   Pointer            pointer2 ,
11095   integer            length1 ,
11096   octetstring        octN ,
11097   Optional_part      opt_part   ,
11098   EndOfOptionalPart  eop   optional    }
11099    with { variant (pointer1) "POINTERTO(length1)";
11100           variant (pointer2) "POINTERTO(opt_part)" ;
11101           variant (length1) "LENGTHTO(octN)"
11102
11103             //Note, that optional part itself is mandatory but it may be empty!
11104         }
11105
11106
11107 type union RAW_PDU
11108 { Elem1      elem1 ,
11109   Elem2      elem2 ,
11110   Elem3      elem3 ,
11111   Elem4      elem4 ,
11112   Elem5      elem5  }
11113 with { variant "TAG (
11114                       elem1 ,       messageType = e1 ;
11115                       elem2 ,       messageType = e2 ;
11116                       elem3 ,       messageType = e3 ;
11117                       elem4 ,       messageType = e4 ;
11118                       elem5 ,       messageType = e5   ) "
11119      } ;
11120
11121 } with{encode "RAW"}
11122
11123 const RAW_PDU
11124     i := { elem2 :=
11125              {  messageType :=       e2 ,
11126                 octstr :=            '123456'O ,
11127                 bit7 :=              '0000000'B ,
11128                 bit1 :=              '1'B ,
11129                 hexstr :=            'FF'H ,
11130                 int :=               1 ,
11131                 pointer1 :=          2 ,
11132                 pointer2 :=          7 ,
11133                 length1 :=           5 ,
11134                 octN :=              '1234567890'O ,
11135                 opt_part :=
11136                      { param1 :=
11137                            { paramName :=         name1 ,
11138                              paramLength :=       6 ,
11139                              octstr :=            '123456'O ,
11140                              bit7 :=              '0000000'B ,
11141                              bit1 :=              '1'B ,
11142                              hexstr :=            'FF'H ,
11143                              int :=               1 }  ,
11144                        param4 :=
11145                            { paramName :=         name4 ,
11146                              paramLength :=       6 ,
11147                              field1 :=
11148                                   { field2indic :=  '1'B ,
11149                                     field2par :=  '0000000'B  } ,
11150                              field2 :=
11151                                   { present_ :=  'FFFFFF'O   } ,
11152                              hexstr :=            '12'H ,
11153                              int :=               1 }  ,
11154                        param3 :=
11155                            { paramName :=         name3 ,
11156                              paramLength :=       6 ,
11157                              octstr :=            '123456'O ,
11158                              bit7 :=              '0000000'B ,
11159                              bit1 :=              '1'B ,
11160                              hexstr :=            'FF'H ,
11161                              int :=               1 }  ,
11162                        param2 := omit       },
11163                 eop :=   '00'O        } }
11164
11165
11166
11167 const octetstring    o :='0212345680FF010207051234567890010612345680FF01030612345680FF01040601FFFFFF210100'O
11168
11169
11170 <TTCN_TC:EXEC>
11171
11172 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
11173 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
11174
11175 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
11176   else {setverdict(fail);}
11177
11178 <RESULT>
11179
11180 Overall verdict: pass
11181
11182 <END_TC>
11183
11184 :exmp.
11185
11186 .*---------------------------------------------------------------------*
11187 :h3. Test of  structured types - 15
11188 .*---------------------------------------------------------------------*
11189 :xmp tab=0.
11190
11191 <TC-  Test of  structured types - 15>
11192
11193 <STATIC>
11194
11195 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
11196 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
11197
11198 group RAW_group{
11199
11200 type integer Pointer
11201 with { variant "" } ;
11202
11203 type octetstring EndOfOptionalPart
11204 with { variant "FIELDLENGTH(1)" } ;
11205
11206 type integer INT1
11207 with { variant "" } ;
11208
11209 type bitstring BIT1
11210 with { variant "FIELDLENGTH(1)" } ;
11211
11212 type bitstring BIT7
11213 with { variant "FIELDLENGTH(7)" } ;
11214
11215 type octetstring OCT3
11216 with { variant "FIELDLENGTH(3)" } ;
11217
11218 type hexstring HEX2
11219 with { variant "FIELDLENGTH(2)" } ;
11220
11221 type enumerated  MessageType
11222   { e1(1),      e2(2),      e3(3),    e4(4),    e5(5) }
11223    with { variant "FIELDLENGTH(8)" }
11224
11225
11226 type enumerated  ParamName
11227   { name1(1),      name2(2),      name3(3),    name4(4) }
11228    with { variant "FIELDLENGTH(8)" }
11229
11230 type record Param1
11231 { ParamName           paramName  ,
11232   integer             paramLength ,
11233   OCT3                octstr ,
11234   BIT7                bit7 ,
11235   BIT1                bit1 ,
11236   HEX2                hexstr ,
11237   INT1                int }
11238    with { variant  (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int   )" }
11239
11240 type record Param2
11241 { ParamName           paramName ,
11242   integer             paramLength ,
11243   OCT3                octstr ,
11244   BIT7                bit7 ,
11245   BIT1                bit1 ,
11246   HEX2                hexstr ,
11247   INT1                int }
11248    with { variant  (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int   )" }
11249
11250 type record Param3
11251 { ParamName           paramName  ,
11252   integer             paramLength ,
11253   OCT3                octstr ,
11254   BIT7                bit7 ,
11255   BIT1                bit1 ,
11256   HEX2                hexstr ,
11257   INT1                int }
11258    with { variant  (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int   )" }
11259
11260
11261 type record Field1
11262 { BIT1    field2indic ,
11263   BIT7    field2par   }
11264 with { variant "" }
11265
11266
11267 type union Field2
11268 { OCT3       present_ ,
11269   OCT3       absent   }
11270 with { variant "" }
11271
11272
11273 type record Param4
11274 { ParamName           paramName  ,
11275   integer             paramLength ,
11276   Field1                field1 ,
11277   Field2                field2 ,
11278   HEX2                hexstr ,
11279   INT1                int }
11280    with { variant (field2) "CROSSTAG(
11281                                       present_ ,       field1.field2indic = '1'B ;
11282                                       absent ,        field1.field2indic = '0'B ; )" ;
11283           variant  (paramLength) "LENGTHTO(field1 , field2 , hexstr , int   )" }
11284
11285 type set Optional_part
11286 { Param1    param1 optional ,
11287   Param2    param2 optional ,
11288   Param3    param3 optional ,
11289   Param4    param4 optional   }
11290    with { variant "TAG (
11291                          param1 ,           paramName= name1;
11292                          param2 ,           paramName= name2;
11293                          param3 ,           paramName= name3;
11294                          param4 ,           paramName= name4  )"   }
11295
11296
11297 type record Elem1
11298 { MessageType        messageType ,
11299   OCT3               octstr ,
11300   BIT7               bit7 ,
11301   BIT1               bit1 ,
11302   HEX2               hexstr ,
11303   INT1               int ,
11304   Pointer            pointer1 ,
11305   Pointer            pointer2 ,
11306   integer            length1 ,
11307   octetstring        octN ,
11308   Optional_part      opt_part   ,
11309   EndOfOptionalPart  eop   optional    }
11310    with { variant (pointer1) "POINTERTO(length1)";
11311           variant (pointer2) "POINTERTO(opt_part)" ;
11312           variant (length1) "LENGTHTO(octN)"
11313
11314             //Note, that optional part itself is mandatory but it may be empty!
11315         }
11316
11317
11318 type record Elem2
11319 { MessageType        messageType ,
11320   OCT3               octstr ,
11321   BIT7               bit7 ,
11322   BIT1               bit1 ,
11323   HEX2               hexstr ,
11324   INT1               int ,
11325   Pointer            pointer1 ,
11326   Pointer            pointer2 ,
11327   integer            length1 ,
11328   octetstring        octN ,
11329   Optional_part      opt_part   ,
11330   EndOfOptionalPart  eop   optional    }
11331    with { variant (pointer1) "POINTERTO(length1)";
11332           variant (pointer2) "POINTERTO(opt_part)" ;
11333           variant (length1) "LENGTHTO(octN)"
11334
11335             //Note, that optional part itself is mandatory but it may be empty!
11336         }
11337
11338
11339 type record Elem3
11340 { MessageType        messageType ,
11341   OCT3               octstr ,
11342   BIT7               bit7 ,
11343   BIT1               bit1 ,
11344   HEX2               hexstr ,
11345   INT1               int ,
11346   Pointer            pointer1 ,
11347   Pointer            pointer2 ,
11348   integer            length1 ,
11349   octetstring        octN ,
11350   Optional_part      opt_part   ,
11351   EndOfOptionalPart  eop   optional    }
11352    with { variant (pointer1) "POINTERTO(length1)";
11353           variant (pointer2) "POINTERTO(opt_part)" ;
11354           variant (length1) "LENGTHTO(octN)"
11355
11356             //Note, that optional part itself is mandatory but it may be empty!
11357         }
11358
11359
11360 type record Elem4
11361 { MessageType        messageType ,
11362   OCT3               octstr ,
11363   BIT7               bit7 ,
11364   BIT1               bit1 ,
11365   HEX2               hexstr ,
11366   INT1               int ,
11367   Pointer            pointer1 ,
11368   Pointer            pointer2 ,
11369   integer            length1 ,
11370   octetstring        octN ,
11371   Optional_part      opt_part   ,
11372   EndOfOptionalPart  eop   optional    }
11373    with { variant (pointer1) "POINTERTO(length1)";
11374           variant (pointer2) "POINTERTO(opt_part)" ;
11375           variant (length1) "LENGTHTO(octN)"
11376
11377             //Note, that optional part itself is mandatory but it may be empty!
11378         }
11379
11380
11381 type record Elem5
11382 { MessageType        messageType ,
11383   OCT3               octstr ,
11384   BIT7               bit7 ,
11385   BIT1               bit1 ,
11386   HEX2               hexstr ,
11387   INT1               int ,
11388   Pointer            pointer1 ,
11389   Pointer            pointer2 ,
11390   integer            length1 ,
11391   octetstring        octN ,
11392   Optional_part      opt_part   ,
11393   EndOfOptionalPart  eop   optional    }
11394    with { variant (pointer1) "POINTERTO(length1)";
11395           variant (pointer2) "POINTERTO(opt_part)" ;
11396           variant (length1) "LENGTHTO(octN)"
11397
11398             //Note, that optional part itself is mandatory but it may be empty!
11399         }
11400
11401
11402 type union RAW_PDU
11403 { Elem1      elem1 ,
11404   Elem2      elem2 ,
11405   Elem3      elem3 ,
11406   Elem4      elem4 ,
11407   Elem5      elem5  }
11408 with { variant "TAG (
11409                       elem1 ,       messageType = e1 ;
11410                       elem2 ,       messageType = e2 ;
11411                       elem3 ,       messageType = e3 ;
11412                       elem4 ,       messageType = e4 ;
11413                       elem5 ,       messageType = e5   ) "
11414      } ;
11415
11416 }with{encode "RAW"}
11417
11418 const RAW_PDU
11419     i := { elem2 :=
11420              {  messageType :=       e2 ,
11421                 octstr :=            '123456'O ,
11422                 bit7 :=              '0000000'B ,
11423                 bit1 :=              '1'B ,
11424                 hexstr :=            'FF'H ,
11425                 int :=               1 ,
11426                 pointer1 :=          2 ,
11427                 pointer2 :=          7 ,
11428                 length1 :=           5 ,
11429                 octN :=              '1234567890'O ,
11430                 opt_part :=
11431                      { param1 :=
11432                            { paramName :=         name1 ,
11433                              paramLength :=       6 ,
11434                              octstr :=            '123456'O ,
11435                              bit7 :=              '0000000'B ,
11436                              bit1 :=              '1'B ,
11437                              hexstr :=            'FF'H ,
11438                              int :=               1 }  ,
11439                        param4 :=
11440                            { paramName :=         name4 ,
11441                              paramLength :=       6 ,
11442                              field1 :=
11443                                   { field2indic :=  '0'B ,
11444                                     field2par :=  '0000000'B  } ,
11445                              field2 :=
11446                                   { absent :=  '000000'O   } ,
11447                              hexstr :=            '12'H ,
11448                              int :=               1 }  ,
11449                        param3 :=
11450                            { paramName :=         name3 ,
11451                              paramLength :=       6 ,
11452                              octstr :=            '123456'O ,
11453                              bit7 :=              '0000000'B ,
11454                              bit1 :=              '1'B ,
11455                              hexstr :=            'FF'H ,
11456                              int :=               1 }  ,
11457                        param2 := omit       },
11458                 eop :=   '00'O        } }
11459
11460
11461
11462 const octetstring   o :='0212345680FF010207051234567890010612345680FF01030612345680FF01040600000000210100'O
11463
11464
11465
11466 <TTCN_TC:EXEC>
11467
11468 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
11469 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
11470
11471 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
11472   else {setverdict(fail);}
11473
11474 <RESULT>
11475
11476 Overall verdict: pass
11477
11478 <END_TC>
11479
11480 :exmp.
11481
11482 .*---------------------------------------------------------------------*
11483 :h3. Test of  structured types - 16
11484 .*---------------------------------------------------------------------*
11485 :xmp tab=0.
11486
11487 <TC-  Test of  structured types - 16>
11488
11489 <STATIC>
11490
11491 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
11492 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
11493
11494 group RAW_group{
11495
11496 type bitstring BIT4
11497 with { variant "FIELDLENGTH(4)" } ;
11498
11499 type octetstring OCT2
11500 with { variant "FIELDLENGTH(2)" } ;
11501
11502 type octetstring OCT3
11503 with { variant "FIELDLENGTH(3)" } ;
11504
11505 type union Union2
11506 { OCT3          field1 ,
11507   OCT2          field2 ,
11508   OCT3          field3 ,
11509   OCT2          field4  }
11510  with { variant ""};
11511
11512
11513 type union Union1
11514 { BIT4          field1 ,
11515   BIT4          field2  }
11516  with { variant ""};
11517
11518
11519 type record RAW_PDU
11520 { BIT4                id ,
11521   Union1             union1 ,
11522   Union2             union2  }
11523    with { variant  (union2) "CROSSTAG(
11524                                        field1 ,       id = '0001'B ;
11525                                        field2 ,       id = '0010'B ;
11526                                        field3 ,       id = '0011'B ;
11527                                        field4 ,    {  id = '0100'B ,
11528                                                       id = '0101'B ,
11529                                                       id = '0111'B   }    )"  ;
11530            variant  (union1) "CROSSTAG(
11531                                        field1 ,   {   id = '0001'B ,
11532                                                       id = '0010'B ,
11533                                                       id = '0011'B     } ;
11534                                        field2 ,    {  id = '0100'B ,
11535                                                       id = '0101'B ,
11536                                                       id = '0111'B   }    )" } ;
11537
11538 }with{encode "RAW"}
11539
11540
11541
11542
11543 const RAW_PDU
11544     i := { id :=   '0001'B ,
11545            union1 := { field1 := '0000'B } ,
11546            union2 := { field1 := '123456'O }     }
11547
11548
11549
11550 const octetstring   o :='01123456'O
11551
11552
11553
11554 <TTCN_TC:EXEC>
11555
11556 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
11557 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
11558
11559 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
11560   else {setverdict(fail);}
11561
11562 <RESULT>
11563
11564 Overall verdict: pass
11565
11566 <END_TC>
11567
11568 :exmp.
11569
11570 .*---------------------------------------------------------------------*
11571 :h3. Test of  structured types - 17
11572 .*---------------------------------------------------------------------*
11573 :xmp tab=0.
11574
11575 <TC-  Test of  structured types - 17>
11576
11577 <STATIC>
11578
11579 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
11580 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
11581
11582 group RAW_group{
11583
11584 type bitstring BIT4
11585 with { variant "FIELDLENGTH(4)" } ;
11586
11587 type octetstring OCT2
11588 with { variant "FIELDLENGTH(2)" } ;
11589
11590 type octetstring OCT3
11591 with { variant "FIELDLENGTH(3)" } ;
11592
11593
11594 type union Union2
11595 { OCT3          field1 ,
11596   OCT2          field2 ,
11597   OCT3          field3 ,
11598   OCT2          field4  }
11599  with { variant ""};
11600
11601
11602 type union Union1
11603 { BIT4          field1 ,
11604   BIT4          field2  }
11605  with { variant ""};
11606
11607
11608 type record RAW_PDU
11609 { BIT4                id ,
11610   Union1             union1 ,
11611   Union2             union2  }
11612    with { variant  (union2) "CROSSTAG(
11613                                        field1 ,       id = '0001'B ;
11614                                        field2 ,       id = '0010'B ;
11615                                        field3 ,       id = '0011'B ;
11616                                        field4 ,    {  id = '0100'B ,
11617                                                       id = '0101'B ,
11618                                                       id = '0111'B   }    )"  ;
11619            variant  (union1) "CROSSTAG(
11620                                        field1 ,   {   id = '0001'B ,
11621                                                       id = '0010'B ,
11622                                                       id = '0011'B     } ;
11623                                        field2 ,    {  id = '0100'B ,
11624                                                       id = '0101'B ,
11625                                                       id = '0111'B   }    )" } ;
11626
11627 }with{encode "RAW"}
11628
11629 const RAW_PDU
11630     i := { id :=   '0111'B ,
11631            union1 := { field2 := '1111'B } ,
11632            union2 := { field4 := '1234'O }       }
11633
11634
11635
11636 const octetstring   o :='F71234'O
11637
11638
11639
11640 <TTCN_TC:EXEC>
11641
11642 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
11643 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
11644
11645 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
11646   else {setverdict(fail);}
11647
11648 <RESULT>
11649
11650 Overall verdict: pass
11651
11652 <END_TC>
11653
11654 :exmp.
11655
11656 .*---------------------------------------------------------------------*
11657 :h2. Testing RAW update
11658 .*---------------------------------------------------------------------*
11659 .*---------------------------------------------------------------------*
11660 :h3. Raw update test 1
11661 .*---------------------------------------------------------------------*
11662 :xmp tab=0.
11663
11664 <TC-  Raw update test 1>
11665
11666 <STATIC>
11667
11668 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
11669 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
11670
11671 group RAW_group{
11672
11673 type bitstring BIT4
11674 with { variant "FIELDLENGTH(4)" } ;
11675
11676 type octetstring OCT2
11677 with { variant "FIELDLENGTH(2)" } ;
11678
11679 type union Union2
11680 { OCT2          field1 ,
11681   OCT2          field2 ,
11682   OCT2          field3 ,
11683   OCT2          field4  }
11684  with { variant ""};
11685
11686
11687 type union Union1
11688 { BIT4          field1 ,
11689   BIT4          field2  }
11690  with { variant ""};
11691
11692
11693 type record RAW_PDU
11694 { Union2 union2 ,
11695   Union1 union1,
11696   BIT4 id }
11697    with { variant  (union2) "CROSSTAG(
11698                                        field1 ,       id = '0001'B ;
11699                                        field2 ,       id = '0010'B ;
11700                                        field3 ,       id = '0011'B ;
11701                                        field4 ,    {  id = '0100'B ,
11702                                                       id = '0101'B ,
11703                                                       id = '0111'B   }    )"  ;
11704            variant  (union1) "CROSSTAG(
11705                                        field1 ,   {   id = '0001'B ,
11706                                                       id = '0010'B ,
11707                                                       id = '0011'B     } ;
11708                                        field2 ,    {  id = '0100'B ,
11709                                                       id = '0101'B ,
11710                                                       id = '0111'B   }    )" } ;
11711
11712 }with{encode "RAW"}
11713
11714 const RAW_PDU
11715     i := {  union2 := { field4 := '1234'O } ,
11716             union1 := { field2 := '1111'B },
11717             id := '0111'B }
11718
11719
11720
11721 const octetstring   o :='12347F'O
11722
11723
11724
11725 <TTCN_TC:EXEC>
11726
11727 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
11728 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
11729
11730 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
11731   else {setverdict(fail);}
11732
11733 <RESULT>
11734
11735 Overall verdict: pass
11736
11737 <END_TC>
11738
11739 :exmp.
11740
11741 .*---------------------------------------------------------------------*
11742 :h3. Raw update test 2
11743 .*---------------------------------------------------------------------*
11744 :xmp tab=0.
11745
11746 <TC-  Raw update test 2>
11747
11748 <STATIC>
11749
11750 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
11751 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
11752
11753 group RAW_group{
11754
11755 type bitstring BIT4
11756 with { variant "FIELDLENGTH(4)" } ;
11757
11758 type octetstring OCT2
11759 with { variant "FIELDLENGTH(2)" } ;
11760
11761
11762 type union Union2
11763 { OCT2          field1 ,
11764   OCT2          field2 ,
11765   OCT2          field3 ,
11766   OCT2          field4  }
11767  with { variant ""};
11768
11769
11770 type union Union1
11771 { BIT4          field1 ,
11772   BIT4          field2  }
11773  with { variant ""};
11774
11775
11776 type record RAW_PDU
11777 { Union2 union2 ,
11778   Union1 union1,
11779   BIT4 id }
11780    with { variant  (union2) "CROSSTAG(
11781                                        field1 ,       id = '0001'B ;
11782                                        field2 ,       id = '0010'B ;
11783                                        field3 ,       id = '0011'B ;
11784                                        field4 ,    {  id = '0100'B ,
11785                                                       id = '0101'B ,
11786                                                       id = '0111'B   }    )"  ;
11787            variant  (union1) "CROSSTAG(
11788                                        field1 ,   {   id = '0001'B ,
11789                                                       id = '0010'B ,
11790                                                       id = '0011'B     } ;
11791                                        field2 ,    {  id = '0100'B ,
11792                                                       id = '0101'B ,
11793                                                       id = '0111'B   }    )" } ;
11794
11795 }with{encode "RAW"}
11796
11797 const RAW_PDU
11798     i := {  union2 := { field1 := '1234'O } ,
11799             union1 := { field1 := '1111'B },
11800             id := '0001'B }
11801
11802
11803
11804 const octetstring   o :='12341F'O
11805
11806
11807
11808 <TTCN_TC:EXEC>
11809
11810 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
11811 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
11812
11813 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
11814   else {setverdict(fail);}
11815
11816 <RESULT>
11817
11818 Overall verdict: pass
11819
11820 <END_TC>
11821
11822 :exmp.
11823
11824 .*---------------------------------------------------------------------*
11825 :h3. Raw update test 3
11826 .*---------------------------------------------------------------------*
11827 :xmp tab=0.
11828
11829 <TC-  Raw update test 3>
11830
11831 <STATIC>
11832
11833 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
11834 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
11835
11836 group RAW_group{
11837
11838 type bitstring BIT4
11839 with { variant "FIELDLENGTH(4)" } ;
11840
11841 type bitstring BIT8
11842 with { variant "FIELDLENGTH(8)"};
11843
11844 type octetstring OCT2
11845 with { variant "FIELDLENGTH(2)" } ;
11846
11847
11848 type union Union2
11849 { OCT2          field1 ,
11850   OCT2          field2 ,
11851   OCT2          field3 ,
11852   OCT2          field4  }
11853  with { variant ""};
11854
11855
11856 type union Union1
11857 { BIT4          field1 ,
11858   BIT4          field2  }
11859  with { variant ""};
11860
11861
11862 type record RAW_PDU
11863 { Union2             union2 ,
11864   Union1 union1,
11865   BIT8 outfiller,
11866   BIT4 id }
11867    with { variant  (union2) "CROSSTAG(
11868                                        field1 ,       id = '0001'B ;
11869                                        field2 ,       id = '0010'B ;
11870                                        field3 ,       id = '0011'B ;
11871                                        field4 ,    {  id = '0100'B ,
11872                                                       id = '0101'B ,
11873                                                       id = '0111'B   }    )"  ;
11874            variant  (union1) "CROSSTAG(
11875                                        field1 ,   {   id = '0001'B ,
11876                                                       id = '0010'B ,
11877                                                       id = '0011'B     } ;
11878                                        field2 ,    {  id = '0100'B ,
11879                                                       id = '0101'B ,
11880                                                       id = '0111'B   }    )" } ;
11881
11882 }with{encode "RAW"}
11883
11884 const RAW_PDU
11885     i := {  union2 := { field1 := '1234'O } ,
11886             union1 := { field1 := '1111'B },
11887             outfiller := '00001000'B,
11888             id := '0001'B }
11889
11890
11891
11892 const octetstring   o :='12348F10'O
11893
11894
11895
11896 <TTCN_TC:EXEC>
11897
11898 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
11899 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
11900
11901 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
11902   else {setverdict(fail);}
11903
11904 <RESULT>
11905
11906 Overall verdict: pass
11907
11908 <END_TC>
11909
11910 :exmp.
11911
11912 .*---------------------------------------------------------------------*
11913 :h3. Raw update test 4
11914 .*---------------------------------------------------------------------*
11915 :xmp tab=0.
11916
11917 <TC-  Raw update test 4>
11918
11919 <STATIC>
11920
11921 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
11922 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
11923
11924 group RAW_group{
11925
11926 type bitstring BIT4
11927 with { variant "FIELDLENGTH(4)" } ;
11928
11929 type bitstring BIT8
11930 with { variant "FIELDLENGTH(8)"};
11931
11932 type octetstring OCT2
11933 with { variant "FIELDLENGTH(2)" } ;
11934
11935
11936 type union Union2
11937 { OCT2          field1 ,
11938   OCT2          field2 ,
11939   OCT2          field3 ,
11940   OCT2          field4  }
11941  with { variant ""};
11942
11943
11944 type union Union1
11945 { BIT4          field1 ,
11946   BIT4          field2  }
11947  with { variant ""};
11948
11949
11950 type record RAW_PDU
11951 { Union2  union2 ,
11952   BIT8    outfiller,
11953   Union1  union1,
11954   BIT4 id }
11955    with { variant  (union2) "CROSSTAG(
11956                                        field1 ,       id = '0001'B ;
11957                                        field2 ,       id = '0010'B ;
11958                                        field3 ,       id = '0011'B ;
11959                                        field4 ,    {  id = '0100'B ,
11960                                                       id = '0101'B ,
11961                                                       id = '0111'B   }    )"  ;
11962            variant  (union1) "CROSSTAG(
11963                                        field1 ,   {   id = '0001'B ,
11964                                                       id = '0010'B ,
11965                                                       id = '0011'B     } ;
11966                                        field2 ,    {  id = '0100'B ,
11967                                                       id = '0101'B ,
11968                                                       id = '0111'B   }    )" } ;
11969
11970 }with{encode "RAW"}
11971
11972 const RAW_PDU
11973     i := {  union2 := { field1 := '1234'O } ,
11974             outfiller := '00001000'B,
11975             union1 := { field1 := '1111'B },
11976             id := '0001'B }
11977
11978
11979 const octetstring   o :='1234081F'O
11980
11981 <TTCN_TC:EXEC>
11982
11983 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
11984 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
11985
11986 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
11987   else {setverdict(fail);}
11988
11989 <RESULT>
11990
11991 Overall verdict: pass
11992
11993 <END_TC>
11994
11995 :exmp.
11996
11997 .*---------------------------------------------------------------------*
11998 :h3. Raw update test 5
11999 .*---------------------------------------------------------------------*
12000 :xmp tab=0.
12001
12002 <TC-  Raw update test 5>
12003
12004 <STATIC>
12005
12006 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12007 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12008
12009 group RAW_group{
12010
12011 type bitstring BIT4
12012 with { variant "FIELDLENGTH(4)" } ;
12013
12014 type bitstring BIT8
12015 with { variant "FIELDLENGTH(8)"};
12016
12017 type octetstring OCT2
12018 with { variant "FIELDLENGTH(2)" } ;
12019
12020
12021 type union Union2
12022 { OCT2          field1 ,
12023   OCT2          field2 ,
12024   OCT2          field3 ,
12025   OCT2          field4  }
12026  with { variant ""};
12027
12028
12029 type union Union1
12030 { BIT4          field1 ,
12031   BIT4          field2  }
12032  with { variant ""};
12033
12034
12035 type record RAW_PDU
12036 { BIT8    outfiller,
12037   Union2  union2 ,
12038   Union1  union1,
12039   BIT4 id }
12040    with { variant  (union2) "CROSSTAG(
12041                                        field1 ,       id = '0001'B ;
12042                                        field2 ,       id = '0010'B ;
12043                                        field3 ,       id = '0011'B ;
12044                                        field4 ,    {  id = '0100'B ,
12045                                                       id = '0101'B ,
12046                                                       id = '0111'B   }    )"  ;
12047            variant  (union1) "CROSSTAG(
12048                                        field1 ,   {   id = '0001'B ,
12049                                                       id = '0010'B ,
12050                                                       id = '0011'B     } ;
12051                                        field2 ,    {  id = '0100'B ,
12052                                                       id = '0101'B ,
12053                                                       id = '0111'B   }    )" } ;
12054
12055 }with{encode "RAW"}
12056
12057 const RAW_PDU
12058     i := {  outfiller := '00001000'B,
12059             union2 := { field1 := '1234'O } ,
12060             union1 := { field1 := '1111'B },
12061             id := '0001'B }
12062
12063
12064 const octetstring   o :='0812341F'O
12065
12066 <TTCN_TC:EXEC>
12067
12068 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12069 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12070
12071 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12072   else {setverdict(fail);}
12073
12074 <RESULT>
12075
12076 Overall verdict: pass
12077
12078 <END_TC>
12079
12080 :exmp.
12081
12082 .*---------------------------------------------------------------------*
12083 :h3. Raw update test 6
12084 .*---------------------------------------------------------------------*
12085 :xmp tab=0.
12086
12087 <TC-  Raw update test 6>
12088
12089 <STATIC>
12090
12091 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12092 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12093
12094 group RAW_group{
12095
12096 type bitstring BIT4
12097 with { variant "FIELDLENGTH(4)" } ;
12098
12099 type octetstring OCT2
12100 with { variant "FIELDLENGTH(2)" } ;
12101
12102
12103 type union Union2
12104 { OCT2          field1 ,
12105   OCT2          field2 ,
12106   OCT2          field3 ,
12107   OCT2          field4  }
12108  with { variant ""};
12109
12110
12111 type union Union1
12112 { BIT4          field1 ,
12113   BIT4          field2  }
12114  with { variant ""};
12115
12116
12117 type record RAW_PDU
12118 { Union2  union2 ,
12119   BIT4    id,
12120   Union1  union1}
12121    with { variant  (union2) "CROSSTAG(
12122                                        field1 ,       id = '0001'B ;
12123                                        field2 ,       id = '0010'B ;
12124                                        field3 ,       id = '0011'B ;
12125                                        field4 ,    {  id = '0100'B ,
12126                                                       id = '0101'B ,
12127                                                       id = '0111'B   }    )"  ;
12128            variant  (union1) "CROSSTAG(
12129                                        field1 ,   {   id = '0001'B ,
12130                                                       id = '0010'B ,
12131                                                       id = '0011'B     } ;
12132                                        field2 ,    {  id = '0100'B ,
12133                                                       id = '0101'B ,
12134                                                       id = '0111'B   }    )" } ;
12135
12136 }with{encode "RAW"}
12137
12138 const RAW_PDU
12139     i := {  union2 := { field1 := '1234'O },
12140             id := '0001'B,
12141             union1 := { field1 := '1111'B }
12142              }
12143
12144
12145 const octetstring   o :='1234F1'O
12146
12147 <TTCN_TC:EXEC>
12148
12149 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12150 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12151
12152 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12153   else {setverdict(fail);}
12154
12155 <RESULT>
12156
12157 Overall verdict: pass
12158
12159 <END_TC>
12160
12161 :exmp.
12162
12163 .*---------------------------------------------------------------------*
12164 :h3. Raw update test 7
12165 .*---------------------------------------------------------------------*
12166 :xmp tab=0.
12167
12168 <TC-  Raw update test 7>
12169
12170 <STATIC>
12171
12172 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12173 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12174
12175 group RAW_group{
12176
12177 type bitstring BIT4
12178 with { variant "FIELDLENGTH(4)" } ;
12179
12180 type octetstring OCT2
12181 with { variant "FIELDLENGTH(2)" } ;
12182
12183
12184 type union Union2
12185 { OCT2          field1 ,
12186   OCT2          field2 ,
12187   OCT2          field3 ,
12188   OCT2          field4  }
12189  with { variant ""};
12190
12191
12192 type union Union1
12193 { BIT4          field1 ,
12194   BIT4          field2  }
12195  with { variant ""};
12196
12197
12198 type record RAW_PDU
12199 { Union2  union2 ,
12200   BIT4    id,
12201   Union1  union1}
12202    with { variant  (union2) "CROSSTAG(
12203                                        field1 ,       id = '0001'B ;
12204                                        field2 ,       id = '0010'B ;
12205                                        field3 ,       id = '0011'B ;
12206                                        field4 ,    {  id = '0100'B ,
12207                                                       id = '0101'B ,
12208                                                       id = '0111'B   }    )"  ;
12209            variant  (union1) "CROSSTAG(
12210                                        field1 ,   {   id = '0001'B ,
12211                                                       id = '0010'B ,
12212                                                       id = '0011'B     } ;
12213                                        field2 ,    {  id = '0100'B ,
12214                                                       id = '0101'B ,
12215                                                       id = '0111'B   }    )" } ;
12216
12217 }with{encode "RAW"}
12218
12219 const RAW_PDU
12220     i := {  union2 := { field4 := '1234'O },
12221             id := '0101'B,
12222             union1 := { field2 := '1111'B }
12223              }
12224
12225
12226 const octetstring   o :='1234F5'O
12227
12228 <TTCN_TC:EXEC>
12229
12230 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12231 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12232
12233 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12234   else {setverdict(fail);}
12235
12236 <RESULT>
12237
12238 Overall verdict: pass
12239
12240 <END_TC>
12241
12242 :exmp.
12243
12244 .*---------------------------------------------------------------------*
12245 :h3. Raw update test 8
12246 .*---------------------------------------------------------------------*
12247 :xmp tab=0.
12248
12249 <TC-  Raw update test 8>
12250
12251 <STATIC>
12252
12253 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12254 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12255
12256 group RAW_group{
12257
12258 type bitstring BIT4
12259 with { variant "FIELDLENGTH(4)" } ;
12260
12261 type octetstring OCT2
12262 with { variant "FIELDLENGTH(2)" } ;
12263
12264
12265 type union Union2
12266 { OCT2          field1 ,
12267   OCT2          field2 ,
12268   OCT2          field3 ,
12269   OCT2          field4  }
12270  with { variant ""};
12271
12272
12273 type union Union1
12274 { BIT4          field1 ,
12275   BIT4          field2  }
12276  with { variant ""};
12277
12278
12279 type record RAW_PDU
12280 { Union2  union2_1,
12281   Union2  union2_2,
12282   Union1  union1_1,
12283   BIT4    id,
12284   Union1  union1_2,
12285   BIT4    id2}
12286    with { variant  (union2_1) "CROSSTAG(
12287                                        field1 ,       id = '0001'B ;
12288                                        field2 ,       id = '0010'B ;
12289                                        field3 ,       id = '0011'B ;
12290                                        field4 ,    {  id = '0100'B ,
12291                                                       id = '0101'B ,
12292                                                       id = '0111'B   }    )"  ;
12293            variant  (union1_1) "CROSSTAG(
12294                                        field1 ,   {   id = '0001'B ,
12295                                                       id = '0010'B ,
12296                                                       id = '0011'B     } ;
12297                                        field2 ,    {  id = '0100'B ,
12298                                                       id = '0101'B ,
12299                                                       id = '0111'B   })" ;
12300           variant (union2_2) "CROSSTAG(field1 , id2 = '0001'B ;
12301                                       field2 , OTHERWISE)";
12302           variant (union1_2) "CROSSTAG(field1 , id2 = '0001'B ;
12303                                       field2 , OTHERWISE)" ;
12304           } ;
12305
12306 }with{encode "RAW"}
12307
12308 const RAW_PDU
12309     i := {  union2_1 := {field1 := '1234'O },
12310             union2_2 := { field1 := '1234'O},
12311             union1_1 := { field1 := '1111'B },
12312             id := '0001'B,
12313             union1_2 := { field1 := '1111'B},
12314             id2 := '0001'B
12315              }
12316
12317
12318 const octetstring   o :='123412341F1F'O
12319
12320 <TTCN_TC:EXEC>
12321
12322 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12323 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12324
12325 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12326   else {setverdict(fail);}
12327
12328 <RESULT>
12329
12330 Overall verdict: pass
12331
12332 <END_TC>
12333
12334 :exmp.
12335
12336 .*---------------------------------------------------------------------*
12337 :h3. Raw update test 9
12338 .*---------------------------------------------------------------------*
12339 :xmp tab=0.
12340
12341 <TC-  Raw update test 9>
12342
12343 <STATIC>
12344
12345 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12346 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12347
12348 group RAW_group{
12349
12350 type bitstring BIT4
12351 with { variant "FIELDLENGTH(4)" } ;
12352
12353 type octetstring OCT2
12354 with { variant "FIELDLENGTH(2)" } ;
12355
12356
12357 type union Union1
12358 { BIT4          field1 ,
12359   BIT4          field2  }
12360  with { variant ""};
12361
12362 type union Union3
12363 { BIT4 field1,
12364   OCT2 field2
12365 } with { variant ""};
12366
12367
12368 type record RAW_PDU
12369 { BIT4    id,
12370   Union3  union3,
12371   Union1  union1,
12372   BIT4    id2}
12373    with { variant (union1) "CROSSTAG(field1 , id2 = '0001'B ;
12374                                       field2 , OTHERWISE)" ;
12375           variant (union3) "CROSSTAG( field1, id = '0001'B;
12376                                       field2, OTHERWISE)"
12377           } ;
12378
12379 }with{encode "RAW"}
12380
12381 const RAW_PDU
12382     i := {  id := '0001'B,
12383             union3 := {field1 := '1110'B},
12384             union1 := { field1 := '1111'B},
12385             id2 := '0001'B
12386              }
12387
12388
12389 const octetstring   o :='E11F'O
12390
12391 <TTCN_TC:EXEC>
12392
12393 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12394 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12395
12396 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12397   else {setverdict(fail);}
12398
12399 <RESULT>
12400
12401 Overall verdict: pass
12402
12403 <END_TC>
12404
12405 :exmp.
12406
12407 .*---------------------------------------------------------------------*
12408 :h3. Raw update test 10
12409 .*---------------------------------------------------------------------*
12410 :xmp tab=0.
12411
12412 <TC-  Raw update test 10>
12413
12414 <STATIC>
12415
12416 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12417 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12418
12419 group RAW_group{
12420
12421 type bitstring BIT4
12422 with { variant "FIELDLENGTH(4)" } ;
12423
12424 type octetstring OCT2
12425 with { variant "FIELDLENGTH(2)" } ;
12426
12427 group shortening{
12428
12429 type union Union1
12430 { BIT4          field1 ,
12431   BIT4          field2  };
12432
12433 type union Union2
12434 { OCT2          field1 ,
12435   OCT2          field2 };
12436
12437 type union Union3
12438 { BIT4 field1,
12439   OCT2 field2 };
12440
12441 } with {variant ""}
12442
12443 type record RAW_PDU
12444 { Union2  union2,
12445   BIT4    id,
12446   Union3  union3,
12447   Union1  union1,
12448   BIT4    id2}
12449    with { variant (union1) "CROSSTAG(field1 , id2 = '0001'B ;
12450                                       field2 , OTHERWISE)" ;
12451           variant (union3) "CROSSTAG( field1, id = '0001'B;
12452                                       field2, OTHERWISE)";
12453           variant (union2) "CROSSTAG(field1 , id2 = '0001'B ;
12454                                       field2 , OTHERWISE)"} ;
12455
12456 }with{encode "RAW"}
12457
12458 const RAW_PDU
12459     i := {  union2 := {field1 := '1234'O},
12460             id := '0001'B,
12461             union3 := {field1 := '1110'B},
12462             union1 := { field1 := '1111'B},
12463             id2 := '0001'B
12464              }
12465
12466
12467 const octetstring   o :='1234E11F'O
12468
12469 <TTCN_TC:EXEC>
12470
12471 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12472 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12473
12474 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12475   else {setverdict(fail);}
12476
12477 <RESULT>
12478
12479 Overall verdict: pass
12480
12481 <END_TC>
12482
12483 :exmp.
12484
12485 .*---------------------------------------------------------------------*
12486 :h3. Raw update test 11
12487 .*---------------------------------------------------------------------*
12488 :xmp tab=0.
12489
12490 <TC-  Raw update test 11>
12491
12492 <STATIC>
12493
12494 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12495 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12496
12497 group RAW_group{
12498
12499 type bitstring BIT4
12500 with { variant "FIELDLENGTH(4)" } ;
12501
12502 type octetstring OCT2
12503 with { variant "FIELDLENGTH(2)" } ;
12504
12505 group shortening{
12506
12507 type union Union1
12508 { BIT4          field1 ,
12509   BIT4          field2  };
12510
12511 type union Union3
12512 { BIT4 field1,
12513   OCT2 field2 };
12514
12515 } with {variant ""}
12516
12517 type record RAW_PDU
12518 { union {
12519    octetstring field1,
12520    octetstring field2
12521   }       union2,
12522   BIT4    id,
12523   Union3  union3,
12524   Union1  union1,
12525   BIT4    id2}
12526    with { variant (union1) "CROSSTAG(field1 , id2 = '0001'B ;
12527                                       field2 , OTHERWISE)" ;
12528           variant (union3) "CROSSTAG( field1, id = '0001'B;
12529                                       field2, OTHERWISE)";
12530           variant (union2) "CROSSTAG(field1 , id2 = '0001'B ;
12531                                       field2 , OTHERWISE)";
12532           variant (union2.field1, union2.field2) "FIELDLENGTH(2)"
12533           } ;
12534
12535 }with{encode "RAW"}
12536
12537 const RAW_PDU
12538     i := {  union2 := {field1 := '1234'O},
12539             id := '0001'B,
12540             union3 := {field1 := '1110'B},
12541             union1 := { field1 := '1111'B},
12542             id2 := '0001'B
12543              }
12544
12545
12546 const octetstring   o :='1234E11F'O
12547
12548 <TTCN_TC:EXEC>
12549
12550 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12551 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12552
12553 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12554   else {setverdict(fail);}
12555
12556 <RESULT>
12557
12558 Overall verdict: pass
12559
12560 <END_TC>
12561
12562 :exmp.
12563
12564 .*---------------------------------------------------------------------*
12565 :h3. Raw update test 12
12566 .*---------------------------------------------------------------------*
12567 :xmp tab=0.
12568
12569 <TC-  Raw update test 12>
12570
12571 <STATIC>
12572
12573 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12574 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12575
12576 group RAW_group{
12577
12578 type union Code {
12579   integer field1,
12580   integer field2,
12581   integer field3
12582 } with { variant "FIELDLENGTH(8)"};
12583
12584 type record RAW_PDU{
12585   Code code,
12586   bitstring ABCxxxxx,
12587   integer PDU_length,
12588   octetstring id optional
12589   } with { variant (PDU_length) "FIELDLENGTH(16)";
12590            variant (ABCxxxxx) "FIELDLENGTH(8)";
12591            variant (id) "PRESENCE( {
12592               ABCxxxxx = '10000000'B,
12593               ABCxxxxx = '10100000'B} )";
12594            variant (code) "CROSSTAG(
12595              field1, id = omit;
12596              field2, id = '02'O;
12597              field3, id = '03'O; )"};
12598
12599 }with{encode "RAW"}
12600
12601 const RAW_PDU
12602     i := {  code := { field1 := 16},
12603             ABCxxxxx := '00000000'B,
12604             PDU_length := 16,
12605             id := omit }
12606
12607
12608 const octetstring   o :='10001000'O
12609
12610 <TTCN_TC:EXEC>
12611
12612 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12613 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12614
12615 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12616   else {setverdict(fail);}
12617
12618 <RESULT>
12619
12620 Overall verdict: pass
12621
12622 <END_TC>
12623
12624 :exmp.
12625
12626 .*---------------------------------------------------------------------*
12627 :h3. Raw update test 13
12628 .*---------------------------------------------------------------------*
12629 :xmp tab=0.
12630
12631 <TC-  Raw update test 13>
12632
12633 <STATIC>
12634
12635 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12636 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12637
12638 group RAW_group{
12639
12640 type union Code {
12641   integer field1,
12642   integer field2,
12643   integer field3
12644 } with { variant "FIELDLENGTH(8)"};
12645
12646 type record RAW_PDU{
12647   Code code,
12648   bitstring ABCxxxxx,
12649   integer PDU_length,
12650   octetstring id optional
12651   } with { variant (PDU_length) "FIELDLENGTH(16)";
12652            variant (ABCxxxxx) "FIELDLENGTH(8)";
12653            variant (id) "PRESENCE( {
12654               ABCxxxxx = '10000000'B,
12655               ABCxxxxx = '10100000'B} )";
12656            variant (code) "CROSSTAG(
12657              field1, id = omit;
12658              field2, id = '02'O;
12659              field3, id = '03'O; )"};
12660
12661 }with{encode "RAW"}
12662
12663 const RAW_PDU
12664     i := {  code := { field2 := 16},
12665             ABCxxxxx := '10000000'B,
12666             PDU_length := 16,
12667             id := '02'O }
12668
12669
12670 const octetstring   o :='1080100002'O
12671
12672 <TTCN_TC:EXEC>
12673
12674 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12675 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12676
12677 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12678   else {setverdict(fail);}
12679
12680 <RESULT>
12681
12682 Overall verdict: pass
12683
12684 <END_TC>
12685
12686 :exmp.
12687
12688 .*---------------------------------------------------------------------*
12689 :h3. Raw update test 14
12690 .*---------------------------------------------------------------------*
12691 :xmp tab=0.
12692
12693 <TC-  Raw update test 14>
12694
12695 <STATIC>
12696
12697 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12698 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12699
12700 group RAW_group{
12701
12702 type union Code {
12703   enumerated {e1a (0), e1b (1), e1c (2)} E1,
12704   enumerated {e2a (1), e2b (2), e2c (3)} E2,
12705   enumerated {e3a (2), e3b (3), e3c (4), e3d (5)} E3
12706 } with { variant (E1,E2,E3) "FIELDLENGTH(32)";
12707          variant (E1,E2,E3) "BYTEORDER(last)";
12708          variant (E1,E2,E3) "COMP(2scompl)"};
12709
12710 type integer UINT24 (0..16777215)
12711 with {variant "FIELDLENGTH(24)";
12712       variant "BYTEORDER(last)"};
12713
12714 type enumerated Identifier {
12715   id_E1 (0),
12716   id_E2 (1),
12717   id_E3 (2)
12718 } with {variant "FIELDLENGTH(32)";
12719         variant "BYTEORDER(last)";
12720         variant "COMP(2scompl)"};
12721
12722 type record RAW_PDU{
12723   Code code,
12724   bitstring ABCxxxxx,
12725   UINT24 PDU_length,
12726   Identifier id optional,
12727   octetstring payload optional
12728   } with { variant (ABCxxxxx) "FIELDLENGTH(8)";
12729            variant (id) "PRESENCE( {
12730               ABCxxxxx = '10000000'B,
12731               ABCxxxxx = '10100000'B} )";
12732            variant (code) "CROSSTAG(
12733              E1, id = omit;
12734              E2, id = id_E2;
12735              E3, id = id_E3; )";
12736             variant (PDU_length) "LENGTHTO(code,ABCxxxxx,PDU_length,id,payload)"};
12737
12738 }with{encode "RAW"}
12739
12740 const RAW_PDU
12741     i := {  code := {E1 := e1c},
12742             ABCxxxxx := '00000000'B,
12743             PDU_length := 8,
12744             id := omit,
12745             payload := omit}
12746
12747
12748 const octetstring   o :='0000000200000008'O ;
12749
12750 <TTCN_TC:EXEC>
12751
12752 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12753 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12754
12755 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12756   else {setverdict(fail);}
12757
12758 <RESULT>
12759
12760 Overall verdict: pass
12761
12762 <END_TC>
12763
12764 :exmp.
12765
12766 .*---------------------------------------------------------------------*
12767 :h3. Raw update test 15
12768 .*---------------------------------------------------------------------*
12769 :xmp tab=0.
12770
12771 <TC-  Raw update test 15>
12772
12773 <STATIC>
12774
12775 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12776 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12777
12778 group RAW_group{
12779
12780 type union Code {
12781   enumerated {e1a (0), e1b (1), e1c (2)} E1,
12782   enumerated {e2a (1), e2b (2), e2c (3)} E2,
12783   enumerated {e3a (2), e3b (3), e3c (4), e3d (5)} E3
12784 } with { variant (E1,E2,E3) "FIELDLENGTH(32)";
12785          variant (E1,E2,E3) "BYTEORDER(last)";
12786          variant (E1,E2,E3) "COMP(2scompl)"};
12787
12788 type integer UINT24 (0..16777215)
12789 with {variant "FIELDLENGTH(24)";
12790       variant "BYTEORDER(last)"};
12791
12792 type enumerated Identifier {
12793   id_E1 (0),
12794   id_E2 (1),
12795   id_E3 (2)
12796 } with {variant "FIELDLENGTH(32)";
12797         variant "BYTEORDER(last)";
12798         variant "COMP(2scompl)"};
12799
12800 type record RAW_PDU{
12801   Code code,
12802   bitstring ABCxxxxx,
12803   UINT24 PDU_length,
12804   Identifier id optional,
12805   octetstring payload optional
12806   } with { variant (ABCxxxxx) "FIELDLENGTH(8)";
12807            variant (id) "PRESENCE( {
12808               ABCxxxxx = '10000000'B,
12809               ABCxxxxx = '10100000'B} )";
12810            variant (code) "CROSSTAG(
12811              E1, id = omit;
12812              E2, id = id_E2;
12813              E3, id = id_E3; )";
12814             variant (PDU_length) "LENGTHTO(code,ABCxxxxx,PDU_length,id,payload)"};
12815
12816 }with{encode "RAW"}
12817
12818 const RAW_PDU
12819     i := {  code := {E2 := e2b},
12820             ABCxxxxx := '10000000'B,
12821             PDU_length := 14,
12822             id := id_E2,
12823             payload := 'ABCD'O}
12824
12825
12826 const octetstring   o :='000000028000000E00000001ABCD'O ;
12827
12828 <TTCN_TC:EXEC>
12829
12830 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12831 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12832
12833 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12834   else {setverdict(fail);}
12835
12836 <RESULT>
12837
12838 Overall verdict: pass
12839
12840 <END_TC>
12841
12842 :exmp.
12843
12844 .*---------------------------------------------------------------------*
12845 :h3. Raw update test 16
12846 .*---------------------------------------------------------------------*
12847 :xmp tab=0.
12848
12849 <TC-  Raw update test 16>
12850
12851 <STATIC>
12852
12853 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12854 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12855
12856 group RAW_group{
12857
12858 type union Code {
12859   enumerated {e1a (0), e1b (1), e1c (2)} E1,
12860   enumerated {e2a (1), e2b (2), e2c (3)} E2,
12861   enumerated {e3a (2), e3b (3), e3c (4), e3d (5)} E3
12862 } with { variant (E1,E2,E3) "FIELDLENGTH(32)";
12863          variant (E1,E2,E3) "BYTEORDER(last)";
12864          variant (E1,E2,E3) "COMP(2scompl)"};
12865
12866 type integer UINT24 (0..16777215)
12867 with {variant "FIELDLENGTH(24)";
12868       variant "BYTEORDER(last)"};
12869
12870 type enumerated Identifier {
12871   id_E1 (0),
12872   id_E2 (1),
12873   id_E3 (2)
12874 } with {variant "FIELDLENGTH(32)";
12875         variant "BYTEORDER(last)";
12876         variant "COMP(2scompl)"};
12877
12878 type record RAW_PDU{
12879   Code code,
12880   bitstring ABCxxxxx,
12881   UINT24 PDU_length,
12882   Identifier id optional,
12883   octetstring payload optional
12884   } with { variant (ABCxxxxx) "FIELDLENGTH(8)";
12885            variant (id) "PRESENCE( {
12886               ABCxxxxx = '10000000'B,
12887               ABCxxxxx = '10100000'B} )";
12888            variant (code) "CROSSTAG(
12889              E1, id = omit;
12890              E2, id = id_E2;
12891              E3, id = id_E3; )";
12892             variant (PDU_length) "LENGTHTO(code,ABCxxxxx,PDU_length,id,payload)"};
12893
12894 }with{encode "RAW"}
12895
12896 const RAW_PDU
12897     i := {  code := {E3 := e3b},
12898             ABCxxxxx := '10100000'B,
12899             PDU_length := 14,
12900             id := id_E3,
12901             payload := 'ABCD'O}
12902
12903
12904 const octetstring   o :='00000003A000000E00000002ABCD'O ;
12905
12906 <TTCN_TC:EXEC>
12907
12908 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12909 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12910
12911 if ((enc_RAW_PDU(i) == o )and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12912   else {setverdict(fail);}
12913
12914 <RESULT>
12915
12916 Overall verdict: pass
12917
12918 <END_TC>
12919
12920 :exmp.
12921
12922
12923 .*---------------------------------------------------------------------*
12924 :h3. group raw attribute test 1
12925 .*---------------------------------------------------------------------*
12926 :xmp tab=0.
12927
12928 <TC- group raw attribute test 1>
12929
12930 <STATIC>
12931
12932 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12933 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12934
12935 group RAW_group {
12936   type integer RAW_PDU
12937 } with { encode "RAW";
12938        variant "FIELDLENGTH(8)" ;
12939        variant "COMP( 2scompl ) "
12940      };
12941
12942 const RAW_PDU           i := -2
12943 const octetstring       o := 'FE'O
12944
12945 <TTCN_TC:EXEC>
12946
12947 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12948 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12949
12950 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12951   else {setverdict(fail);}
12952
12953 <RESULT>
12954
12955 Overall verdict: pass
12956
12957 <END_TC>
12958
12959 :exmp.
12960
12961 .*---------------------------------------------------------------------*
12962 :h3. group raw attribute test 2
12963 .*---------------------------------------------------------------------*
12964 :xmp tab=0.
12965
12966 <TC- group raw attribute test 2>
12967
12968 <STATIC>
12969
12970 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
12971 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
12972
12973 type integer RAW_PDU
12974 with {  encode "RAW";
12975         variant  "BITORDERINOCTET(msb)";
12976         variant  "BYTEORDER(last)";
12977         variant  "ALIGN(left)";
12978         variant  "BITORDERINFIELD(msb)";
12979         variant  "COMP(signbit)";
12980         variant  "FIELDLENGTH(20)" };
12981
12982 const RAW_PDU           i := -234
12983 const octetstring       o := 'EA0008'O
12984
12985 <TTCN_TC:EXEC>
12986
12987 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
12988 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
12989
12990 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
12991   else {setverdict(fail);}
12992
12993 <RESULT>
12994
12995 Overall verdict: pass
12996
12997 <END_TC>
12998
12999 :exmp.
13000
13001
13002
13003 .*---------------------------------------------------------------------*
13004 :h3. group raw attribute test 3
13005 .*---------------------------------------------------------------------*
13006 :xmp tab=0.
13007
13008 <TC- group raw attribute test 3>
13009
13010 <STATIC>
13011
13012 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
13013 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
13014
13015 group RAW_group {
13016   group grp_v1 {
13017     group grp_v2 {
13018       group grp_v3 {
13019         group grp_v4 {
13020           group grp_v5 {
13021             group grp_v6 {
13022               type integer RAW_PDU
13023             } with { variant "BITORDERINOCTET(msb)" }
13024           } with { variant "BYTEORDER(last)" }
13025         } with { variant "ALIGN(left)" }
13026       } with { variant "BITORDERINFIELD(msb)" }
13027     } with { variant "COMP(signbit)" }
13028   } with { variant "FIELDLENGTH(20)" }
13029 } with { encode "RAW" }
13030
13031 const RAW_PDU           i := -234
13032 const octetstring       o := 'EA0008'O
13033
13034 <TTCN_TC:EXEC>
13035
13036 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
13037 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
13038
13039 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
13040   else {setverdict(fail);}
13041
13042 <RESULT>
13043
13044 Overall verdict: pass
13045
13046 <END_TC>
13047
13048 :exmp.
13049
13050 .*---------------------------------------------------------------------*
13051 :h3. group raw attribute test 4
13052 .*---------------------------------------------------------------------*
13053 :xmp tab=0.
13054
13055 <TC- group raw attribute test 4>
13056
13057 <STATIC>
13058
13059 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
13060 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
13061
13062 group RAW_group {
13063   group grp_v1 {
13064     group grp_v2 {
13065       group grp_v3 {
13066         group grp_v4 {
13067           group grp_v5 {
13068             group grp_v6 {
13069               type integer RAW_PDU
13070               with { variant "" }
13071             } with { variant "FIELDLENGTH(20)"; variant "COMP(signbit)" }
13072           } with { variant "BITORDERINFIELD(msb)"; variant "ALIGN(left)" }
13073         } with { variant "BITORDERINOCTET(msb)"; variant "BYTEORDER(last)" }
13074       } with { variant "BITORDERINOCTET(lsb)"; variant "BYTEORDER(first)" }
13075     } with { variant "FIELDLENGTH(10)"; variant "COMP(2scompl)" }
13076   } with { variant "BITORDERINFIELD(lsb)"; variant "ALIGN(right)" }
13077
13078 } with { encode "RAW" }
13079
13080 const RAW_PDU           i := -234
13081 const octetstring       o := 'EA0008'O
13082
13083 <TTCN_TC:EXEC>
13084
13085 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
13086 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
13087
13088 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
13089   else {setverdict(fail);}
13090
13091 <RESULT>
13092
13093 Overall verdict: pass
13094
13095 <END_TC>
13096
13097
13098 .*---------------------------------------------------------------------*
13099 :h3. group raw attribute test 5
13100 .*---------------------------------------------------------------------*
13101 :xmp tab=0.
13102
13103 <TC- group raw attribute test 5>
13104
13105 <STATIC>
13106
13107 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
13108 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
13109
13110 group RAW_group {
13111   group grp_v1 {
13112     group grp_v2 {
13113       group grp_v3 {
13114         type integer RAW_PDU
13115         with { encode "RAW"; variant "" }
13116       } with { encode "RAW"; variant "FIELDLENGTH(20)"; variant "COMP(signbit)" }
13117     } with { encode "RAW"; variant "BITORDERINFIELD(msb)"; variant "ALIGN(left)" }
13118   } with { encode "RAW"; variant "BITORDERINOCTET(msb)"; variant "BYTEORDER(last)" }
13119 } with { encode "RAW" }
13120
13121 const RAW_PDU           i := -234
13122 const octetstring       o := 'EA0008'O
13123
13124 <TTCN_TC:EXEC>
13125
13126 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
13127 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
13128
13129 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
13130   else {setverdict(fail);}
13131
13132 <RESULT>
13133
13134 Overall verdict: pass
13135
13136 <END_TC>
13137
13138 :exmp.
13139
13140 .*---------------------------------------------------------------------*
13141 :h3. group raw attribute test 6
13142 .*---------------------------------------------------------------------*
13143 :xmp tab=0.
13144
13145 <TC- group raw attribute test 6>
13146
13147 <STATIC>
13148
13149 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
13150 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
13151
13152 group RAW_group {
13153   group grp_v1 {
13154     group grp_v2 {
13155       group grp_v3 {
13156         type integer RAW_PDU
13157         with { variant "" }
13158       } with { variant override "FIELDLENGTH(32)"  }
13159     } with { variant "FIELDLENGTH(10)" }
13160   } with { variant override "FIELDLENGTH(8)"; variant "FIELDLENGTH(2)" }
13161 } with { encode "RAW" }
13162
13163 const RAW_PDU           i := 255
13164 const octetstring       o := 'FF'O
13165
13166 <TTCN_TC:EXEC>
13167
13168 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
13169 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
13170
13171 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
13172   else {setverdict(fail);}
13173
13174 <RESULT>
13175
13176 Overall verdict: pass
13177
13178 <END_TC>
13179
13180 :exmp.
13181
13182 .*---------------------------------------------------------------------*
13183 :h3. group raw attribute test 7
13184 .*---------------------------------------------------------------------*
13185 :xmp tab=0.
13186
13187 <TC- group raw attribute test 7>
13188
13189 <STATIC>
13190
13191 external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
13192 external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
13193
13194 group RAW_group{
13195   group grp1 {
13196     type record RAW_PDU
13197     { integer   int1 ,
13198       integer   int2 ,
13199       integer   int3 ,
13200       integer   int4   }
13201      with { variant (int1,int2,int3,int4) "FIELDLENGTH(4)";
13202             variant (int1,int2) "PADDING(yes)";
13203             variant (int3,int4) "PADDING(no)"; }
13204   } with { variant "FIELDLENGTH(3)" }
13205 } with {encode "RAW" };
13206
13207
13208 const RAW_PDU
13209         i := {  int1 :=    1  ,
13210                 int2 :=    2  ,
13211                 int3 :=    3  ,
13212                 int4 :=    4       }
13213
13214 const octetstring       o := '010243'O
13215
13216 <TTCN_TC:EXEC>
13217
13218 log ("enc_RAW_PDU(i)=     "  , enc_RAW_PDU(i)) ;
13219 log ("dec_RAW_PDU(o)=     "  , dec_RAW_PDU(o)) ;
13220
13221 if ((enc_RAW_PDU(i) == o)and(dec_RAW_PDU(o) == i)) {setverdict(pass);}
13222   else {setverdict(fail);}
13223
13224 <RESULT>
13225
13226 Overall verdict: pass
13227
13228 <END_TC>
13229
13230 :exmp.
13231
13232 .*---------------------------------------------------------------------*
13233 :h2.Testing Enc/Dec functions of implicit message encoding
13234 .*---------------------------------------------------------------------*
13235 .*---------------------------------------------------------------------*
13236 :h3.  Fast enc/dec function
13237 .*---------------------------------------------------------------------*
13238 :xmp tab=0.
13239
13240 <TC- Implicit message encoding: prototype fast>
13241
13242 <STATIC>
13243
13244 external function enc_RAW_PDU(in RAW_PDU pdu, out octetstring stream) with { extension "prototype(fast) encode(RAW)" }
13245 external function dec_RAW_PDU(in octetstring stream, out RAW_PDU pdu) with { extension "prototype(fast) decode(RAW)" }
13246 type integer RAW_PDU with { encode "RAW"; variant "FIELDLENGTH(16)" };
13247
13248 const RAW_PDU           i := 255
13249 const octetstring       o := 'FF00'O
13250
13251 <TTCN_TC:EXEC>
13252
13253 var octetstring encoded_pdu;
13254 var RAW_PDU decoded_pdu;
13255
13256 enc_RAW_PDU(i, encoded_pdu);
13257 dec_RAW_PDU(o, decoded_pdu);
13258
13259 if ( encoded_pdu == o and decoded_pdu == i ) {setverdict(pass);}
13260 else {setverdict(fail);}
13261
13262 <RESULT>
13263
13264 Overall verdict: pass
13265
13266 <END_TC>
13267
13268 :exmp.
13269
13270 .*---------------------------------------------------------------------*
13271 :h3. Backtrack decode function
13272 .*---------------------------------------------------------------------*
13273 :xmp tab=0.
13274
13275 <TC- Implicit message encoding: prototype backtrack>
13276
13277 <STATIC>
13278
13279 external function dec_RAW_PDU(in octetstring stream, out RAW_PDU pdu) return integer
13280   with { extension "prototype(backtrack) decode(RAW) errorbehavior(ALL:WARNING)" }
13281
13282 type integer RAW_PDU with { encode "RAW"; variant "FIELDLENGTH(16)" };
13283
13284 const RAW_PDU           i := 255
13285 const octetstring o1 := 'FF00'O
13286 const octetstring o2 := '12'O
13287
13288 <TTCN_TC:EXEC>
13289
13290 var RAW_PDU decoded_pdu;
13291 var integer ret_val;
13292
13293 ret_val := dec_RAW_PDU(o1, decoded_pdu);
13294 if (ret_val==0 and decoded_pdu==i) {setverdict(pass);}
13295 else {setverdict(fail);}
13296
13297 ret_val := dec_RAW_PDU(o2, decoded_pdu);
13298 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
13299
13300 <RESULT>
13301
13302 Overall verdict: pass
13303
13304 <END_TC>
13305
13306 :exmp.
13307
13308 .*---------------------------------------------------------------------*
13309 :h3. Sliding decode function
13310 .*---------------------------------------------------------------------*
13311 :xmp tab=0.
13312
13313 <TC- Implicit message encoding: prototype sliding>
13314
13315 <STATIC>
13316
13317 external function dec_RAW_PDU(inout octetstring stream, out RAW_PDU pdu) return integer
13318   with { extension "prototype(sliding) decode(RAW) errorbehavior(ALL:WARNING)" }
13319
13320 type integer RAW_PDU with { encode "RAW"; variant "FIELDLENGTH(16)" };
13321
13322 const RAW_PDU           i := 255
13323
13324 <TTCN_TC:EXEC>
13325
13326 var octetstring o1 := 'FF00'O;
13327 var octetstring o2 := '12'O;
13328 var RAW_PDU decoded_pdu;
13329 var integer ret_val;
13330
13331 ret_val := dec_RAW_PDU(o1, decoded_pdu);
13332 if (ret_val==0 and decoded_pdu==i) {setverdict(pass);}
13333 else {setverdict(fail);}
13334
13335 ret_val := dec_RAW_PDU(o2, decoded_pdu);
13336 if (ret_val>0) {setverdict(pass);} else {setverdict(fail);}
13337
13338 <RESULT>
13339
13340 Overall verdict: pass
13341
13342 <END_TC>
13343
13344 :exmp.
13345
13346
13347 .*---------------------------------------------------------------------*
13348 :h2. Testing limits of codec
13349 .*---------------------------------------------------------------------*
13350 .*---------------------------------------------------------------------*
13351 :h3. Decoding empty octetstring to PDU
13352 .*---------------------------------------------------------------------*
13353 :xmp tab=0.
13354
13355 <TC- Decoding empty octetstring to PDU>
13356
13357 <STATIC>
13358
13359 type record PDU {
13360   integer f1,
13361   octetstring f2,
13362   boolean f3
13363 } with { encode "RAW" variant "" }
13364
13365 external function decodePDU(inout octetstring os, out PDU pdu) return integer
13366 with { extension "prototype(sliding) decode(RAW) errorbehavior(ALL:WARNING)" }
13367
13368 <TTCN_TC:EXEC>
13369
13370 var octetstring os := ''O;
13371 var PDU pdu;
13372 var integer ret_val := decodePDU(os, pdu);
13373 if (ret_val>0) {setverdict(pass);} else {setverdict(fail);}
13374
13375 <RESULT>
13376
13377 Overall verdict: pass
13378
13379 <END_TC>
13380
13381 :exmp.
13382
13383 .*---------------------------------------------------------------------*
13384 :h2. Testing encoding/decoding of big integers
13385 .*---------------------------------------------------------------------*
13386 .*---------------------------------------------------------------------*
13387 :h3. Encoding/decoding big integer variables
13388 .*---------------------------------------------------------------------*
13389 :xmp tab=0.
13390
13391 <TC- Big integers: Encoding/decoding big integer variables>
13392
13393 <STATIC>
13394
13395 external function enc_raw3(in myint3 r) return octetstring
13396   with { extension "encode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
13397 external function dec_raw3(in octetstring r) return myint3
13398   with { extension "decode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
13399 external function enc_raw2(in myint2 r) return octetstring
13400   with { extension "encode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
13401 external function dec_raw2(in octetstring r) return myint2
13402   with { extension "decode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
13403
13404 type integer myint2
13405 with {
13406   variant "FIELDLENGTH(128)"
13407   variant "COMP(nosign)"
13408   variant "BITORDERINFIELD(lsb)"
13409   variant "PADDING(dword32)"
13410   encode "RAW" }
13411
13412 type integer myint3
13413 with {
13414   variant "FIELDLENGTH(96)"
13415   variant "COMP(signbit)"
13416   variant "BITORDERINFIELD(lsb)"
13417   variant "PADDING(dword32)"
13418   encode "RAW" }
13419
13420 <TTCN_TC:EXEC>
13421
13422   var myint3 v1 := -4294967296
13423   var myint3 v2 := -2147483647
13424   var myint3 v3 := 34359738368
13425   var myint3 v4 := 4398046511104
13426   var myint3 v5 := -140737488355328
13427   var myint3 v6 := 4294967296
13428   var myint3 v7 := 4294967295
13429   var myint3 v8 := -4294967295
13430   var myint3 v9 := 4294967297
13431   var myint3 v10 := -4294967297
13432   var myint3 v11 := 2147483647
13433   var myint3 v12 := -2147483648
13434   var myint3 v13 := 2147483648
13435   var myint3 v14 := -2147483649
13436   var myint3 v15 := 2147483649
13437   var myint2 v16 := -4294967296
13438   var myint2 v17 := 2147483647
13439   var myint2 v18 := 34359738368
13440   var myint2 v19 := 4398046511104
13441   var octetstring o
13442   o := enc_raw3(v1);if (v1 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13443   o := enc_raw3(v2);if (v2 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13444   o := enc_raw3(v3);if (v3 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13445   o := enc_raw3(v4);if (v4 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13446   o := enc_raw3(-140737488355328);if (v5 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13447   o := enc_raw3(v6);if (v6 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13448   o := enc_raw3(v7);if (v7 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13449   o := enc_raw3(v8);if (v8 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13450   o := enc_raw3(v9);if (v9 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13451   o := enc_raw3(v10);if (v10 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13452   o := enc_raw3(v11);if (v11 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13453   o := enc_raw3(v12);if (v12 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13454   o := enc_raw3(v13);if (v13 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13455   o := enc_raw3(v14);if (v14 == dec_raw3(o)) {setverdict(pass)} else {setverdict(fail)}
13456
13457 <RESULT>
13458
13459 Overall verdict: pass
13460
13461 <END_TC>
13462
13463 :exmp.
13464
13465 .*---------------------------------------------------------------------*
13466 :h3. Encoding/decoding records with big integer fields
13467 .*---------------------------------------------------------------------*
13468 :xmp tab=0.
13469
13470 <TC- Big integers: Encoding/decoding records with big integer fields>
13471
13472 <STATIC>
13473
13474 external function enc_raw(in rec_raw1 r) return octetstring
13475   with { extension "encode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
13476 external function dec_raw(in octetstring r) return rec_raw1
13477   with { extension "decode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
13478
13479 type integer myint1
13480 with {
13481   variant "FIELDLENGTH(256)"
13482   variant "COMP(2scompl)"
13483   variant "BITORDERINFIELD(lsb)"
13484   variant "PADDING(dword32)"
13485   encode "RAW" } // The script eats the trailing '}' in a new line.
13486
13487 type record rec_raw1 {
13488   myint1 int1,
13489   myint1 int2
13490 } with { variant "" encode "RAW" }
13491
13492 <TTCN_TC:EXEC>
13493
13494   var rec_raw1 myrec1 := {int1 := -12345678910111213141516, int2 := -3}
13495   var rec_raw1 myrec2 := {int1 := -11111111111111111111111, int2 := -11111111111111111111111}
13496   var rec_raw1 myrec3 := {int1 := -2147483648, int2 := -4294967296}
13497   var rec_raw1 myrec4 := {int1 := 2147483648, int2 := -4294967296}
13498   var rec_raw1 myrec5 := {int1 := -2147483649, int2 := 2147483649}
13499   var rec_raw1 myrec6 := {int1 := -1234, int2 := -4321}
13500   var octetstring o
13501   o := enc_raw(myrec1);if (myrec1 == dec_raw(o)) {setverdict(pass)} else {setverdict(fail)}
13502   o := enc_raw(myrec2);if (myrec2 == dec_raw(o)) {setverdict(pass)} else {setverdict(fail)}
13503   o := enc_raw(myrec3);if (myrec3 == dec_raw(o)) {setverdict(pass)} else {setverdict(fail)}
13504   o := enc_raw(myrec4);if (myrec4 == dec_raw(o)) {setverdict(pass)} else {setverdict(fail)}
13505   o := enc_raw(myrec5);if (myrec5 == dec_raw(o)) {setverdict(pass)} else {setverdict(fail)}
13506   o := enc_raw(myrec6);if (myrec6 == dec_raw(o)) {setverdict(pass)} else {setverdict(fail)}
13507
13508 <RESULT>
13509
13510 Overall verdict: pass
13511
13512 <END_TC>
13513
13514 :exmp.
13515
13516 .*---------------------------------------------------------------------*
13517 :h3. Multiple optional fields (R8G FOA bug)
13518 .*---------------------------------------------------------------------*
13519 :xmp tab=0.
13520
13521 <TC- Multiple optional fields (R8G FOA bug)>
13522
13523 <STATIC>
13524
13525 external function enc_PDU_GTPCv2(in PDU_GTPCv2 pdu) return octetstring
13526 with { extension "prototype(convert)" extension "encode(RAW)" }
13527
13528 external function dec_PDU_GTPCv2(in octetstring stream) return PDU_GTPCv2
13529 with { extension "prototype(convert)" extension "decode(RAW)" }
13530
13531 type bitstring BIT3 length(3) with { encode "RAW"  variant "FIELDLENGTH(3)" };
13532 type bitstring BIT4 length(4) with { encode "RAW"  variant "FIELDLENGTH(4)" };
13533 type bitstring BIT5 length(5) with { encode "RAW"  variant "FIELDLENGTH(5)" };
13534 type bitstring BIT1 length(1) with { encode "RAW"  variant "FIELDLENGTH(1)" };
13535 type octetstring OCT1 length(1) with { encode "RAW"  variant "FIELDLENGTH(1)" };
13536 type octetstring OCT2 length(2) with { encode "RAW"  variant "FIELDLENGTH(2)" };
13537 type octetstring OCT3 length(3) with { encode "RAW"  variant "FIELDLENGTH(3)" };
13538 type octetstring OCT4 length(4) with { encode "RAW"  variant "FIELDLENGTH(4)" };
13539 type integer LIN1 (0..255) with { encode "RAW"  variant "FIELDLENGTH(8)" };
13540
13541 type integer LIN2_BO_LAST (0..65535) with { encode "RAW"  variant "FIELDLENGTH(16), COMP(nosign), BYTEORDER(last)" };
13542
13543 type record Cause {
13544     OCT1              elementIdentifier, //dec 2, '02'O
13545     LIN2_BO_LAST      lengthIndicator,
13546     BIT4              instance,
13547     BIT4              spare,
13548     OCT1              causeValue,
13549     BIT1              cS,
13550     BIT1              bCE,
13551     BIT1              pCE,
13552     BIT5              spare2,
13553     OCT1              typeOfOffendingIE optional,
13554     LIN2_BO_LAST      lengthIndicator2 optional,
13555     BIT4              instanceOfOffendingIE optional,
13556     BIT4              spare3 optional
13557 } with { encode "RAW"
13558     variant "PRESENCE (elementIdentifier = '02'O; )"
13559     variant (lengthIndicator) "LENGTHTO(causeValue,cS,bCE,pCE,spare2,typeOfOffendingIE,
13560     lengthIndicator2,instanceOfOffendingIE,spare3 )" };
13561
13562 type record Recovery {
13563     OCT1              elementIdentifier,  // dec 3, '03'O
13564     LIN2_BO_LAST      lengthIndicator,
13565     BIT4              instance,
13566     BIT4              spare,
13567     integer           recoveryValue
13568 } with { encode "RAW"
13569     variant (lengthIndicator) "LENGTHTO(recoveryValue)"
13570     variant "PRESENCE (elementIdentifier = '03'O; )" };
13571
13572 type set of  ProtocolID_or_ContainerID   ProtocolIDs_and_ContainerIDs;
13573
13574 type record ProtocolID_or_ContainerID {
13575     OCT2               protocolID_or_ContainerID,
13576     LIN1               lengthIndicator,
13577     octetstring        protID_orContID_Contents
13578 } with { encode "RAW"
13579     variant (lengthIndicator) "LENGTHTO (protID_orContID_Contents)"};
13580
13581 type record ProtocolConfigOptions {
13582     OCT1                         elementIdentifier, // dec 78 '4E'O;
13583     LIN2_BO_LAST                 lengthIndicator,
13584     BIT4                         instance,
13585     BIT4                         spare,
13586     BIT3                         configProtocol,
13587     BIT4                         spare2,  //'0000'B
13588     BIT1                         extensionField,   //'1'B
13589     ProtocolIDs_and_ContainerIDs protocolIDs_and_ContainerIDs optional
13590 } with { encode "RAW"
13591     variant (lengthIndicator) "LENGTHTO(configProtocol,spare2,extensionField,protocolIDs_and_ContainerIDs)"
13592     variant "PRESENCE (elementIdentifier = '4E'O; )" };
13593
13594 type record PrivateExtension {
13595     OCT1                         elementIdentifier, // dec 255, 'FF'O
13596     LIN2_BO_LAST                 lengthIndicator,
13597     BIT4                         instance,
13598     BIT4                         spare,
13599     integer                      enterpriseID,
13600     octetstring                  proprietartyValue
13601 }  with { encode "RAW"
13602     variant (lengthIndicator) "LENGTHTO(enterpriseID,proprietartyValue)";
13603     variant "PRESENCE (elementIdentifier = 'FF'O;)"; };
13604
13605 type set DeleteSessionResponse {
13606     Cause                                   cause,
13607     Recovery                                recovery optional,
13608     ProtocolConfigOptions                   protocolConfigOptions optional,
13609     PrivateExtension                        privateExtension optional };
13610
13611 type union GTPCv2_PDUs {
13612     DeleteSessionResponse                        deleteSessionResponse };
13613
13614 type record PDU_GTPCv2 {
13615     BIT3                           spare,   //0
13616     BIT1                           t_Bit,
13617     BIT1                           p_Bit,
13618     BIT3                           version,  //'010'B
13619     OCT1                           messageType,
13620     LIN2_BO_LAST                   lengthf,
13621     OCT4                           tEID optional,
13622     OCT3                           sequenceNumber,
13623     OCT1                           spare3, // 0
13624     GTPCv2_PDUs                    gtpcv2_pdu,
13625     PDU_GTPCv2                     piggybackPDU_GTPCv2 optional
13626 }  with { encode "RAW"
13627     variant (tEID) "PRESENCE(t_Bit = '1'B)";
13628     variant (piggybackPDU_GTPCv2) "PRESENCE(p_Bit = '1'B)";
13629     variant (lengthf) "LENGTHTO(tEID,sequenceNumber,spare3,gtpcv2_pdu)";
13630     variant (gtpcv2_pdu) "CROSSTAG(
13631     deleteSessionResponse,                             messageType = '25'O;  //37
13632     )"; };
13633
13634 <TTCN_TC:EXEC>
13635
13636   var PDU_GTPCv2 vl_temp := dec_PDU_GTPCv2( '48250013800000000249BF000200020010000300010011'O );
13637   setverdict(pass);
13638
13639 <RESULT>
13640
13641 Overall verdict: pass
13642
13643 <END_TC>
13644
13645 :exmp.
13646
13647 .*---------------------------------------------------------------------*
13648 :h3. HO79315: Segfault on unbound octetstring
13649 .*---------------------------------------------------------------------*
13650 :xmp tab=0.
13651
13652 <TC- HO79315: Segfault on unbound octetstring>
13653
13654 <STATIC>
13655
13656 type octetstring raw_pdu_octetstring with { encode "RAW"; variant "FIELDLENGTH(1)"};
13657 external function enc_raw_pdu_octetstring(in raw_pdu_octetstring pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
13658 external function dec_raw_pdu_octetstring(in octetstring stream) return raw_pdu_octetstring with { extension "prototype(convert) decode(RAW)" }
13659
13660 <TTCN_TC:EXEC>
13661
13662   var raw_pdu_octetstring i
13663   const octetstring o := '0F'O
13664   if ((enc_raw_pdu_octetstring(i) == o)and(dec_raw_pdu_octetstring(o) == i)) {setverdict(pass);}
13665   else {setverdict(fail,"enc_raw_pdu_octetstring(i)= ", enc_raw_pdu_octetstring(i), "; dec_raw_pdu_octetstring(o)= ", dec_raw_pdu_octetstring(o));}
13666
13667 <RESULT>
13668
13669 Overall verdict: error
13670
13671 <END_TC>
13672
13673 :exmp.
13674
13675 .*---------------------------------------------------------------------*
13676 :h1.REFERENCES
13677 .*---------------------------------------------------------------------*
13678 :nl. Requirement specification(s):
13679 :nl.-------------------------------
13680 :list.
13681 :li. 8/ETH/RUS-2003:0087 Uen - Requirement Specification for TITAN's encoder/decoder functions
13682 :elist.
13683
13684 :etext.