function_test/Text_EncDec/TEXT_1_TD.fast_script

   1 .******************************************************************************
   2 .* Copyright (c) 2000-2014 Ericsson Telecom AB
   3 .* All rights reserved. This program and the accompanying materials
   4 .* are made available under the terms of the Eclipse Public License v1.0
   5 .* which accompanies this distribution, and is available at
   6 .* http://www.eclipse.org/legal/epl-v10.html
   7 .******************************************************************************/
   8 :text.
   9 :lang eng.
  10 .*
  11 :docname.Test Description
  12 :docno.21/152 91-CRL 113 200/2 Uen
  13 :rev.A
  14 :date.2012-06-27
  15 .*
  16 :prep.ETH/XZR Ferenc Kovacs (+36 1 439 5511)
  17 :appr.ETH/XZ (Roland Gecse)
  18 :checked.ETHPKR
  19 .*
  20 :title.Test Description - Text based coding for TTCN-3 Test Executor
  21 :contents level=3.
  22 .*---------------------------------------------------------------------*
  23 :h1.PREREQUISITES AND PREPARATIONS
  24 .*---------------------------------------------------------------------*
  25 .*---------------------------------------------------------------------*
  26 :h2.Scope of the Test Object
  27 .*---------------------------------------------------------------------*
  28 :xmp tab=1 nokeep.
  29 This TD contains unified test cases related to a part of TTCN3 Executor's Text coder function.
  30 The original test cases can be found in the TEXT_1_TD.script file.
  31 The reason for the unification was to get a really fast version of the tests.
  32
  33 :exmp.
  34
  35 :p.:us.Revision Information:eus.
  36
  37 :xmp nokeep.
  38 :us.History:eus.
  39
  40 REV   DATE         PREPARED   CHANGE
  41 ===   ==========   ========   ======
  42 A     2005-01-10   ETHGHASZ   New document
  43 B     2005-10-11   EKRISZA    Updated for group support.
  44 C     2007-03-06   EDMDELI    Implicit message encoding
  45 D     2008-10-01   EFERKOV    Big integers
  46 E     2011-01-24   EKRISZA     Restructured to use more efficient script.
  47 F     2011-10-10   EKRISZA     Updated for release.
  48 A     2011-12-12   EKRISZA     Updated for release
  49 PB1   2012-01-31   ETHBAAT     Editorial changes,
  50 :exmp.
  51
  52 .*---------------------------------------------------------------------*
  53 :h1.Test environment
  54 .*---------------------------------------------------------------------*
  55 .*---------------------------------------------------------------------*
  56 :h2.Hardware
  57 .*---------------------------------------------------------------------*
  58 No specific hardware requirement.
  59 .*---------------------------------------------------------------------*
  60 :h2.Software
  61 .*---------------------------------------------------------------------*
  62
  63 .*---------------------------------------------------------------------*
  64 :h2.Configuration
  65 .*---------------------------------------------------------------------*
  66
  67 .*---------------------------------------------------------------------*
  68 :h2.Installation
  69 .*---------------------------------------------------------------------*
  70 .*---------------------------------------------------------------------*
  71 :h2.Test Tools
  72 .*---------------------------------------------------------------------*
  73 .*---------------------------------------------------------------------*
  74 :h1.REQUIREMENT-BASED TESTS
  75 .*---------------------------------------------------------------------*
  76 :xmp tab=0.
  77
  78 <TC -  Fixed length encoding>
  79
  80 <STATIC>
  81 type component TempComp {}
  82 <TTCN_TC:PURE_EXEC>
  83
  84 type charstring TEXT_PDU_1 with { encode "TEXT"; variant "TEXT_CODING(length=5)"};
  85 external function enc_TEXT_PDU_1(in TEXT_PDU_1 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
  86 external function dec_TEXT_PDU_1(in charstring oct) return TEXT_PDU_1 with { extension "prototype(convert) decode(TEXT)" }
  87
  88 testcase TC_Fixed_length_encoding() runs on TempComp {
  89   const TEXT_PDU_1      i := "HALI"
  90   const charstring      o := " HALI"
  91   const TEXT_PDU_1  expected_res:=" HALI"
  92
  93   if ((enc_TEXT_PDU_1(i) == o)and(dec_TEXT_PDU_1(o) == expected_res)) {setverdict(pass);}
  94   else {setverdict(fail,"enc_TEXT_PDU_1(i)= ", enc_TEXT_PDU_1(i), "; dec_TEXT_PDU_1(o)= ", dec_TEXT_PDU_1(o));}
  95 }
  96
  97
  98
  99 type charstring TEXT_PDU_2 with { encode "TEXT"; variant "TEXT_CODING(convert=lower_case)"};
 100 external function enc_TEXT_PDU_2(in TEXT_PDU_2 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 101 external function dec_TEXT_PDU_2(in charstring oct) return TEXT_PDU_2 with { extension "prototype(convert) decode(TEXT)" }
 102
 103 testcase TC_Convert_string_to_lower_case_during_encoding() runs on TempComp {
 104   const TEXT_PDU_2      i := "HALI"
 105   const charstring      o := "hali"
 106   const TEXT_PDU_2  expected_res:="hali"
 107
 108   if ((enc_TEXT_PDU_2(i) == o)and(dec_TEXT_PDU_2(o) == expected_res)) {setverdict(pass);}
 109   else {setverdict(fail,"enc_TEXT_PDU_2(i)= ", enc_TEXT_PDU_2(i), "; dec_TEXT_PDU_2(o)= ", dec_TEXT_PDU_2(o));}
 110 }
 111
 112
 113
 114 type charstring TEXT_PDU_3 with { encode "TEXT"; variant "TEXT_CODING(convert=upper_case)"};
 115 external function enc_TEXT_PDU_3(in TEXT_PDU_3 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 116 external function dec_TEXT_PDU_3(in charstring oct) return TEXT_PDU_3 with { extension "prototype(convert) decode(TEXT)" }
 117
 118 testcase TC_Convert_string_to_upper_case_during_encoding() runs on TempComp {
 119   const TEXT_PDU_3      i := "hali"
 120   const charstring      o := "HALI"
 121   const TEXT_PDU_3  expected_res:="HALI"
 122
 123   if ((enc_TEXT_PDU_3(i) == o)and(dec_TEXT_PDU_3(o) == expected_res)) {setverdict(pass);}
 124   else {setverdict(fail,"enc_TEXT_PDU_3(i)= ", enc_TEXT_PDU_3(i), "; dec_TEXT_PDU_3(o)= ", dec_TEXT_PDU_3(o));}
 125 }
 126
 127
 128
 129 type charstring TEXT_PDU_4 with { encode "TEXT"; variant "TEXT_CODING(convert=lower_case,
 130                                                      convert=upper_case)"};
 131 external function enc_TEXT_PDU_4(in TEXT_PDU_4 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 132 external function dec_TEXT_PDU_4(in charstring oct) return TEXT_PDU_4 with { extension "prototype(convert) decode(TEXT)" }
 133
 134 testcase TC_Convert_string_to_lower_case_during_encoding_and_upper_during_decoding() runs on TempComp {
 135   const TEXT_PDU_4      i := "HALI"
 136   const charstring      o := "hali"
 137   const TEXT_PDU_4  expected_res:="HALI"
 138
 139   if ((enc_TEXT_PDU_4(i) == o)and(dec_TEXT_PDU_4(o) == expected_res)) {setverdict(pass);}
 140   else {setverdict(fail,"enc_TEXT_PDU_4(i)= ", enc_TEXT_PDU_4(i), "; dec_TEXT_PDU_4(o)= ", dec_TEXT_PDU_4(o));}
 141 }
 142
 143
 144
 145 type charstring TEXT_PDU_5 with { encode "TEXT"; variant "TEXT_CODING(convert=upper_case,
 146                                                      convert=lower_case)"};
 147 external function enc_TEXT_PDU_5(in TEXT_PDU_5 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 148 external function dec_TEXT_PDU_5(in charstring oct) return TEXT_PDU_5 with { extension "prototype(convert) decode(TEXT)" }
 149
 150 testcase TC_Convert_string_to_upper_case_during_encoding_and_lower_during_decoding() runs on TempComp {
 151   const TEXT_PDU_5      i := "hali"
 152   const charstring      o := "HALI"
 153   const TEXT_PDU_5  expected_res:="hali"
 154
 155   if ((enc_TEXT_PDU_5(i) == o)and(dec_TEXT_PDU_5(o) == expected_res)) {setverdict(pass);}
 156   else {setverdict(fail,"enc_TEXT_PDU_5(i)= ", enc_TEXT_PDU_5(i), "; dec_TEXT_PDU_5(o)= ", dec_TEXT_PDU_5(o));}
 157 }
 158
 159
 160
 161 type charstring TEXT_PDU_6 with { encode "TEXT"; variant "TEXT_CODING(just=left;length=5)"};
 162 external function enc_TEXT_PDU_6(in TEXT_PDU_6 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 163 external function dec_TEXT_PDU_6(in charstring oct) return TEXT_PDU_6 with { extension "prototype(convert) decode(TEXT)" }
 164
 165 testcase TC_Left_justification() runs on TempComp {
 166   const TEXT_PDU_6      i := "hali"
 167   const charstring      o := "hali "
 168   const TEXT_PDU_6  expected_res:="hali "
 169
 170   if ((enc_TEXT_PDU_6(i) == o)and(dec_TEXT_PDU_6(o) == expected_res)) {setverdict(pass);}
 171   else {setverdict(fail,"enc_TEXT_PDU_6(i)= ", enc_TEXT_PDU_6(i), "; dec_TEXT_PDU_6(o)= ", dec_TEXT_PDU_6(o));}
 172 }
 173
 174
 175
 176 type charstring TEXT_PDU_7 with { encode "TEXT"; variant "TEXT_CODING(just=center;length=6)"};
 177 external function enc_TEXT_PDU_7(in TEXT_PDU_7 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 178 external function dec_TEXT_PDU_7(in charstring oct) return TEXT_PDU_7 with { extension "prototype(convert) decode(TEXT)" }
 179
 180 testcase TC_Center_justification() runs on TempComp {
 181   const TEXT_PDU_7      i := "hali"
 182   const charstring      o := " hali "
 183   const TEXT_PDU_7  expected_res:=" hali "
 184
 185   if ((enc_TEXT_PDU_7(i) == o)and(dec_TEXT_PDU_7(o) == expected_res)) {setverdict(pass);}
 186   else {setverdict(fail,"enc_TEXT_PDU_7(i)= ", enc_TEXT_PDU_7(i), "; dec_TEXT_PDU_7(o)= ", dec_TEXT_PDU_7(o));}
 187 }
 188
 189
 190
 191 type charstring TEXT_PDU_8 with { encode "TEXT"; variant "TEXT_CODING(just=right;length=5)"};
 192 external function enc_TEXT_PDU_8(in TEXT_PDU_8 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 193 external function dec_TEXT_PDU_8(in charstring oct) return TEXT_PDU_8 with { extension "prototype(convert) decode(TEXT)" }
 194
 195 testcase TC_Right_justification() runs on TempComp {
 196   const TEXT_PDU_8      i := "hali"
 197   const charstring      o := " hali"
 198   const TEXT_PDU_8  expected_res:=" hali"
 199
 200   if ((enc_TEXT_PDU_8(i) == o)and(dec_TEXT_PDU_8(o) == expected_res)) {setverdict(pass);}
 201   else {setverdict(fail,"enc_TEXT_PDU_8(i)= ", enc_TEXT_PDU_8(i), "; dec_TEXT_PDU_8(o)= ", dec_TEXT_PDU_8(o));}
 202 }
 203
 204
 205
 206 type charstring TEXT_PDU_9 with { encode "TEXT"; variant "TEXT_CODING(,,'[\d]#(4)[a-e]#(4)')"};
 207 external function enc_TEXT_PDU_9(in TEXT_PDU_9 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 208 external function dec_TEXT_PDU_9(in charstring oct) return TEXT_PDU_9 with { extension "prototype(convert) decode(TEXT)" }
 209
 210 testcase TC_Case_sensitive_selection() runs on TempComp {
 211   const TEXT_PDU_9      i := "1234abcd"
 212   const TEXT_PDU_9  expected_res:="1234abcd"
 213
 214   if (dec_TEXT_PDU_9(enc_TEXT_PDU_9(i)) == expected_res) {setverdict(pass);}
 215   else {setverdict(fail,"enc_TEXT_PDU_9(i)= ", enc_TEXT_PDU_9(i), "; dec_TEXT_PDU_9(enc_TEXT_PDU_9(i))= ", dec_TEXT_PDU_9(enc_TEXT_PDU_9(i)));}
 216 }
 217
 218
 219
 220 type charstring TEXT_PDU_10 with { encode "TEXT"; variant "TEXT_CODING(,convert=lower_case,
 221                                        '[\d]#(4)[a-e]#(4)', case_insensitive)"};
 222 external function enc_TEXT_PDU_10(in TEXT_PDU_10 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 223 external function dec_TEXT_PDU_10(in charstring oct) return TEXT_PDU_10 with { extension "prototype(convert) decode(TEXT)" }
 224
 225 testcase TC_Case_insensitive_selection() runs on TempComp {
 226   const TEXT_PDU_10     i := "1234abcd"
 227   const TEXT_PDU_10  expected_res:="1234abcd"
 228
 229   if (dec_TEXT_PDU_10(enc_TEXT_PDU_10(i)) == expected_res) {setverdict(pass);}
 230   else {setverdict(fail,"enc_TEXT_PDU_10(i)= ", enc_TEXT_PDU_10(i), "; dec_TEXT_PDU_10(enc_TEXT_PDU_10(i))= ", dec_TEXT_PDU_10(enc_TEXT_PDU_10(i)));}
 231 }
 232
 233
 234
 235 type integer TEXT_PDU_11 with { encode "TEXT"; variant "TEXT_CODING(length=5)"};
 236 external function enc_TEXT_PDU_11(in TEXT_PDU_11 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 237 external function dec_TEXT_PDU_11(in charstring oct) return TEXT_PDU_11 with { extension "prototype(convert) decode(TEXT)" }
 238
 239 testcase TC_Fixed_length_integer() runs on TempComp {
 240   const TEXT_PDU_11     i := 249
 241   const charstring      o := "  249"
 242   const TEXT_PDU_11  expected_res:= 249
 243
 244   if ((enc_TEXT_PDU_11(i) == o)and(dec_TEXT_PDU_11(o) == expected_res)) {setverdict(pass);}
 245   else {setverdict(fail,"enc_TEXT_PDU_11(i)= ", enc_TEXT_PDU_11(i), "; dec_TEXT_PDU_11(o)= ", dec_TEXT_PDU_11(o));}
 246 }
 247
 248
 249
 250 type integer TEXT_PDU_12 with { encode "TEXT"; variant "TEXT_CODING()"};
 251 external function enc_TEXT_PDU_12(in TEXT_PDU_12 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 252 external function dec_TEXT_PDU_12(in charstring oct) return TEXT_PDU_12 with { extension "prototype(convert) decode(TEXT)" }
 253
 254 testcase TC_Variable_length_integer() runs on TempComp {
 255   const TEXT_PDU_12     i := 12249
 256   const charstring      o := "12249"
 257   const TEXT_PDU_12  expected_res:= 12249
 258
 259   if ((enc_TEXT_PDU_12(i) == o)and(dec_TEXT_PDU_12(o) == expected_res)) {setverdict(pass);}
 260   else {setverdict(fail,"enc_TEXT_PDU_12(i)= ", enc_TEXT_PDU_12(i), "; dec_TEXT_PDU_12(o)= ", dec_TEXT_PDU_12(o));}
 261 }
 262
 263
 264
 265 type integer TEXT_PDU_13 with { encode "TEXT"; variant "TEXT_CODING(length=7)"};
 266 external function enc_TEXT_PDU_13(in TEXT_PDU_13 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 267 external function dec_TEXT_PDU_13(in charstring oct) return TEXT_PDU_13 with { extension "prototype(convert) decode(TEXT)" }
 268
 269 testcase TC_encoding_without_leading_zero() runs on TempComp {
 270   const TEXT_PDU_13     i := 12249
 271   const charstring      o := "  12249"
 272   const TEXT_PDU_13  expected_res:= 12249
 273
 274   if ((enc_TEXT_PDU_13(i) == o)and(dec_TEXT_PDU_13(o) == expected_res)) {setverdict(pass);}
 275   else {setverdict(fail,"enc_TEXT_PDU_13(i)= ", enc_TEXT_PDU_13(i), "; dec_TEXT_PDU_13(o)= ", dec_TEXT_PDU_13(o));}
 276 }
 277
 278
 279
 280 type integer TEXT_PDU_14 with { encode "TEXT"; variant "TEXT_CODING(leading0=true;length=7)"};
 281 external function enc_TEXT_PDU_14(in TEXT_PDU_14 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 282 external function dec_TEXT_PDU_14(in charstring oct) return TEXT_PDU_14 with { extension "prototype(convert) decode(TEXT)" }
 283
 284 testcase TC_encoding_with_leading_zero() runs on TempComp {
 285   const TEXT_PDU_14     i := 12249
 286   const charstring      o := "0012249"
 287   const TEXT_PDU_14  expected_res:= 12249
 288
 289   if ((enc_TEXT_PDU_14(i) == o)and(dec_TEXT_PDU_14(o) == expected_res)) {setverdict(pass);}
 290   else {setverdict(fail,"enc_TEXT_PDU_14(i)= ", enc_TEXT_PDU_14(i), "; dec_TEXT_PDU_14(o)= ", dec_TEXT_PDU_14(o));}
 291 }
 292
 293
 294
 295 type integer TEXT_PDU_15 with { encode "TEXT"; variant "TEXT_CODING(leading0=true;length=7)"};
 296 external function enc_TEXT_PDU_15(in TEXT_PDU_15 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 297 external function dec_TEXT_PDU_15(in charstring oct) return TEXT_PDU_15 with { extension "prototype(convert) decode(TEXT)" }
 298
 299 testcase TC_encoding_negativ_integer_with_leading_zero() runs on TempComp {
 300   const TEXT_PDU_15     i := -12249
 301   const charstring      o := "-012249"
 302   const TEXT_PDU_15  expected_res:= -12249
 303
 304   if ((enc_TEXT_PDU_15(i) == o)and(dec_TEXT_PDU_15(o) == expected_res)) {setverdict(pass);}
 305   else {setverdict(fail,"enc_TEXT_PDU_15(i)= ", enc_TEXT_PDU_15(i), "; dec_TEXT_PDU_15(o)= ", dec_TEXT_PDU_15(o));}
 306 }
 307
 308
 309
 310 type integer TEXT_PDU_16 with { encode "TEXT"; variant "TEXT_CODING(,,
 311                                        '[1-4]#(1,)')"};
 312 external function enc_TEXT_PDU_16(in TEXT_PDU_16 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 313 external function dec_TEXT_PDU_16(in charstring oct) return TEXT_PDU_16 with { extension "prototype(convert) decode(TEXT)" }
 314
 315 testcase TC_Selection_of_integer_value() runs on TempComp {
 316   const TEXT_PDU_16     i := 123423
 317   const charstring      o := "123423567aBCdfrd"
 318   const TEXT_PDU_16  expected_res:= 123423
 319
 320   if (dec_TEXT_PDU_16(o) == expected_res) {setverdict(pass);}
 321   else {setverdict(fail,"enc_TEXT_PDU_16(i)= ", enc_TEXT_PDU_16(i), "; dec_TEXT_PDU_16(o)= ", dec_TEXT_PDU_16(o));}
 322 }
 323
 324
 325
 326 type boolean TEXT_PDU_17 with { encode "TEXT"; variant "TEXT_CODING()"};
 327 external function enc_TEXT_PDU_17(in TEXT_PDU_17 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 328 external function dec_TEXT_PDU_17(in charstring oct) return TEXT_PDU_17 with { extension "prototype(convert) decode(TEXT)" }
 329
 330 testcase TC_basic_encoding_of_true_value() runs on TempComp {
 331   const TEXT_PDU_17     i := true
 332   const charstring      o := "true"
 333   const TEXT_PDU_17  expected_res:= true
 334
 335   if ((enc_TEXT_PDU_17(i) == o)and(dec_TEXT_PDU_17(o) == expected_res)) {setverdict(pass);}
 336   else {setverdict(fail,"enc_TEXT_PDU_17(i)= ", enc_TEXT_PDU_17(i), "; dec_TEXT_PDU_17(o)= ", dec_TEXT_PDU_17(o));}
 337 }
 338
 339
 340
 341 testcase TC_basic_encoding_of_false_value() runs on TempComp {
 342   const TEXT_PDU_17     i := false
 343   const charstring      o := "false"
 344   const TEXT_PDU_17  expected_res:= false
 345
 346   if ((enc_TEXT_PDU_17(i) == o)and(dec_TEXT_PDU_17(o) == expected_res)) {setverdict(pass);}
 347   else {setverdict(fail,"enc_TEXT_PDU_17(i)= ", enc_TEXT_PDU_17(i), "; dec_TEXT_PDU_17(o)= ", dec_TEXT_PDU_17(o));}
 348 }
 349
 350
 351
 352 type boolean TEXT_PDU_18 with { encode "TEXT"; variant "TEXT_CODING(true:'YES';false:'NO')"};
 353 external function enc_TEXT_PDU_18(in TEXT_PDU_18 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 354 external function dec_TEXT_PDU_18(in charstring oct) return TEXT_PDU_18 with { extension "prototype(convert) decode(TEXT)" }
 355
 356 testcase TC_Encoding_and_decoding_of_given_tokens_1() runs on TempComp {
 357   const TEXT_PDU_18     i := false
 358   const charstring      o := "NO"
 359   const TEXT_PDU_18  expected_res:= false
 360
 361   if ((enc_TEXT_PDU_18(i) == o)and(dec_TEXT_PDU_18(o) == expected_res)) {setverdict(pass);}
 362   else {setverdict(fail,"enc_TEXT_PDU_18(i)= ", enc_TEXT_PDU_18(i), "; dec_TEXT_PDU_18(o)= ", dec_TEXT_PDU_18(o));}
 363 }
 364
 365
 366
 367 type boolean TEXT_PDU_19 with { encode "TEXT"; variant "TEXT_CODING(true:'YES';false:'NO',
 368                            true:'good';false:{'bad',case_insensitive})"};
 369 external function enc_TEXT_PDU_19(in TEXT_PDU_19 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 370 external function dec_TEXT_PDU_19(in charstring oct) return TEXT_PDU_19 with { extension "prototype(convert) decode(TEXT)" }
 371
 372 testcase TC_Encoding_and_decoding_of_given_tokens_2() runs on TempComp {
 373   const TEXT_PDU_19     i := false
 374   const charstring      o := "NO"
 375   const charstring      o2 := "Bad"
 376   const TEXT_PDU_19  expected_res:= false
 377
 378   if ((enc_TEXT_PDU_19(i) == o)and(dec_TEXT_PDU_19(o2) == expected_res)) {setverdict(pass);}
 379   else {setverdict(fail,"enc_TEXT_PDU_19(i)= ", enc_TEXT_PDU_19(i), "; dec_TEXT_PDU_19(o)= ", dec_TEXT_PDU_19(o));}
 380 }
 381
 382
 383
 384 type enumerated TEXT_PDU_20 {egy,ketto,harom}
 385     with { encode "TEXT"; variant "TEXT_CODING()"};
 386 external function enc_TEXT_PDU_20(in TEXT_PDU_20 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 387 external function dec_TEXT_PDU_20(in charstring oct) return TEXT_PDU_20 with { extension "prototype(convert) decode(TEXT)" }
 388
 389 testcase TC_Basic_encoding_of_enumerated_values() runs on TempComp {
 390   const TEXT_PDU_20     i := egy
 391   const charstring      o := "egy"
 392   const TEXT_PDU_20  expected_res:= egy
 393
 394   if ((enc_TEXT_PDU_20(i) == o)and(dec_TEXT_PDU_20(o) == expected_res)) {setverdict(pass);}
 395   else {setverdict(fail,"enc_TEXT_PDU_20(i)= ", enc_TEXT_PDU_20(i), "; dec_TEXT_PDU_20(o)= ", dec_TEXT_PDU_20(o));}
 396 }
 397
 398
 399
 400 type enumerated TEXT_PDU_21 {egy,ketto,harom}
 401     with { encode "TEXT"; variant "TEXT_CODING(egy:'haho';harom:'har',
 402                                  egy:'(haho)|(H)';ketto:{,case_insensitive};
 403                                  harom:{'hArom',case_insensitive})"};
 404 external function enc_TEXT_PDU_21(in TEXT_PDU_21 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 405 external function dec_TEXT_PDU_21(in charstring oct) return TEXT_PDU_21 with { extension "prototype(convert) decode(TEXT)" }
 406
 407 testcase TC_Encoding_of_given_enumerated_values_1() runs on TempComp {
 408   const TEXT_PDU_21     i := egy
 409   const charstring      o := "haho"
 410   const TEXT_PDU_21  expected_res:= egy
 411
 412   if ((enc_TEXT_PDU_21(i) == o)and(dec_TEXT_PDU_21(o) == expected_res)) {setverdict(pass);}
 413   else {setverdict(fail,"enc_TEXT_PDU_21(i)= ", enc_TEXT_PDU_21(i), "; dec_TEXT_PDU_21(o)= ", dec_TEXT_PDU_21(o));}
 414 }
 415
 416
 417 testcase TC_Encoding_of_given_enumerated_values_2() runs on TempComp {
 418   const TEXT_PDU_21     i := ketto
 419   const charstring      o1 := "ketto"
 420   const charstring      o2 := "Ketto"
 421   const TEXT_PDU_21  expected_res:= ketto
 422
 423   if ((enc_TEXT_PDU_21(i) == o1)and(dec_TEXT_PDU_21(o2) == expected_res)) {setverdict(pass);}
 424   else {setverdict(fail,"enc_TEXT_PDU_21(i)= ", enc_TEXT_PDU_21(i), "; dec_TEXT_PDU_21(o2)= ", dec_TEXT_PDU_21(o2));}
 425 }
 426
 427
 428 testcase TC_Encoding_of_given_enumerated_values_3() runs on TempComp {
 429   const TEXT_PDU_21     i := harom
 430   const charstring      o1 := "har"
 431   const charstring      o2 := "haRoM"
 432   const TEXT_PDU_21  expected_res:= harom
 433
 434   if ((enc_TEXT_PDU_21(i) == o1)and(dec_TEXT_PDU_21(o2) == expected_res)) {setverdict(pass);}
 435   else {setverdict(fail,"enc_TEXT_PDU_21(i)= ", enc_TEXT_PDU_21(i), "; dec_TEXT_PDU_21(o2)= ", dec_TEXT_PDU_21(o2));}
 436 }
 437
 438
 439
 440 type charstring TEXT_PDU_22 with { encode "TEXT"; variant "BEGIN('Header:')"};
 441 external function enc_TEXT_PDU_22(in TEXT_PDU_22 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 442 external function dec_TEXT_PDU_22(in charstring oct) return TEXT_PDU_22 with { extension "prototype(convert) decode(TEXT)" }
 443
 444 testcase TC_Coding_with_leading_token() runs on TempComp {
 445   const TEXT_PDU_22     i := "value"
 446   const charstring      o := "Header:value"
 447   const TEXT_PDU_22  expected_res:= "value"
 448
 449   if ((enc_TEXT_PDU_22(i) == o)and(dec_TEXT_PDU_22(o) == expected_res)) {setverdict(pass);}
 450   else {setverdict(fail,"enc_TEXT_PDU_22(i)= ", enc_TEXT_PDU_22(i), "; dec_TEXT_PDU_22(o)= ", dec_TEXT_PDU_22(o));}
 451 }
 452
 453
 454
 455 type charstring TEXT_PDU_23 with { encode "TEXT"; variant "BEGIN('Header:',, case_insensitive)"};
 456 external function enc_TEXT_PDU_23(in TEXT_PDU_23 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 457 external function dec_TEXT_PDU_23(in charstring oct) return TEXT_PDU_23 with { extension "prototype(convert) decode(TEXT)" }
 458
 459 testcase TC_Coding_with_leading_token_case_insensitive_decoding() runs on TempComp {
 460   const TEXT_PDU_23     i := "value"
 461   const charstring      o1 := "Header:value"
 462   const charstring      o2 := "heADer:value"
 463   const TEXT_PDU_23  expected_res:= "value"
 464
 465   if ((enc_TEXT_PDU_23(i) == o1)and(dec_TEXT_PDU_23(o2) == expected_res)) {setverdict(pass);}
 466   else {setverdict(fail,"enc_TEXT_PDU_23(i)= ", enc_TEXT_PDU_23(i), "; dec_TEXT_PDU_23(o2)= ", dec_TEXT_PDU_23(o2));}
 467 }
 468
 469
 470
 471 type charstring TEXT_PDU_24 with { encode "TEXT"; variant "BEGIN('Header:','(T:)|(Header:)')"};
 472 external function enc_TEXT_PDU_24(in TEXT_PDU_24 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 473 external function dec_TEXT_PDU_24(in charstring oct) return TEXT_PDU_24 with { extension "prototype(convert) decode(TEXT)" }
 474
 475 testcase TC_Coding_with_leading_token_case_insensitive_decoding_1() runs on TempComp {
 476   const TEXT_PDU_24     i := "value"
 477   const charstring      o := "Header:value"
 478   const TEXT_PDU_24  expected_res:= "value"
 479
 480   if ((enc_TEXT_PDU_24(i) == o)and(dec_TEXT_PDU_24(o) == expected_res)) {setverdict(pass);}
 481   else {setverdict(fail,"enc_TEXT_PDU_24(i)= ", enc_TEXT_PDU_24(i), "; dec_TEXT_PDU_24(o)= ", dec_TEXT_PDU_24(o));}
 482 }
 483
 484
 485 testcase TC_Coding_with_leading_token_case_insensitive_decoding_2() runs on TempComp {
 486   const charstring      o := "T:value"
 487   const TEXT_PDU_24  expected_res:= "value"
 488
 489   if (dec_TEXT_PDU_24(o) == expected_res) {setverdict(pass);}
 490   else {setverdict(fail,"; dec_TEXT_PDU_24(o)= ", dec_TEXT_PDU_24(o));}
 491 }
 492
 493
 494
 495 type charstring TEXT_PDU_25 with { encode "TEXT"; variant "END(':close')"};
 496 external function enc_TEXT_PDU_25(in TEXT_PDU_25 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 497 external function dec_TEXT_PDU_25(in charstring oct) return TEXT_PDU_25 with { extension "prototype(convert) decode(TEXT)" }
 498
 499 testcase TC_Coding_with_trailing_token() runs on TempComp {
 500   const TEXT_PDU_25     i := "value"
 501   const charstring      o := "value:close"
 502   const TEXT_PDU_25  expected_res:= "value"
 503
 504   if ((enc_TEXT_PDU_25(i) == o)and(dec_TEXT_PDU_25(o) == expected_res)) {setverdict(pass);}
 505   else {setverdict(fail,"enc_TEXT_PDU_25(i)= ", enc_TEXT_PDU_25(i), "; dec_TEXT_PDU_25(o)= ", dec_TEXT_PDU_25(o));}
 506 }
 507
 508
 509
 510 type charstring TEXT_PDU_26 with { encode "TEXT"; variant "END(':close',, case_insensitive)"};
 511 external function enc_TEXT_PDU_26(in TEXT_PDU_26 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 512 external function dec_TEXT_PDU_26(in charstring oct) return TEXT_PDU_26 with { extension "prototype(convert) decode(TEXT)" }
 513
 514 testcase TC_Coding_with_trailing_token_case_insensitive_decoding() runs on TempComp {
 515   const TEXT_PDU_26     i := "value"
 516   const charstring      o1 := "value:close"
 517   const charstring      o2 := "value:CloSe"
 518   const TEXT_PDU_26  expected_res:= "value"
 519
 520   if ((enc_TEXT_PDU_26(i) == o1)and(dec_TEXT_PDU_26(o2) == expected_res)) {setverdict(pass);}
 521   else {setverdict(fail,"enc_TEXT_PDU_26(i)= ", enc_TEXT_PDU_26(i), "; dec_TEXT_PDU_26(o2)= ", dec_TEXT_PDU_26(o2));}
 522 }
 523
 524
 525
 526 type charstring TEXT_PDU_27 with { encode "TEXT"; variant "END(':close','(:T)|(:close)')"};
 527 external function enc_TEXT_PDU_27(in TEXT_PDU_27 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 528 external function dec_TEXT_PDU_27(in charstring oct) return TEXT_PDU_27 with { extension "prototype(convert) decode(TEXT)" }
 529
 530 testcase TC_Coding_with_trailing_token_using_decoding_matching_pattern() runs on TempComp {
 531   const TEXT_PDU_27     i := "value"
 532   const charstring      o1 := "value:close"
 533   const charstring      o2 := "value:T"
 534   const TEXT_PDU_27  expected_res:= "value"
 535
 536   if ((enc_TEXT_PDU_27(i) == o1)and(dec_TEXT_PDU_27(o2) == expected_res)) {setverdict(pass);}
 537   else {setverdict(fail,"enc_TEXT_PDU_27(i)= ", enc_TEXT_PDU_27(i), "; dec_TEXT_PDU_27(o2)= ", dec_TEXT_PDU_27(o2));}
 538 }
 539
 540
 541
 542 type record TEXT_PDU_28 {
 543   charstring f1,
 544   charstring f2
 545 } with { encode "TEXT"; variant "SEPARATOR('\n\r')"};
 546 external function enc_TEXT_PDU_28(in TEXT_PDU_28 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 547 external function dec_TEXT_PDU_28(in charstring oct) return TEXT_PDU_28 with { extension "prototype(convert) decode(TEXT)" }
 548
 549 testcase TC_Coding_with_separator_token() runs on TempComp {
 550   const TEXT_PDU_28     i := {f1:="value1",f2:="value2"}
 551   const charstring      o := "value1\n\rvalue2"
 552   const TEXT_PDU_28  expected_res:= {f1:="value1",f2:="value2"}
 553
 554   if ((enc_TEXT_PDU_28(i) == o)and(dec_TEXT_PDU_28(o) == expected_res)) {setverdict(pass);}
 555   else {setverdict(fail,"enc_TEXT_PDU_28(i)= ", enc_TEXT_PDU_28(i), "; dec_TEXT_PDU_28(o)= ", dec_TEXT_PDU_28(o));}
 556 }
 557
 558
 559
 560 type record TEXT_PDU_29 {
 561   charstring f1,
 562   charstring f2
 563 } with { encode "TEXT"; variant "SEPARATOR(':FieldSep\n\r',,case_insensitive)"};
 564 external function enc_TEXT_PDU_29(in TEXT_PDU_29 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 565 external function dec_TEXT_PDU_29(in charstring oct) return TEXT_PDU_29 with { extension "prototype(convert) decode(TEXT)" }
 566
 567 testcase TC_Coding_with_separator_token_case_insensitive_decoding() runs on TempComp {
 568   const charstring      o := "value1:FiELDsep\n\rvalue2"
 569   const TEXT_PDU_29  expected_res:= {f1:="value1",f2:="value2"}
 570
 571   if (dec_TEXT_PDU_29(o) == expected_res) {setverdict(pass);}
 572   else {setverdict(fail, "; dec_TEXT_PDU_29(o)= ", dec_TEXT_PDU_29(o));}
 573 }
 574
 575
 576
 577 type record TEXT_PDU_30 {
 578   charstring f1,
 579   charstring f2
 580 } with { encode "TEXT"; variant "SEPARATOR(':FieldSep\n\r','(\n\r)|(:FieldSep\n\r)')"};
 581 external function enc_TEXT_PDU_30(in TEXT_PDU_30 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 582 external function dec_TEXT_PDU_30(in charstring oct) return TEXT_PDU_30 with { extension "prototype(convert) decode(TEXT)" }
 583
 584 testcase TC_Coding_with_separator_token_1() runs on TempComp {
 585   const TEXT_PDU_30     i := {f1:="value1",f2:="value2"}
 586   const charstring      o := "value1:FieldSep\n\rvalue2"
 587   const TEXT_PDU_30  expected_res:= {f1:="value1",f2:="value2"}
 588
 589   if ((enc_TEXT_PDU_30(i) == o)and(dec_TEXT_PDU_30(o) == expected_res)) {setverdict(pass);}
 590   else {setverdict(fail,"enc_TEXT_PDU_30(i)= ", enc_TEXT_PDU_30(i), "; dec_TEXT_PDU_30(o)= ", dec_TEXT_PDU_30(o));}
 591 }
 592
 593
 594 testcase TC_Coding_with_separator_token_2() runs on TempComp {
 595   const charstring      o := "value1\n\rvalue2"
 596   const TEXT_PDU_30  expected_res:= {f1:="value1",f2:="value2"}
 597
 598   if (dec_TEXT_PDU_30(o) == expected_res) {setverdict(pass);}
 599   else {setverdict(fail,"; dec_TEXT_PDU_30(o)= ", dec_TEXT_PDU_30(o));}
 600 }
 601
 602
 603
 604 type record TEXT_PDU_31 {
 605   charstring f1
 606 } with { encode "TEXT"; variant "BEGIN('Head:'),END(':end')"};
 607 external function enc_TEXT_PDU_31(in TEXT_PDU_31 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 608 external function dec_TEXT_PDU_31(in charstring oct) return TEXT_PDU_31 with { extension "prototype(convert) decode(TEXT)" }
 609
 610 testcase TC_Record_with_BEGIN_END_token() runs on TempComp {
 611   const TEXT_PDU_31     i := {f1:="value1"}
 612   const charstring      o := "Head:value1:end"
 613   const TEXT_PDU_31  expected_res:= {f1:="value1"}
 614
 615   if ((enc_TEXT_PDU_31(i) == o)and(dec_TEXT_PDU_31(o) == expected_res)) {setverdict(pass);}
 616   else {setverdict(fail,"enc_TEXT_PDU_31(i)= ", enc_TEXT_PDU_31(i), "; dec_TEXT_PDU_31(o)= ", dec_TEXT_PDU_31(o));}
 617 }
 618
 619
 620
 621 type record rec_32{
 622   charstring field1,
 623   charstring field2
 624 } with { encode "TEXT";variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
 625
 626 type record TEXT_PDU_32 {
 627   rec_32 f1,
 628   charstring f2
 629 } with { encode "TEXT";variant "BEGIN('PDU:'),END(':UDP')"};
 630 external function enc_TEXT_PDU_32(in TEXT_PDU_32 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 631 external function dec_TEXT_PDU_32(in charstring oct) return TEXT_PDU_32 with { extension "prototype(convert) decode(TEXT)" }
 632
 633 testcase TC_Record_with_record_fields() runs on TempComp {
 634   const TEXT_PDU_32     i := {f1:={field1:="v1",field2:="v2"},f2:="value1"}
 635   const charstring      o := "PDU:Head:v1,v2:endvalue1:UDP"
 636   const TEXT_PDU_32  expected_res:= {f1:={field1:="v1",field2:="v2"},f2:="value1"}
 637
 638   if ((enc_TEXT_PDU_32(i) == o)and(dec_TEXT_PDU_32(o) == expected_res)) {setverdict(pass);}
 639   else {setverdict(fail,"enc_TEXT_PDU_32(i)= ", enc_TEXT_PDU_32(i), "; dec_TEXT_PDU_32(o)= ", dec_TEXT_PDU_32(o));}
 640 }
 641
 642
 643
 644 type record rec_33{
 645   charstring field1,
 646   charstring field2
 647 } with { encode "TEXT";variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
 648
 649 type record TEXT_PDU_33 {
 650   rec_33 f1 optional,
 651   charstring f2
 652 } with { encode "TEXT"; variant "BEGIN('PDU:'),END(':UDP')"};
 653 external function enc_TEXT_PDU_33(in TEXT_PDU_33 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 654 external function dec_TEXT_PDU_33(in charstring oct) return TEXT_PDU_33 with { extension "prototype(convert) decode(TEXT)" }
 655
 656 testcase TC_Record_with_optional_fields_1() runs on TempComp {
 657   const TEXT_PDU_33     i := {f1:={field1:="v1",field2:="v2"},f2:="value1"}
 658   const charstring      o := "PDU:Head:v1,v2:endvalue1:UDP"
 659   const TEXT_PDU_33  expected_res:= {f1:={field1:="v1",field2:="v2"},f2:="value1"}
 660
 661   if ((enc_TEXT_PDU_33(i) == o)and(dec_TEXT_PDU_33(o) == expected_res)) {setverdict(pass);}
 662   else {setverdict(fail,"enc_TEXT_PDU_33(i)= ", enc_TEXT_PDU_33(i), "; dec_TEXT_PDU_33(o)= ", dec_TEXT_PDU_33(o));}
 663 }
 664
 665
 666 testcase TC_Record_with_optional_fields_2() runs on TempComp {
 667   const TEXT_PDU_33     i := {f1:=omit,f2:="value1"}
 668   const charstring      o := "PDU:value1:UDP"
 669   const TEXT_PDU_33  expected_res:= {f1:=omit,f2:="value1"}
 670
 671   if ((enc_TEXT_PDU_33(i) == o)and(dec_TEXT_PDU_33(o) == expected_res)) {setverdict(pass);}
 672   else {setverdict(fail,"enc_TEXT_PDU_33(i)= ", enc_TEXT_PDU_33(i), "; dec_TEXT_PDU_33(o)= ", dec_TEXT_PDU_33(o));}
 673 }
 674
 675
 676
 677 type set TEXT_PDU_34 {
 678   charstring f1
 679 } with { encode "TEXT"; variant "BEGIN('Head:'),END(':end')"};
 680 external function enc_TEXT_PDU_34(in TEXT_PDU_34 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 681 external function dec_TEXT_PDU_34(in charstring oct) return TEXT_PDU_34 with { extension "prototype(convert) decode(TEXT)" }
 682
 683 testcase TC_Set_with_BEGIN_END_token() runs on TempComp {
 684   const TEXT_PDU_34     i := {f1:="value1"}
 685   const charstring      o := "Head:value1:end"
 686   const TEXT_PDU_34  expected_res:= {f1:="value1"}
 687
 688   if ((enc_TEXT_PDU_34(i) == o)and(dec_TEXT_PDU_34(o) == expected_res)) {setverdict(pass);}
 689   else {setverdict(fail,"enc_TEXT_PDU_34(i)= ", enc_TEXT_PDU_34(i), "; dec_TEXT_PDU_34(o)= ", dec_TEXT_PDU_34(o));}
 690 }
 691
 692
 693
 694 type set rec_35{
 695   charstring field1,
 696   charstring field2
 697 } with { encode "TEXT"; variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
 698
 699 type set TEXT_PDU_35 {
 700   rec_35 f1,
 701   charstring f2
 702 } with { encode "TEXT"; variant "BEGIN('PDU:'),END(':UDP'),SEPARATOR(',')"};
 703 external function enc_TEXT_PDU_35(in TEXT_PDU_35 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 704 external function dec_TEXT_PDU_35(in charstring oct) return TEXT_PDU_35 with { extension "prototype(convert) decode(TEXT)" }
 705
 706 testcase TC_Set_with_BEGIN_END_token_1() runs on TempComp {
 707   const TEXT_PDU_35     i := {f1:={field1:="v1",field2:="v2"},f2:="value1"}
 708   const charstring      o := "PDU:Head:v1,v2:end,value1:UDP"
 709   const TEXT_PDU_35  expected_res:= {f1:={field1:="v1",field2:="v2"},f2:="value1"}
 710
 711   if ((enc_TEXT_PDU_35(i) == o)and(dec_TEXT_PDU_35(o) == expected_res)) {setverdict(pass);}
 712   else {setverdict(fail,"enc_TEXT_PDU_35(i)= ", enc_TEXT_PDU_35(i), "; dec_TEXT_PDU_35(o)= ", dec_TEXT_PDU_35(o));}
 713 }
 714
 715
 716 testcase TC_Set_with_BEGIN_END_token_2() runs on TempComp {
 717   const charstring      o := "PDU:value1,Head:v1,v2:end:UDP"
 718   const TEXT_PDU_35  expected_res:= {f1:={field1:="v1",field2:="v2"},f2:="value1"}
 719
 720   if (dec_TEXT_PDU_35(o) == expected_res) {setverdict(pass);}
 721   else {setverdict(fail,"; dec_TEXT_PDU_35(o)= ", dec_TEXT_PDU_35(o));}
 722 }
 723
 724
 725
 726 type record rec_36{
 727   charstring field1,
 728   charstring field2
 729 } with { encode "TEXT"; variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
 730
 731 type set TEXT_PDU_36 {
 732   rec_36 f1 optional,
 733   charstring f2
 734 } with { encode "TEXT"; variant "BEGIN('PDU:'),END(':UDP')"};
 735 external function enc_TEXT_PDU_36(in TEXT_PDU_36 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 736 external function dec_TEXT_PDU_36(in charstring oct) return TEXT_PDU_36 with { extension "prototype(convert) decode(TEXT)" }
 737
 738 testcase TC_Set_with_optional_fields_1() runs on TempComp {
 739   const TEXT_PDU_36     i := {f1:={field1:="v1",field2:="v2"},f2:="value1"}
 740   const charstring      o := "PDU:Head:v1,v2:endvalue1:UDP"
 741   const TEXT_PDU_36  expected_res:= {f1:={field1:="v1",field2:="v2"},f2:="value1"}
 742
 743   if ((enc_TEXT_PDU_36(i) == o)and(dec_TEXT_PDU_36(o) == expected_res)) {setverdict(pass);}
 744   else {setverdict(fail,"enc_TEXT_PDU_36(i)= ", enc_TEXT_PDU_36(i), "; dec_TEXT_PDU_36(o)= ", dec_TEXT_PDU_36(o));}
 745 }
 746
 747
 748 testcase TC_Set_with_optional_fields_2() runs on TempComp {
 749   const TEXT_PDU_36     i := {f1:=omit,f2:="value1"}
 750   const charstring      o := "PDU:value1:UDP"
 751   const TEXT_PDU_36  expected_res:= {f1:=omit,f2:="value1"}
 752
 753   if ((enc_TEXT_PDU_36(i) == o)and(dec_TEXT_PDU_36(o) == expected_res)) {setverdict(pass);}
 754   else {setverdict(fail,"enc_TEXT_PDU_36(i)= ", enc_TEXT_PDU_36(i), "; dec_TEXT_PDU_36(o)= ", dec_TEXT_PDU_36(o));}
 755 }
 756
 757
 758
 759 type set of charstring sof_37 with {encode "TEXT"; variant "SEPARATOR(',')"}
 760
 761 type set TEXT_PDU_37 {
 762   charstring f1,
 763   charstring f2 optional,
 764   sof_37 f3,
 765   sof_37 f4 optional,
 766   sof_37 f5,
 767   charstring f6
 768 } with { encode "TEXT"; variant "BEGIN('Head:'),END(':end')";
 769          variant (f1) "BEGIN('f1:')";
 770          variant (f2) "BEGIN('f2:')";
 771          variant (f3) "BEGIN('f3:')";
 772          variant (f4) "BEGIN('f4:'),TEXT_CODING(,repeatable=true)";
 773          variant (f5) "BEGIN('f5:'),TEXT_CODING(,repeatable=true)";
 774          variant (f6) "BEGIN('f6:')";
 775          variant "SEPARATOR(';')" };
 776 external function enc_TEXT_PDU_37(in TEXT_PDU_37 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 777 external function dec_TEXT_PDU_37(in charstring oct) return TEXT_PDU_37 with { extension "prototype(convert) decode(TEXT)" }
 778
 779 testcase TC_Set_with_set_of_type_fields_1() runs on TempComp {
 780   const TEXT_PDU_37     i := {f1:="value1",
 781                     f2:=omit,
 782                     f3:={"sof1","sof1a","sof1b"},
 783                     f4:={"sof2","sof2a","sof2b"},
 784                     f5:={"sof3","sof3a","sof3b"},
 785                     f6:="value6" }
 786   const charstring      o := "Head:f1:value1;f3:sof1,sof1a,sof1b;f4:sof2,sof2a,sof2b;f5:sof3,sof3a,sof3b;f6:value6:end"
 787   const TEXT_PDU_37  expected_res:= {f1:="value1",
 788                     f2:=omit,
 789                     f3:={"sof1","sof1a","sof1b"},
 790                     f4:={"sof2","sof2a","sof2b"},
 791                     f5:={"sof3","sof3a","sof3b"},
 792                     f6:="value6" }
 793
 794   if ((enc_TEXT_PDU_37(i) == o)and(dec_TEXT_PDU_37(o) == expected_res)) {setverdict(pass);}
 795   else {setverdict(fail,"enc_TEXT_PDU_37(i)= ", enc_TEXT_PDU_37(i), "; dec_TEXT_PDU_37(o)= ", dec_TEXT_PDU_37(o));}
 796 }
 797
 798
 799 testcase TC_Set_with_set_of_type_fields_2() runs on TempComp {
 800   const charstring      o := "Head:f5:sof3a,sof3b;f3:sof1,sof1a,sof1b;f4:sof2;f1:value1;f4:sof2a,sof2b;f5:sof3;f6:value6:end"
 801   const TEXT_PDU_37  expected_res:= {f1:="value1",
 802                     f2:=omit,
 803                     f3:={"sof1","sof1a","sof1b"},
 804                     f4:={"sof2","sof2a","sof2b"},
 805                     f5:={"sof3","sof3a","sof3b"},
 806                     f6:="value6" }
 807
 808   if (dec_TEXT_PDU_37(o) == expected_res) {setverdict(pass);}
 809   else {setverdict(fail, "; dec_TEXT_PDU_37(o)= ", dec_TEXT_PDU_37(o));}
 810 }
 811
 812
 813 testcase TC_Set_with_set_of_type_fields_3() runs on TempComp {
 814   const charstring      o := "Head:f5:sof3a,sof3b;f3:sof1,sof1a,sof1b;f1:value1;f5:sof3;f6:value6:end"
 815   const TEXT_PDU_37  expected_res:= {f1:="value1",
 816                     f2:=omit,
 817                     f3:={"sof1","sof1a","sof1b"},
 818                     f4:=omit,
 819                     f5:={"sof3","sof3a","sof3b"},
 820                     f6:="value6" }
 821
 822   if (dec_TEXT_PDU_37(o) == expected_res) {setverdict(pass);}
 823   else {setverdict(fail, "; dec_TEXT_PDU_37(o)= ", dec_TEXT_PDU_37(o));}
 824 }
 825
 826
 827
 828 type record of charstring TEXT_PDU_38
 829      with { encode "TEXT"; variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
 830 external function enc_TEXT_PDU_38(in TEXT_PDU_38 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 831 external function dec_TEXT_PDU_38(in charstring oct) return TEXT_PDU_38 with { extension "prototype(convert) decode(TEXT)" }
 832
 833 testcase TC_Record_of_with_BEGIN_END_token() runs on TempComp {
 834   const TEXT_PDU_38     i := {"value1","value2","value3"}
 835   const charstring      o := "Head:value1,value2,value3:end"
 836   const TEXT_PDU_38  expected_res:= {"value1","value2","value3"}
 837
 838   if ((enc_TEXT_PDU_38(i) == o)and(dec_TEXT_PDU_38(o) == expected_res)) {setverdict(pass);}
 839   else {setverdict(fail,"enc_TEXT_PDU_38(i)= ", enc_TEXT_PDU_38(i), "; dec_TEXT_PDU_38(o)= ", dec_TEXT_PDU_38(o));}
 840 }
 841
 842
 843
 844 type record rec_39{
 845   charstring field1,
 846   charstring field2
 847 } with { encode "TEXT"; variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
 848
 849 type record of rec_39 TEXT_PDU_39  with { encode "TEXT"; variant "BEGIN('PDU:'),END(':UDP')"};
 850 external function enc_TEXT_PDU_39(in TEXT_PDU_39 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 851 external function dec_TEXT_PDU_39(in charstring oct) return TEXT_PDU_39 with { extension "prototype(convert) decode(TEXT)" }
 852
 853 testcase TC_Record_of_with_record_fields() runs on TempComp {
 854   const TEXT_PDU_39     i := {{field1:="v1",field2:="v2"},{field1:="v3",field2:="v4"}}
 855   const charstring      o := "PDU:Head:v1,v2:endHead:v3,v4:end:UDP"
 856   const TEXT_PDU_39  expected_res:= {{field1:="v1",field2:="v2"},{field1:="v3",field2:="v4"}}
 857
 858   if ((enc_TEXT_PDU_39(i) == o)and(dec_TEXT_PDU_39(o) == expected_res)) {setverdict(pass);}
 859   else {setverdict(fail,"enc_TEXT_PDU_39(i)= ", enc_TEXT_PDU_39(i), "; dec_TEXT_PDU_39(o)= ", dec_TEXT_PDU_39(o));}
 860 }
 861
 862
 863 testcase TC_Empty_Record_of() runs on TempComp {
 864   const TEXT_PDU_39     i := {}
 865   const charstring      o := "PDU::UDP"
 866   const TEXT_PDU_39  expected_res:= {}
 867
 868   if ((enc_TEXT_PDU_39(i) == o)and(dec_TEXT_PDU_39(o) == expected_res)) {setverdict(pass);}
 869   else {setverdict(fail,"enc_TEXT_PDU_39(i)= ", enc_TEXT_PDU_39(i), "; dec_TEXT_PDU_39(o)= ", dec_TEXT_PDU_39(o));}
 870 }
 871
 872
 873
 874 type union TEXT_PDU_40 {
 875   charstring f1,
 876   charstring f2
 877 } with { encode "TEXT"; variant "BEGIN('Head:'),END(':end')";
 878             variant (f1) "BEGIN('f1:'),END(':1f')"
 879             variant (f2) "BEGIN('f2:'),END(':2f')" };
 880 external function enc_TEXT_PDU_40(in TEXT_PDU_40 pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
 881 external function dec_TEXT_PDU_40(in charstring oct) return TEXT_PDU_40 with { extension "prototype(convert) decode(TEXT)" }
 882
 883 testcase TC_Union_with_BEGIN_END_token_1() runs on TempComp {
 884   const TEXT_PDU_40     i := {f1:="value1"}
 885   const charstring      o := "Head:f1:value1:1f:end"
 886   const TEXT_PDU_40  expected_res:= {f1:="value1"}
 887
 888   if ((enc_TEXT_PDU_40(i) == o)and(dec_TEXT_PDU_40(o) == expected_res)) {setverdict(pass);}
 889   else {setverdict(fail,"enc_TEXT_PDU_40(i)= ", enc_TEXT_PDU_40(i), "; dec_TEXT_PDU_40(o)= ", dec_TEXT_PDU_40(o));}
 890 }
 891
 892 testcase TC_Union_with_BEGIN_END_token_2() runs on TempComp {
 893   const charstring      o := "Head:f2:value2:2f:end"
 894   const TEXT_PDU_40  expected_res:= {f2:="value2"}
 895
 896   if (dec_TEXT_PDU_40(o) == expected_res) {setverdict(pass);}
 897   else {setverdict(fail,"; dec_TEXT_PDU_40(o)= ", dec_TEXT_PDU_40(o));}
 898 }
 899
 900
 901
 902 type union TEXT_PDU_41 {
 903   charstring f1,
 904   charstring f2
 905 } with { encode "TEXT"; variant "BEGIN('Head:'),END(':end')";
 906             variant (f1) "BEGIN('f1:'),END(':1f')"
 907             variant (f2) "BEGIN('f2:'),END(':2f')" };
 908 external function enc_TEXT_PDU_41(in TEXT_PDU_41 pdu, out charstring cs) with { extension "prototype(fast) encode(TEXT)" }
 909 external function dec_TEXT_PDU_41(in charstring cs, out TEXT_PDU_41 pdu) with { extension "prototype(fast) decode(TEXT)" }
 910
 911 testcase TC_implicit_message_encoding_prototype_fast_1() runs on TempComp {
 912   const TEXT_PDU_41     i := {f1:="value1"}
 913   const charstring      o := "Head:f1:value1:1f:end"
 914   const TEXT_PDU_41  expected_res:= {f1:="value1"}
 915
 916   var charstring res;
 917   enc_TEXT_PDU_41(i, res);
 918   var TEXT_PDU_41 dec_pdu;
 919   dec_TEXT_PDU_41(o, dec_pdu);
 920
 921   if ((res == o)and(dec_pdu == expected_res)) {setverdict(pass);}
 922   else {setverdict(fail,"enc_TEXT_PDU_41(i)= ", res, "; dec_TEXT_PDU_41(o)= ", dec_pdu);}
 923 }
 924
 925 testcase TC_implicit_message_encoding_prototype_fast_2() runs on TempComp {
 926   const charstring      o := "Head:f2:value2:2f:end"
 927   const TEXT_PDU_41  expected_res:= {f2:="value2"}
 928
 929   var TEXT_PDU_41 dec_pdu;
 930   dec_TEXT_PDU_41(o, dec_pdu);
 931
 932   if (dec_pdu == expected_res) {setverdict(pass);}
 933   else {setverdict(fail,"; dec_TEXT_PDU_41(o)= ", dec_pdu);}
 934 }
 935
 936
 937
 938 type integer TEXT_PDU_42 with { encode "TEXT"; variant "TEXT_CODING()" };
 939 external function enc_TEXT_PDU_42(in TEXT_PDU_42 pdu, out charstring cs)
 940    with { extension "prototype(fast) encode(TEXT)" }
 941 external function dec_TEXT_PDU_42(in charstring cs, out TEXT_PDU_42 pdu) return integer
 942    with { extension "prototype(backtrack) decode(TEXT) errorbehavior(ALL:WARNING)" }
 943
 944 testcase TC_implicit_message_encoding_prototype_backtrack() runs on TempComp {
 945   var TEXT_PDU_42 bs := 42;
 946   var TEXT_PDU_42 decoded_bs;
 947   var charstring enc_bs;
 948   var integer ret_val;
 949   var charstring invalid_enc_bs := "bruhaha";
 950
 951   enc_TEXT_PDU_42(bs, enc_bs);
 952   ret_val := dec_TEXT_PDU_42(enc_bs, decoded_bs);
 953   if (ret_val==0) { setverdict(pass); } else { setverdict(fail); }
 954   if (decoded_bs==bs) { setverdict(pass); } else { setverdict(fail); }
 955   ret_val := dec_TEXT_PDU_42(invalid_enc_bs, decoded_bs);
 956   if (ret_val==1) { setverdict(pass); } else { setverdict(fail); }
 957 }
 958
 959
 960
 961 type integer TEXT_PDU_43 with { encode "TEXT"; variant "TEXT_CODING(length=4)" };
 962 external function dec_TEXT_PDU_43(inout charstring cs, out TEXT_PDU_43 pdu) return integer
 963   with { extension "prototype(sliding) decode(TEXT) errorbehavior(ALL:WARNING)" }
 964
 965 testcase TC_implicit_message_encoding_prototype_sliding() runs on TempComp {
 966   var TEXT_PDU_43 out_pdu;
 967   var charstring enc_pdu1 := "  42  21";
 968   var integer ret_val;
 969
 970   ret_val := dec_TEXT_PDU_43(enc_pdu1, out_pdu);
 971   if (ret_val==0 and out_pdu==42) { setverdict(pass); } else { setverdict(fail); }
 972   ret_val := dec_TEXT_PDU_43(enc_pdu1, out_pdu);
 973   if (ret_val==0 and out_pdu==21) { setverdict(pass); } else { setverdict(fail); }
 974   ret_val := dec_TEXT_PDU_43(enc_pdu1, out_pdu);
 975 }
 976
 977
 978 control {
 979 execute (TC_Fixed_length_encoding());
 980 execute (TC_Convert_string_to_lower_case_during_encoding());
 981 execute (TC_Convert_string_to_upper_case_during_encoding());
 982 execute (TC_Convert_string_to_lower_case_during_encoding_and_upper_during_decoding());
 983 execute (TC_Convert_string_to_upper_case_during_encoding_and_lower_during_decoding());
 984 execute (TC_Left_justification());
 985 execute (TC_Center_justification());
 986 execute (TC_Right_justification());
 987 execute (TC_Case_sensitive_selection());
 988 execute (TC_Case_insensitive_selection());
 989 execute (TC_Fixed_length_integer());
 990 execute (TC_Variable_length_integer());
 991 execute (TC_encoding_without_leading_zero());
 992 execute (TC_encoding_with_leading_zero());
 993 execute (TC_encoding_negativ_integer_with_leading_zero());
 994 execute (TC_Selection_of_integer_value());
 995 execute (TC_basic_encoding_of_true_value());
 996 execute (TC_basic_encoding_of_false_value());
 997 execute (TC_Encoding_and_decoding_of_given_tokens_1());
 998 execute (TC_Encoding_and_decoding_of_given_tokens_2());
 999 execute (TC_Basic_encoding_of_enumerated_values());
1000 execute (TC_Encoding_of_given_enumerated_values_1());
1001 execute (TC_Encoding_of_given_enumerated_values_2());
1002 execute (TC_Encoding_of_given_enumerated_values_3());
1003 execute (TC_Coding_with_leading_token());
1004 execute (TC_Coding_with_leading_token_case_insensitive_decoding());
1005 execute (TC_Coding_with_leading_token_case_insensitive_decoding_1());
1006 execute (TC_Coding_with_leading_token_case_insensitive_decoding_2());
1007 execute (TC_Coding_with_trailing_token());
1008 execute (TC_Coding_with_trailing_token_case_insensitive_decoding());
1009 execute (TC_Coding_with_trailing_token_using_decoding_matching_pattern());
1010 execute (TC_Coding_with_separator_token());
1011 execute (TC_Coding_with_separator_token_case_insensitive_decoding());
1012 execute (TC_Coding_with_separator_token_1());
1013 execute (TC_Coding_with_separator_token_2());
1014 execute (TC_Record_with_BEGIN_END_token());
1015 execute (TC_Record_with_record_fields());
1016 execute (TC_Record_with_optional_fields_1());
1017 execute (TC_Record_with_optional_fields_2());
1018 execute (TC_Set_with_BEGIN_END_token());
1019 execute (TC_Set_with_BEGIN_END_token_1());
1020 execute (TC_Set_with_BEGIN_END_token_2());
1021 execute (TC_Set_with_optional_fields_1());
1022 execute (TC_Set_with_optional_fields_2());
1023 execute (TC_Set_with_set_of_type_fields_1());
1024 execute (TC_Set_with_set_of_type_fields_2());
1025 execute (TC_Set_with_set_of_type_fields_3());
1026 execute (TC_Record_of_with_BEGIN_END_token());
1027 execute (TC_Record_of_with_record_fields());
1028 execute (TC_Empty_Record_of());
1029 execute (TC_Union_with_BEGIN_END_token_1());
1030 execute (TC_Union_with_BEGIN_END_token_2());
1031 execute (TC_implicit_message_encoding_prototype_fast_1());
1032 execute (TC_implicit_message_encoding_prototype_fast_2());
1033 execute (TC_implicit_message_encoding_prototype_backtrack());
1034 execute (TC_implicit_message_encoding_prototype_sliding());
1035 }
1036
1037 <RESULT>
1038 Overall verdict: pass
1039 <END_TC>
1040
1041 :exmp.
1042
1043 .*---------------------------------------------------------------------*
1044 :h2. Encoding/decoding of big integers
1045 .*---------------------------------------------------------------------*
1046 .*---------------------------------------------------------------------*
1047 :h3.Big integer fields
1048 .*---------------------------------------------------------------------*
1049 :xmp tab=0.
1050
1051
1052 <TC - big integers: big integer fields>
1053 <STATIC>
1054
1055 external function enc_text(in rec_text r) return charstring
1056   with { extension "encode(TEXT) prototype(convert) errorbehavior(ALL:WARNING)" }
1057 external function dec_text(in charstring r) return rec_text
1058   with { extension "decode(TEXT) prototype(convert) errorbehavior(ALL:WARNING)" }
1059
1060 type integer myint1 with {
1061   variant "BEGIN('<myint>')"
1062   variant "END('</myint>')"
1063   encode "TEXT" }
1064
1065 type integer myint2 with {
1066   variant "BEGIN('<myint_dummy>')"
1067   variant "END('</myint_dummy>')"
1068   variant "TEXT_CODING(length=128;leading0=true)"
1069   encode "TEXT" }
1070
1071 type integer myint3 with {
1072   variant "BEGIN('<myint_super>')"
1073   variant "END('</myint_super>')"
1074   encode "TEXT" }
1075
1076 type integer myint4 with {
1077   variant "TEXT_CODING(length=256)"
1078   variant "BEGIN('<myint_pad>')"
1079   variant "END('</myint_pad>')"
1080   encode "TEXT" }
1081
1082 type record rec_text {
1083   myint1 int1,
1084   myint1 int2,
1085   myint2 int3 optional,
1086   myint3 int4 optional,
1087   myint4 int5 optional
1088 } with {
1089   variant "BEGIN('<rec_text>')"
1090   // `variant "SEPARATOR(',')"' is not necessary if the fields can be found
1091   // unambigously.
1092   variant "END('</rec_text>')"
1093   encode "TEXT" }
1094
1095 <TTCN_TC:EXEC>
1096   const integer a := 214748364799
1097   const integer b := 214748364788
1098   const integer c := 0
1099   // Implicit `omit' would be great.
1100   var rec_text myrec1 := {int1 := 214748364799, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}
1101   var rec_text myrec2 := {214748364799, 214748364788, omit, omit, omit}
1102   var rec_text myrec3 := {214748364799, 0, omit, omit, omit}
1103   var rec_text myrec4 := {int1 := 214748364799, int2 := 0, int3 := omit, int4 := omit, int5 := omit}
1104   var rec_text myrec5 := {int1 := 0, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}
1105   var rec_text myrec6 := {0, 214748364788, omit, omit, omit}
1106   var rec_text myrec7 := {0, 0, omit, omit, omit}
1107   var rec_text myrec8 := {int1 := 0, int2 := 0, int3 := omit, int4 := omit, int5 := omit}
1108   var rec_text myrec9 := {int1 := a, int2 := b, int3 := omit, int4 := omit, int5 := omit}
1109   var rec_text myrec10 := {a, b, omit, omit, omit}
1110   // The original `sprintf' encoder encodes negative values `-' <padding>
1111   // `0123456'.  We should work similarly.
1112   var rec_text myrec11 := {
1113     int1 := -11111111111111111111111111111,
1114     int2 := 22222222222222222222222222222,
1115     int3 := -33333333333333333333333333333,
1116     int4 := 2147483648,
1117     int5 := -2147483648 }
1118   var rec_text myrec12 := {int1 := 0, int2 := 0, int3 := 0, int4 := -1111111111111111111111111111111, int5 := -1234567891011121314151617181920}
1119   var rec_text myrec13 := {-0, -0, -0, -0, -0}
1120   var rec_text myrec14 := {-0, -1, 1234567891011121314151617181920, -1111111111111111111111111111111, -0}
1121   var rec_text myrec15 := {int1 := 1111111111111111111111111111111, int2 := -1234567891011121314151617181920, int3 := 0, int4 := -0, int5 := -111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111}
1122   var charstring ret_val
1123   ret_val := enc_text(myrec1)
1124   if (dec_text(ret_val) == myrec1) { setverdict(pass) } else { setverdict(fail) }
1125   if (dec_text(ret_val) == {int1 := 214748364799, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1126   ret_val := enc_text(myrec2)
1127   if (dec_text(ret_val) == myrec2) { setverdict(pass) } else { setverdict(fail) }
1128   if (dec_text(ret_val) == {214748364799, 214748364788, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1129   ret_val := enc_text(myrec3)
1130   if (dec_text(ret_val) == myrec3) { setverdict(pass) } else { setverdict(fail) }
1131   if (dec_text(ret_val) == {214748364799, 0, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1132   ret_val := enc_text(myrec4)
1133   if (dec_text(ret_val) == myrec4) { setverdict(pass) } else { setverdict(fail) }
1134   if (dec_text(ret_val) == {int1 := 214748364799, int2 := 0, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1135   ret_val := enc_text(myrec5)
1136   if (dec_text(ret_val) == myrec5) { setverdict(pass) } else { setverdict(fail) }
1137   if (dec_text(ret_val) == {int1 := 0, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1138   ret_val := enc_text(myrec6)
1139   if (dec_text(ret_val) == myrec6) { setverdict(pass) } else { setverdict(fail) }
1140   if (dec_text(ret_val) == {0, 214748364788, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1141   ret_val := enc_text(myrec7)
1142   if (dec_text(ret_val) == myrec7) { setverdict(pass) } else { setverdict(fail) }
1143   if (dec_text(ret_val) == {0, 0, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1144   ret_val := enc_text(myrec8)
1145   if (dec_text(ret_val) == myrec8) { setverdict(pass) } else { setverdict(fail) }
1146   if (dec_text(ret_val) == {int1 := 0, int2 := 0, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1147   ret_val := enc_text(myrec9)
1148   if (dec_text(ret_val) == myrec9) { setverdict(pass) } else { setverdict(fail) }
1149   if (dec_text(ret_val) == {int1 := a, int2 := b, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1150   ret_val := enc_text(myrec10)
1151   if (dec_text(ret_val) == myrec10) { setverdict(pass) } else { setverdict(fail) }
1152   if (dec_text(ret_val) == {a, b, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1153   ret_val := enc_text(myrec11)
1154   if (dec_text(ret_val) == myrec11) { setverdict(pass) } else { setverdict(fail) }
1155   if (dec_text(ret_val) == {int1 := -11111111111111111111111111111, int2 := 22222222222222222222222222222, int3 := -33333333333333333333333333333, int4 := 2147483648, int5 := -2147483648}) { setverdict(pass) } else { setverdict(fail) }
1156   ret_val := enc_text(myrec12)
1157   if (dec_text(ret_val) == myrec12) { setverdict(pass) } else { setverdict(fail) }
1158   if (dec_text(ret_val) == {int1 := 0, int2 := 0, int3 := 0, int4 := -1111111111111111111111111111111, int5 := -1234567891011121314151617181920}) { setverdict(pass) } else { setverdict(fail) }
1159   ret_val := enc_text(myrec13)
1160   if (dec_text(ret_val) == myrec13) { setverdict(pass) } else { setverdict(fail) }
1161   if (dec_text(ret_val) == {-0, -0, -0, -0, -0}) { setverdict(pass) } else { setverdict(fail) }
1162   ret_val := enc_text(myrec14)
1163   if (dec_text(ret_val) == myrec14) { setverdict(pass) } else { setverdict(fail) }
1164   if (dec_text(ret_val) == {-0, -1, 1234567891011121314151617181920, -1111111111111111111111111111111, -0}) { setverdict(pass) } else { setverdict(fail) }
1165   ret_val := enc_text(myrec15)
1166   if (dec_text(ret_val) == myrec15) { setverdict(pass) } else { setverdict(fail) }
1167   if (dec_text(ret_val) == {int1 := 1111111111111111111111111111111, int2 := -1234567891011121314151617181920, int3 := 0, int4 := -0, int5 := -111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111}) { setverdict(pass) } else { setverdict(fail) }
1168
1169 <RESULT>
1170 Overall verdict: pass
1171 <END_TC>
1172
1173 :exmp.
1174
1175 .*---------------------------------------------------------------------*
1176 :h3.Sliding encoding/decoding of big integers
1177 .*---------------------------------------------------------------------*
1178 :xmp tab=0.
1179
1180
1181 <TC - big integers: sliding encoding/decoding of big integers>
1182 <STATIC>
1183
1184 external function dec_text_sliding(inout charstring r, out myint5 s) return integer
1185   with { extension "prototype(sliding) decode(TEXT) errorbehavior(ALL:WARNING)" }
1186
1187 type integer myint5 with { encode "TEXT"; variant "TEXT_CODING(length=25)" }
1188
1189 <TTCN_TC:EXEC>
1190   var myint5 decoded
1191   var charstring encoded := "  12345678910111213141516    -11111111111111111111"
1192   var integer ret_val
1193   var template integer intt := 12345678910111213141516
1194   ret_val := dec_text_sliding(encoded, decoded)
1195   if (ret_val == 0 and decoded == 12345678910111213141516) {setverdict(pass)}
1196   else {setverdict(fail)}
1197   ret_val := dec_text_sliding(encoded, decoded)
1198   if (ret_val == 0 and decoded == -11111111111111111111) {setverdict(pass)}
1199   else {setverdict(fail)}
1200   ret_val := dec_text_sliding(encoded, decoded)
1201   if (match(12345678910111213141516, intt)) {setverdict(pass)}
1202   else {setverdict(fail)}
1203
1204 <RESULT>
1205 Overall verdict: pass
1206 <END_TC>
1207
1208 :exmp.
1209 .*---------------------------------------------------------------------*
1210 :h1.REFERENCES
1211 .*---------------------------------------------------------------------*
1212 :nl. Requirement specification(s):
1213 :nl.-------------------------------
1214 :list.
1215 :li. 3/ETH/RUS-2003:0087 Uen - Requirement Specification for TITAN's TTCN-3 Semantic Analyser
1216 :elist.
1217
1218 :etext.