regression_test/RAW/Annex_E_variants/Annex_E_variants.ttcn

   1 /******************************************************************************
   2  * Copyright (c) 2000-2015 Ericsson Telecom AB
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  ******************************************************************************/
   8
   9 // This module contains tests for the variant attributes defined in Annex E of the
  10 // TTCN-3 language standard.
  11 // The encoding of the types with the new variants are compared to the encoding of
  12 // types declared using traditional RAW variant attributes.
  13
  14 // New attributes and their equivalents:
  15 // "N bit" == "FIELDLENGTH(N), COMP(signbit), BYTEORDER(last)"
  16 // "unsigned N bit" == "FIELDLENGTH(N), COMP(nosign), BYTEORDER(last)"
  17 module Annex_E_variants {
  18
  19 // E.2.1.0 Signed and unsigned single byte integers
  20 type integer Byte (-128 .. 127) with { variant "8 bit" };
  21 type integer ByteEq (-128 .. 127) with { variant "FIELDLENGTH(8), COMP(signbit), BYTEORDER(last)" };
  22
  23 type integer UnsignedByte (0 .. 255) with { variant "unsigned 8 bit" };
  24 type integer UnsignedByteEq (0 .. 255) with { variant "FIELDLENGTH(8), COMP(nosign), BYTEORDER(last)" };
  25
  26 // E.2.1.1 Signed and unsigned short integers
  27 type integer Short (-32768 .. 32767) with { variant "16 bit" };
  28 type integer ShortEq (-32768 .. 32767) with { variant "FIELDLENGTH(16), COMP(signbit), BYTEORDER(last)" };
  29
  30 type integer UnsignedShort (0 .. 65535) with { variant "unsigned 16 bit" };
  31 type integer UnsignedShortEq (0 .. 65535) with { variant "FIELDLENGTH(16), COMP(nosign), BYTEORDER(last)" };
  32
  33 // E.2.1.2 Signed and unsigned long integers
  34 type integer Long (-2147483648 .. 2147483647) with { variant "32 bit" };
  35 type integer LongEq (-2147483648 .. 2147483647) with { variant "FIELDLENGTH(32), COMP(signbit), BYTEORDER(last)" };
  36
  37 type integer UnsignedLong (0 .. 4294967295) with { variant "unsigned 32 bit" };
  38 type integer UnsignedLongEq (0 .. 4294967295) with { variant "FIELDLENGTH(32), COMP(nosign), BYTEORDER(last)" };
  39
  40 // E.2.1.3 Signed and unsigned longlong integers
  41 type integer LongLong (-9223372036854775808 .. 9223372036854775807) with { variant "64 bit" };
  42 type integer LongLongEq (-9223372036854775808 .. 9223372036854775807) with { variant "FIELDLENGTH(64), COMP(signbit), BYTEORDER(last)" };
  43
  44 type integer UnsignedLongLong (0 .. 18446744073709551615) with { variant "unsigned 64 bit" };
  45 type integer UnsignedLongLongEq (0 .. 18446744073709551615) with { variant "FIELDLENGTH(64), COMP(nosign), BYTEORDER(last)" };
  46
  47 // Custom integer types
  48 type integer Int6 with { variant "6 bit" };
  49 type integer Int6Eq with { variant "FIELDLENGTH(6), COMP(signbit), BYTEORDER(last)" };
  50
  51 type integer UInt4 with { variant "unsigned 4 bit" };
  52 type integer UInt4Eq with { variant "FIELDLENGTH(4), COMP(nosign), BYTEORDER(last)" };
  53
  54 type integer BigInt with { variant "300 bit " };
  55 type integer BigIntEq with { variant "FIELDLENGTH(300), COMP(signbit), BYTEORDER(last)" };
  56
  57 // Using the "N bit" attribute on enumerated types
  58 type enumerated Enum5 { val1(1), val7(7), val2(2), val11(11) } with { variant "unsigned 5 bit" };
  59 type enumerated Enum5Eq { val1(1), val7(7), val2(2), val11(11) } with { variant "FIELDLENGTH(5), COMP(nosign), BYTEORDER(last)" };
  60
  61 type enumerated Enum12 { val30(30), valm10(-10), val9(9) } with { variant "12 bit" };
  62 type enumerated Enum12Eq { val30(30), valm10(-10), val9(9) } with { variant "FIELDLENGTH(12), COMP(signbit), BYTEORDER(last)" };
  63
  64 // Using the "N bit" attribute on boolean types
  65 type boolean Bool3 with { variant "3 bit" };
  66 type boolean Bool3Eq with { variant "FIELDLENGTH(3), BYTEORDER(last)" };
  67
  68 type boolean Bool13 with { variant "13 bit" };
  69 type boolean Bool13Eq with { variant "FIELDLENGTH(13), BYTEORDER(last)" };
  70
  71 // Using the "N bit" attribute on string types
  72 type bitstring BStr14 with { variant "14 bit" };
  73 type bitstring BStr14Eq with { variant "FIELDLENGTH(14), BYTEORDER(last)" };
  74
  75 type hexstring HStr20 with { variant "unsigned 20 bit" }; // 20 bits = 5 hex nibbles, 'unsigned' is ignored
  76 type hexstring HStr20Eq with { variant "FIELDLENGTH(5), BYTEORDER(last)" };
  77
  78 type octetstring OStr32 with { variant "32 bit" }; // 32 bits = 4 octets
  79 type octetstring OStr32Eq with { variant "FIELDLENGTH(4), BYTEORDER(last)" };
  80
  81 type charstring CStr64 with { variant "64 bit" }; // 64 bits = 8 characters
  82 type charstring CStr64Eq with { variant "FIELDLENGTH(8), BYTEORDER(last)" };
  83
  84 // Component type
  85 type component CT {}
  86
  87 // Test cases
  88 testcase tc_byte() runs on CT
  89 {
  90   var Byte x := -12;
  91   var ByteEq x_eq := x;
  92   var bitstring enc := encvalue(x);
  93   var bitstring enc_exp := encvalue(x_eq);
  94   if (enc != enc_exp) {
  95     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
  96   }
  97   else {
  98     var Byte dec;
  99     if (decvalue(enc, dec) != 0) {
 100       setverdict(fail, "Could not decode ", enc);
 101     }
 102     else if (dec != x) {
 103       setverdict(fail, "Expected: ", x, ", got: ", dec);
 104     }
 105   }
 106   setverdict(pass);
 107 }
 108
 109 testcase tc_unsigned_byte() runs on CT
 110 {
 111   var UnsignedByte x := 91;
 112   var UnsignedByteEq x_eq := x;
 113   var bitstring enc := encvalue(x);
 114   var bitstring enc_exp := encvalue(x_eq);
 115   if (enc != enc_exp) {
 116     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 117   }
 118   else {
 119     var UnsignedByte dec;
 120     if (decvalue(enc, dec) != 0) {
 121       setverdict(fail, "Could not decode ", enc);
 122     }
 123     else if (dec != x) {
 124       setverdict(fail, "Expected: ", x, ", got: ", dec);
 125     }
 126   }
 127   setverdict(pass);
 128 }
 129
 130 testcase tc_short() runs on CT
 131 {
 132   var Short x := 399;
 133   var ShortEq x_eq := x;
 134   var bitstring enc := encvalue(x);
 135   var bitstring enc_exp := encvalue(x_eq);
 136   if (enc != enc_exp) {
 137     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 138   }
 139   else {
 140     var Short dec;
 141     if (decvalue(enc, dec) != 0) {
 142       setverdict(fail, "Could not decode ", enc);
 143     }
 144     else if (dec != x) {
 145       setverdict(fail, "Expected: ", x, ", got: ", dec);
 146     }
 147   }
 148   setverdict(pass);
 149 }
 150
 151 testcase tc_unsigned_short() runs on CT
 152 {
 153   var UnsignedShort x := 399;
 154   var UnsignedShortEq x_eq := x;
 155   var bitstring enc := encvalue(x);
 156   var bitstring enc_exp := encvalue(x_eq);
 157   if (enc != enc_exp) {
 158     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 159   }
 160   else {
 161     var UnsignedShort dec;
 162     if (decvalue(enc, dec) != 0) {
 163       setverdict(fail, "Could not decode ", enc);
 164     }
 165     else if (dec != x) {
 166       setverdict(fail, "Expected: ", x, ", got: ", dec);
 167     }
 168   }
 169   setverdict(pass);
 170 }
 171
 172 testcase tc_long() runs on CT
 173 {
 174   var Long x := 1457664;
 175   var LongEq x_eq := x;
 176   var bitstring enc := encvalue(x);
 177   var bitstring enc_exp := encvalue(x_eq);
 178   if (enc != enc_exp) {
 179     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 180   }
 181   else {
 182     var Long dec;
 183     if (decvalue(enc, dec) != 0) {
 184       setverdict(fail, "Could not decode ", enc);
 185     }
 186     else if (dec != x) {
 187       setverdict(fail, "Expected: ", x, ", got: ", dec);
 188     }
 189   }
 190   setverdict(pass);
 191 }
 192
 193 testcase tc_unsigned_long() runs on CT
 194 {
 195   var UnsignedLong x := 1457664;
 196   var UnsignedLongEq x_eq := x;
 197   var bitstring enc := encvalue(x);
 198   var bitstring enc_exp := encvalue(x_eq);
 199   if (enc != enc_exp) {
 200     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 201   }
 202   else {
 203     var UnsignedLong dec;
 204     if (decvalue(enc, dec) != 0) {
 205       setverdict(fail, "Could not decode ", enc);
 206     }
 207     else if (dec != x) {
 208       setverdict(fail, "Expected: ", x, ", got: ", dec);
 209     }
 210   }
 211   setverdict(pass);
 212 }
 213
 214 testcase tc_long_long() runs on CT
 215 {
 216   var LongLong x := -9223372036854775807;
 217   var LongLongEq x_eq := x;
 218   var bitstring enc := encvalue(x);
 219   var bitstring enc_exp := encvalue(x_eq);
 220   if (enc != enc_exp) {
 221     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 222   }
 223   else {
 224     var LongLong dec;
 225     if (decvalue(enc, dec) != 0) {
 226       setverdict(fail, "Could not decode ", enc);
 227     }
 228     else if (dec != x) {
 229       setverdict(fail, "Expected: ", x, ", got: ", dec);
 230     }
 231   }
 232   setverdict(pass);
 233 }
 234
 235 testcase tc_unsigned_long_long() runs on CT
 236 {
 237   var UnsignedLongLong x := 18446744073709551610;
 238   var UnsignedLongLongEq x_eq := x;
 239   var bitstring enc := encvalue(x);
 240   var bitstring enc_exp := encvalue(x_eq);
 241   if (enc != enc_exp) {
 242     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 243   }
 244   else {
 245     var UnsignedLongLong dec;
 246     if (decvalue(enc, dec) != 0) {
 247       setverdict(fail, "Could not decode ", enc);
 248     }
 249     else if (dec != x) {
 250       setverdict(fail, "Expected: ", x, ", got: ", dec);
 251     }
 252   }
 253   setverdict(pass);
 254 }
 255
 256 testcase tc_int6() runs on CT
 257 {
 258   var Int6 x := -19;
 259   var Int6Eq x_eq := x;
 260   var bitstring enc := encvalue(x);
 261   var bitstring enc_exp := encvalue(x_eq);
 262   if (enc != enc_exp) {
 263     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 264   }
 265   else {
 266     var Int6 dec;
 267     if (decvalue(enc, dec) != 0) {
 268       setverdict(fail, "Could not decode ", enc);
 269     }
 270     else if (dec != x) {
 271       setverdict(fail, "Expected: ", x, ", got: ", dec);
 272     }
 273   }
 274   setverdict(pass);
 275 }
 276
 277 testcase tc_uint4() runs on CT
 278 {
 279   var UInt4 x := 7;
 280   var UInt4Eq x_eq := x;
 281   var bitstring enc := encvalue(x);
 282   var bitstring enc_exp := encvalue(x_eq);
 283   if (enc != enc_exp) {
 284     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 285   }
 286   else {
 287     var UInt4 dec;
 288     if (decvalue(enc, dec) != 0) {
 289       setverdict(fail, "Could not decode ", enc);
 290     }
 291     else if (dec != x) {
 292       setverdict(fail, "Expected: ", x, ", got: ", dec);
 293     }
 294   }
 295   setverdict(pass);
 296 }
 297
 298 testcase tc_big_int() runs on CT
 299 {
 300   var BigInt x := -2837219487639565876438796348973264327463294623463287046324783264987325432;
 301   var BigIntEq x_eq := x;
 302   var bitstring enc := encvalue(x);
 303   var bitstring enc_exp := encvalue(x_eq);
 304   if (enc != enc_exp) {
 305     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 306   }
 307   else {
 308     var BigInt dec;
 309     if (decvalue(enc, dec) != 0) {
 310       setverdict(fail, "Could not decode ", enc);
 311     }
 312     else if (dec != x) {
 313       setverdict(fail, "Expected: ", x, ", got: ", dec);
 314     }
 315   }
 316   setverdict(pass);
 317 }
 318
 319 testcase tc_enum5() runs on CT
 320 {
 321   var Enum5 x := val11;
 322   var Enum5Eq x_eq := val11;
 323   var bitstring enc := encvalue(x);
 324   var bitstring enc_exp := encvalue(x_eq);
 325   if (enc != enc_exp) {
 326     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 327   }
 328   else {
 329     var Enum5 dec;
 330     if (decvalue(enc, dec) != 0) {
 331       setverdict(fail, "Could not decode ", enc);
 332     }
 333     else if (dec != x) {
 334       setverdict(fail, "Expected: ", x, ", got: ", dec);
 335     }
 336   }
 337   setverdict(pass);
 338 }
 339
 340 testcase tc_enum12() runs on CT
 341 {
 342   var Enum12 x := valm10;
 343   var Enum12Eq x_eq := valm10;
 344   var bitstring enc := encvalue(x);
 345   var bitstring enc_exp := encvalue(x_eq);
 346   if (enc != enc_exp) {
 347     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 348   }
 349   else {
 350     var Enum12 dec;
 351     if (decvalue(enc, dec) != 0) {
 352       setverdict(fail, "Could not decode ", enc);
 353     }
 354     else if (dec != x) {
 355       setverdict(fail, "Expected: ", x, ", got: ", dec);
 356     }
 357   }
 358   setverdict(pass);
 359 }
 360
 361 testcase tc_bool3() runs on CT
 362 {
 363   var Bool3 x := true;
 364   var Bool3Eq x_eq := x;
 365   var bitstring enc := encvalue(x);
 366   var bitstring enc_exp := encvalue(x_eq);
 367   if (enc != enc_exp) {
 368     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 369   }
 370   else {
 371     var Bool3 dec;
 372     if (decvalue(enc, dec) != 0) {
 373       setverdict(fail, "Could not decode ", enc);
 374     }
 375     else if (dec != x) {
 376       setverdict(fail, "Expected: ", x, ", got: ", dec);
 377     }
 378   }
 379   setverdict(pass);
 380 }
 381
 382 testcase tc_bool13() runs on CT
 383 {
 384   var Bool13 x := true;
 385   var Bool13Eq x_eq := x;
 386   var bitstring enc := encvalue(x);
 387   var bitstring enc_exp := encvalue(x_eq);
 388   if (enc != enc_exp) {
 389     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 390   }
 391   else {
 392     var Bool13 dec;
 393     if (decvalue(enc, dec) != 0) {
 394       setverdict(fail, "Could not decode ", enc);
 395     }
 396     else if (dec != x) {
 397       setverdict(fail, "Expected: ", x, ", got: ", dec);
 398     }
 399   }
 400   setverdict(pass);
 401 }
 402
 403 testcase tc_bstr14() runs on CT
 404 {
 405   var BStr14 x := '10101010101010'B;
 406   var BStr14Eq x_eq := x;
 407   var bitstring enc := encvalue(x);
 408   var bitstring enc_exp := encvalue(x_eq);
 409   if (enc != enc_exp) {
 410     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 411   }
 412   else {
 413     var BStr14 dec;
 414     if (decvalue(enc, dec) != 0) {
 415       setverdict(fail, "Could not decode ", enc);
 416     }
 417     else if (dec != x) {
 418       setverdict(fail, "Expected: ", x, ", got: ", dec);
 419     }
 420   }
 421   setverdict(pass);
 422 }
 423
 424 testcase tc_hstr20() runs on CT
 425 {
 426   var HStr20 x := 'CCCCC'H;
 427   var HStr20Eq x_eq := x;
 428   var bitstring enc := encvalue(x);
 429   var bitstring enc_exp := encvalue(x_eq);
 430   if (enc != enc_exp) {
 431     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 432   }
 433   else {
 434     var HStr20 dec;
 435     if (decvalue(enc, dec) != 0) {
 436       setverdict(fail, "Could not decode ", enc);
 437     }
 438     else if (dec != x) {
 439       setverdict(fail, "Expected: ", x, ", got: ", dec);
 440     }
 441   }
 442   setverdict(pass);
 443 }
 444
 445 testcase tc_ostr32() runs on CT
 446 {
 447   var OStr32 x := 'ABABABAB'O;
 448   var OStr32Eq x_eq := x;
 449   var bitstring enc := encvalue(x);
 450   var bitstring enc_exp := encvalue(x_eq);
 451   if (enc != enc_exp) {
 452     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 453   }
 454   else {
 455     var OStr32 dec;
 456     if (decvalue(enc, dec) != 0) {
 457       setverdict(fail, "Could not decode ", enc);
 458     }
 459     else if (dec != x) {
 460       setverdict(fail, "Expected: ", x, ", got: ", dec);
 461     }
 462   }
 463   setverdict(pass);
 464 }
 465
 466 testcase tc_cstr64() runs on CT
 467 {
 468   var CStr64 x := "Hello";
 469   var CStr64Eq x_eq := x;
 470   var bitstring enc := encvalue(x);
 471   var bitstring enc_exp := encvalue(x_eq);
 472   if (enc != enc_exp) {
 473     setverdict(fail, "Expected: ", enc_exp, ", got: ", enc);
 474   }
 475   else {
 476     var CStr64 dec;
 477     var CStr64Eq dec_exp;
 478     if (decvalue(enc, dec) != 0 or decvalue(enc_exp, dec_exp) != 0) {
 479       setverdict(fail, "Could not decode ", enc);
 480     }
 481     else if (dec != dec_exp) {
 482       setverdict(fail, "Expected: ", dec_exp, ", got: ", dec);
 483     }
 484   }
 485   setverdict(pass);
 486 }
 487
 488 // Control part
 489 control {
 490   execute(tc_byte());
 491   execute(tc_unsigned_byte());
 492   execute(tc_short());
 493   execute(tc_unsigned_short());
 494   execute(tc_long());
 495   execute(tc_unsigned_long());
 496   execute(tc_long_long());
 497   execute(tc_unsigned_long_long());
 498   execute(tc_int6());
 499   execute(tc_uint4());
 500   execute(tc_big_int());
 501   execute(tc_enum5());
 502   execute(tc_enum12());
 503   execute(tc_bool3());
 504   execute(tc_bool13());
 505   execute(tc_bstr14());
 506   execute(tc_hstr20());
 507   execute(tc_ostr32());
 508   execute(tc_cstr64());
 509 }
 510
 511 }
 512 with {
 513   encode "RAW";
 514 }