regression_test/predefFunction/int_to_OK.ttcn

   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 module int_to_OK {
   9
  10 type component PDTestComponent {};
  11
  12
  13 /*--- INT2BIT --------------------------------------------------*/
  14
  15 const     bitstring i2bcon := '0000011111000001111100001111'B
  16
  17 modulepar bitstring i2bpar := '0000011111000001111100001111'B
  18 modulepar bitstring i2bpar1 := int2bit(0,10);
  19 modulepar bitstring i2bpar2 := int2bit(0,0);
  20 modulepar bitstring i2bpar3 := int2bit(1,1)
  21 modulepar bitstring i2bpar4 := int2bit(255,8)
  22 modulepar bitstring i2bpar5 := int2bit(bit2int(i2bcon),lengthof(i2bcon))
  23 modulepar bitstring i2bpar6 := not4b int2bit(bit2int(not4b i2bcon),lengthof(i2bcon))
  24 modulepar bitstring i2bpar7 := int2bit(bit2int(substr(i2bcon,0,lengthof(i2bcon)/2)),lengthof(i2bcon)/2)
  25 modulepar bitstring i2bpar8 := int2bit(bit2int(substr(i2bcon,  lengthof(i2bcon)/2,  lengthof(i2bcon)/2)),lengthof(i2bcon)/2)
  26
  27 testcase int_to_bit() runs on PDTestComponent{
  28         var integer i1 := 12345678910111213141516
  29         var bitstring bs1 := '00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B
  30         var bitstring bs2 := '010100111010100001010110110010101101000100100110010100010111011111000001100'B
  31         if ((i2bpar1 == '0000000000'B)
  32         and (i2bpar1 == int2bit(0,10)))
  33              {setverdict(pass);}
  34         else {setverdict(fail, __LINE__);}
  35         if ((i2bpar2 == ''B)and (i2bpar2 ==  int2bit(0,0)))
  36              {setverdict(pass);}
  37         else {setverdict(fail, __LINE__);}
  38         if ((i2bpar3 == '1'B)and (i2bpar3 ==  int2bit(1,1)))
  39              {setverdict(pass);}
  40         else {setverdict(fail, __LINE__);}
  41         if ((i2bpar4 == '11111111'B)and (i2bpar4 ==  int2bit(255,8)))
  42              {setverdict(pass);}
  43         else {setverdict(fail, __LINE__);}
  44         if ((i2bpar5 == i2bpar)and (i2bpar5 ==  int2bit(bit2int(i2bpar),lengthof(i2bpar))))
  45              {setverdict(pass);}
  46         else {setverdict(fail, __LINE__);}
  47         if ((i2bpar6 == i2bpar)and (i2bpar5 ==  not4b int2bit(bit2int(not4b i2bpar),lengthof(i2bpar))))
  48              {setverdict(pass);}
  49         else {setverdict(fail, __LINE__);}
  50         if (i2bpar == (i2bpar7 & i2bpar8))
  51              {setverdict(pass);}
  52         else {setverdict(fail, __LINE__);}
  53         if (int2bit(i1, 92) == bs1)
  54              {setverdict(pass);}
  55         else {setverdict(fail, __LINE__);}
  56         /* compile-time
  57         if (int2bit(12345678910111213141516, 92) == '00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B)
  58              {setverdict(pass);}
  59         else {setverdict(fail, __LINE__);}
  60     */
  61         if (int2bit(12345678910111213141516, 92) == bs1)
  62              {setverdict(pass);}
  63         else {setverdict(fail, __LINE__);}
  64         if (int2bit(12345678910111213141516, 75) == bs2)
  65              {setverdict(pass);}
  66         else {setverdict(fail, __LINE__);}
  67 }
  68
  69 /*--- INT2CHAR --------------------------------------------------*/
  70
  71 const integer i2cpari[3] := {0,1,2}
  72
  73 type record of integer i2crtype
  74 const i2crtype i2cparii := {0,1,2}
  75
  76 modulepar charstring i2cpar1 :=  int2char(8 mod 6)
  77 modulepar charstring i2cpar2 :=  int2char(i2cpari[2])
  78 modulepar charstring i2cpar3 :=  int2char(sizeof(i2cpari)-1)
  79 modulepar charstring i2cpar4 :=  int2char(sizeof(i2cparii)-1)
  80
  81 testcase int_to_char() runs on PDTestComponent{
  82
  83         if ((i2cpar1 == int2char(8 mod 6))
  84         and (i2cpar1 == "\ 2"))
  85              {setverdict(pass);}
  86         else {setverdict(fail, __LINE__);}
  87         if ((i2cpar2 == int2char(i2cpari[2]))
  88         and (i2cpar2 == "\ 2"))
  89              {setverdict(pass);}
  90         else {setverdict(fail, __LINE__);}
  91         if ((i2cpar3 == int2char(sizeof(i2cpari)-1))
  92         and (i2cpar3 == "\ 2"))
  93              {setverdict(pass);}
  94         else {setverdict(fail, __LINE__);}
  95         if ((i2cpar4 == int2char(sizeof(i2cparii)-1))
  96         and (i2cpar4 == "\ 2"))
  97              {setverdict(pass);}
  98         else {setverdict(fail, __LINE__);}
  99
 100         var integer j
 101         var charstring c
 102
 103         for (j:=0; j<128; j:=j+1) {
 104                 if (char2int(int2char(j)) == j)
 105                          {setverdict(pass);}
 106                 else {setverdict(fail, __LINE__);}
 107         }
 108
 109 }
 110
 111 /*--- INT2UNICHAR --------------------------------------------------*/
 112
 113
 114
 115 modulepar universal charstring i2uccon1 :=  int2unichar(1)
 116 modulepar universal charstring i2uccon2 :=  int2unichar(256)
 117 modulepar universal charstring i2uccon3 :=  int2unichar(65536)
 118 modulepar universal charstring i2uccon4 :=  int2unichar(16777216)
 119 modulepar universal charstring i2uccon5 :=  int2unichar(2147483647)
 120
 121
 122 testcase int_to_unichar() runs on PDTestComponent{
 123
 124 log (i2uccon1)
 125 log (i2uccon2)
 126 log (i2uccon3)
 127 log (i2uccon4)
 128 log (i2uccon5)
 129
 130         if ((i2uccon1 == int2unichar(1))
 131         and (i2uccon1 == char(0, 0, 0, 1)))
 132              {setverdict(pass);}
 133         else {setverdict(fail, __LINE__);}
 134         if ((i2uccon2 == int2unichar(256))
 135         and (i2uccon2 == char(0, 0, 1, 0)))
 136              {setverdict(pass);}
 137         else {setverdict(fail, __LINE__);}
 138         if ((i2uccon3 == int2unichar(65536))
 139         and (i2uccon3 == char(0, 1, 0, 0)))
 140              {setverdict(pass);}
 141         else {setverdict(fail, __LINE__);}
 142         if ((i2uccon4 == int2unichar(16777216))
 143         and (i2uccon4 == char(1, 0, 0, 0)))
 144              {setverdict(pass);}
 145         else {setverdict(fail, __LINE__);}
 146         if ((i2uccon5 == int2unichar(2147483647))
 147         and (i2uccon5 == char(127, 255, 255, 255)))
 148              {setverdict(pass);}
 149         else {setverdict(fail, __LINE__);}
 150
 151 }
 152
 153
 154 /*--- INT2FLOAT --------------------------------------------------*/
 155
 156
 157 const integer i2fpari[3] := {0,1,2}
 158
 159 type record of integer i2frtype;
 160 const i2frtype i2fparii := {0}
 161
 162 type float i2fflo (-1.0 .. 6.0)
 163
 164 modulepar float i2fpar1 := int2float(3/2)
 165 modulepar float i2fpar2 := int2float(-3)
 166 modulepar float i2fpar3 := int2float(lengthof(""))
 167 modulepar float i2fpar4 := int2float(i2fpari[0])
 168 modulepar float i2fpar5 := int2float(i2fparii[0])
 169 modulepar float i2fpar8 := int2float(2147483648)
 170 modulepar float i2fpar9 := int2float(214748364800)
 171 modulepar float i2fpar10 := int2float(4294967296)
 172
 173 modulepar i2fflo i2fpar6 := int2float(20/3)
 174 modulepar i2fflo i2fpar7 := int2float(8 mod 6)
 175
 176 testcase int_to_float() runs on PDTestComponent{
 177
 178         if ((i2fpar1 == 1.0)
 179         and (i2fpar1 == int2float(3/2)))
 180              {setverdict(pass);}
 181         else {setverdict(fail, __LINE__);}
 182         if ((i2fpar2 == -3.0)
 183         and (i2fpar2 == -3E0))
 184              {setverdict(pass);}
 185         else {setverdict(fail, __LINE__);}
 186         if ((i2fpar3 == 0.0)
 187         and (i2fpar3 == int2float(lengthof(""))))
 188              {setverdict(pass);}
 189         else {setverdict(fail, __LINE__);}
 190         if ((i2fpar4 == 0.0)
 191         and (i2fpar4 == int2float(i2fpari[0])))
 192              {setverdict(pass);}
 193         else {setverdict(fail, __LINE__);}
 194         if ((i2fpar5 == 0.0)
 195         and (i2fpar5 == int2float(i2fparii[0])))
 196              {setverdict(pass);}
 197         else {setverdict(fail, __LINE__);}
 198         if ((i2fpar6 == 6.0)
 199         and (i2fpar6 == int2float(20/3)))
 200              {setverdict(pass);}
 201         else {setverdict(fail, __LINE__);}
 202         if ((i2fpar7 == 2.0)
 203         and (i2fpar7 == int2float(8 mod 6)))
 204              {setverdict(pass);}
 205         else {setverdict(fail, __LINE__);}
 206     if ((i2fpar8 == 2147483648.0)
 207         and (i2fpar8 == int2float(2147483648)))
 208              {setverdict(pass);}
 209         else {setverdict(fail, __LINE__);}
 210     if ((i2fpar9 == 214748364800.0)
 211         and (i2fpar9 == int2float(214748364800)))
 212              {setverdict(pass);}
 213         else {setverdict(fail, __LINE__);}
 214     if ((i2fpar10 == 4294967296.0)
 215         and (i2fpar10 == int2float(4294967296)))
 216              {setverdict(pass);}
 217         else {setverdict(fail, __LINE__);}
 218     var float i2fvar1 := 2147483648.0
 219     var float i2fvar2 := 214748364800.0
 220     var float i2fvar3 := 4294967296.0
 221     if ((i2fvar1 == 2147483648.0)
 222         and (i2fvar1 == int2float(2147483648)))
 223              {setverdict(pass);}
 224         else {setverdict(fail, __LINE__);}
 225     if ((i2fvar2 == 214748364800.0)
 226         and (i2fvar2 == int2float(214748364800)))
 227              {setverdict(pass);}
 228         else {setverdict(fail, __LINE__);}
 229     if ((i2fvar3 == 4294967296.0)
 230         and (i2fvar3 == int2float(4294967296)))
 231              {setverdict(pass);}
 232         else {setverdict(fail, __LINE__);}
 233
 234 }
 235
 236 /*--- INT2HEX --------------------------------------------------*/
 237
 238 const     hexstring i2hcon := '0123456'H
 239 modulepar hexstring i2hpar := '0123456'H
 240 modulepar hexstring i2hpar1 := int2hex(0,10)
 241 modulepar hexstring i2hpar2 := int2hex(0,0)
 242 modulepar hexstring i2hpar3 := int2hex(15,1)
 243 modulepar hexstring i2hpar4 := int2hex(hex2int(i2hcon),lengthof(i2hcon))
 244 modulepar integer i2hpari := hex2int(i2hcon)
 245
 246 testcase int_to_hex() runs on PDTestComponent{
 247         var integer i1 := 12345678910111213141516
 248         var hexstring hs1 := '000000000000029D42B65689328BBE0C'H
 249         var hexstring hs2 := '029D42B65689328BBE0C'H
 250         if ((i2hpar1 == '0000000000'H)
 251         and (i2hpar1 == int2hex(0,10)))
 252              {setverdict(pass);}
 253         else {setverdict(fail, __LINE__);}
 254         if ((i2hpar2 == ''H) and (i2hpar2 ==  int2hex(0,0)))
 255              {setverdict(pass);}
 256         else {setverdict(fail, __LINE__);}
 257         if ((i2hpar3 == 'F'H)
 258         and (i2hpar3 == int2hex(15,1)))
 259              {setverdict(pass);}
 260         else {setverdict(fail, __LINE__);}
 261         if ((i2hpar4 == i2hpar)
 262         and (i2hpar4 == int2hex(hex2int(i2hpar),lengthof(i2hpar))))
 263              {setverdict(pass);}
 264         else {setverdict(fail, __LINE__);}
 265         if (int2hex(i1, 32) == hs1) { setverdict(pass) } else { setverdict(fail, __LINE__) }
 266         //compile-time: if (int2hex(12345678910111213141516, 32) == '000000000000029D42B65689328BBE0C'H) { setverdict(pass) } else { setverdict(fail, __LINE__) }
 267         if (int2hex(12345678910111213141516, 32) == hs1) { setverdict(pass) } else { setverdict(fail, __LINE__) }
 268         if (int2hex(12345678910111213141516, 20) == hs2) { setverdict(pass) } else { setverdict(fail, __LINE__) }
 269 }
 270
 271 /*--- INT2OCT --------------------------------------------------*/
 272
 273 const     octetstring i2ocon := '12345678'O
 274 modulepar octetstring i2opar := '12345678'O
 275 modulepar octetstring i2opar1 := int2oct(0,10)
 276 modulepar octetstring i2opar2 := int2oct(0,0)
 277 modulepar octetstring i2opar3 := int2oct(15,1)
 278 modulepar octetstring i2opar4 := int2oct(oct2int(i2ocon),lengthof(i2ocon))
 279 modulepar octetstring i2opar5 := int2oct(33,8);
 280 modulepar integer i2opari := oct2int(i2ocon)
 281
 282 testcase int_to_oct() runs on PDTestComponent{
 283     var integer i1 := 881883119815076896174081;
 284     var octetstring os1 := '00000000000000000000000000000000000000000000BABEFACEDECAFBADF001'O
 285     var octetstring os2 := 'BABEFACEDECAFBADF001'O
 286         if ((i2opar1 == '00000000000000000000'O)
 287         and (i2opar1 == int2oct(0,10)))
 288              {setverdict(pass);}
 289         else {setverdict(fail, __LINE__);}
 290         if ((i2opar2 == ''O)and (i2opar2 ==  int2oct(0,0)))
 291              {setverdict(pass);}
 292         else {setverdict(fail, __LINE__);}
 293         if ((i2opar3 == '0F'O)
 294         and (i2opar3 == int2oct(15,1)))
 295              {setverdict(pass);}
 296         else {setverdict(fail, __LINE__);}
 297         if (i2opar5 == '0000000000000021'O)
 298              {setverdict(pass);}
 299         else {setverdict(fail, __LINE__);}
 300         if ((i2opar4 == i2opar)
 301         and (i2opar4 == int2oct(oct2int(i2opar),lengthof(i2opar))))
 302              {setverdict(pass);}
 303         else {setverdict(fail, __LINE__);}
 304         log(i1);
 305         log(int2oct(i1, 32));
 306         log(os1);
 307         if (int2oct(i1, 32) == os1) { setverdict(pass) } else { setverdict(fail, __LINE__, match(int2oct(i1, 32) , os1)) }
 308         //compile-time: if (int2oct(12345678910111213141516, 32) == '00000000000000000000000000000000000000000000029D42B65689328BBE0C'O) { setverdict(pass) } else { setverdict(fail, __LINE__) }
 309         if (int2oct(881883119815076896174081, 32) == os1) { setverdict(pass) } else { setverdict(fail, __LINE__) }
 310         if (int2oct(881883119815076896174081, 10) == os2) { setverdict(pass) } else { setverdict(fail, __LINE__) }
 311 }
 312
 313 /*--- INT2STR --------------------------------------------------*/
 314
 315 const     charstring i2scon :=  "1234567890"
 316 modulepar charstring i2spar :=  "1234567890"
 317 modulepar charstring i2spar1 := int2str(0)
 318 modulepar charstring i2spar2 := int2str(-1)
 319 modulepar charstring i2spar3 := int2str(16 mod 3)
 320 modulepar charstring i2spar4 := int2str(16 rem 3)
 321 modulepar charstring i2spar5 := int2str(lengthof(i2scon))
 322
 323 const     integer i2sconi := str2int(i2scon)
 324
 325 modulepar charstring i2spar6 := int2str(i2sconi)
 326 const     charstring i2scon7 := "1234567891011121314151617181920"
 327 modulepar charstring i2spar7 := "1234567891011121314151617181920"
 328 const     charstring i2scon8 := "-1234567891011121314151617181920"  // Negative values.
 329 modulepar charstring i2spar8 := "-1234567891011121314151617181920"  // Negative values.
 330 modulepar integer i2spari1 := str2int(i2scon7)
 331 modulepar integer i2spari2 := str2int(i2scon8)
 332
 333 testcase int_to_str() runs on PDTestComponent{
 334
 335         var charstring cc := int2str(i2sconi)
 336         var charstring vv := "1234567891011121314151617181920"
 337         var charstring vv1 := "-1234567891011121314151617181920"
 338         var integer ii := str2int(vv)
 339         var integer ii1 := str2int(vv1)
 340
 341         if ((i2spar1 == "0")
 342         and (i2spar1 == int2str(0)))
 343              {setverdict(pass);}
 344         else {setverdict(fail, __LINE__);}
 345         if ((i2spar2 == "-1")
 346         and (i2spar2 == int2str(-1)))
 347              {setverdict(pass);}
 348         else {setverdict(fail, __LINE__);}
 349         if ((i2spar3 == "1")
 350         and (i2spar3 == int2str(16 mod 3)))
 351              {setverdict(pass);}
 352         else {setverdict(fail, __LINE__);}
 353         if ((i2spar4 == "1")
 354         and (i2spar4 == int2str(16 rem 3)))
 355              {setverdict(pass);}
 356         else {setverdict(fail, __LINE__);}
 357         if ((i2spar5 == "10")
 358         and (i2spar5 == int2str(lengthof(i2spar))))
 359              {setverdict(pass);}
 360         else {setverdict(fail, __LINE__);}
 361         if ((i2spar6 == i2spar)
 362         and (i2spar6 == int2str(i2sconi)))
 363              {setverdict(pass);}
 364         else {setverdict(fail, __LINE__);}
 365         // Compile time evaluation.  (Positive/negative.)
 366         if ((i2spar7 == int2str(1234567891011121314151617181920)
 367         and (int2str(1234567891011121314151617181920) == i2spar7)))
 368              {setverdict(pass);}
 369         else {setverdict(fail, __LINE__);}
 370         if ((int2str(1234567891011121314151617181930 - 10) == i2spar7)
 371         and (i2spar7 == int2str(1234567891011121314151617181930 - 10)))
 372              {setverdict(pass);}
 373         else {setverdict(fail, __LINE__);}
 374         if ((i2spar7 == int2str(i2spari1)
 375         and (int2str(i2spari1) == i2spar7)))
 376              {setverdict(pass);}
 377         else {setverdict(fail, __LINE__);}
 378         if ((int2str(i2spari1 + 10 - 10) == i2spar7)
 379         and (i2spar7 == int2str(i2spari1 + 10 - 10)))
 380              {setverdict(pass);}
 381         else {setverdict(fail, __LINE__);}
 382         if ((i2spar8 == int2str(-1234567891011121314151617181920)
 383         and (int2str(1234567891011121314151617181920) == i2spar7)))
 384              {setverdict(pass);}
 385         else {setverdict(fail, __LINE__);}
 386         if ((int2str(-1234567891011121314151617181930 + 10) == i2spar8)
 387         and (i2spar8 == int2str(-1234567891011121314151617181930 + 10)))
 388              {setverdict(pass);}
 389         else {setverdict(fail, __LINE__);}
 390         if ((i2spar8 == int2str(i2spari2)
 391         and (int2str(i2spari2) == i2spar8)))
 392              {setverdict(pass);}
 393         else {setverdict(fail, __LINE__);}
 394         if ((int2str(i2spari2 + 10 - 10) == i2spar8)
 395         and (i2spar8 == int2str(i2spari2 + 10 - 10)))
 396              {setverdict(pass);}
 397         else {setverdict(fail, __LINE__);}
 398         // Run-time evaluation.  (Positive/negative.)
 399         if ((vv == int2str(1234567891011121314151617181920)
 400         and (int2str(1234567891011121314151617181920) == vv)))
 401              {setverdict(pass);}
 402         else {setverdict(fail, __LINE__);}
 403         if ((int2str(1234567891011121314151617181910 + 10) == vv)
 404         and (vv == int2str(1234567891011121314151617181910 + 10)))
 405              {setverdict(pass);}
 406         else {setverdict(fail, __LINE__);}
 407         if ((vv == int2str(ii)
 408         and (int2str(1234567891011121314151617181920) == vv)))
 409              {setverdict(pass);}
 410         else {setverdict(fail, __LINE__);}
 411         if ((int2str(ii + 10 - 10) == vv)
 412         and (vv == int2str(ii + 10 - 10)))
 413              {setverdict(pass);}
 414         else {setverdict(fail, __LINE__);}
 415         if ((i2spari1 == ii)
 416         and (ii == i2spari1))
 417              {setverdict(pass);}
 418         else {setverdict(fail, __LINE__);}
 419         if ((int2str(i2spari1) == int2str(ii))
 420         and (int2str(ii) == int2str(i2spari1)))
 421              {setverdict(pass);}
 422         else {setverdict(fail, __LINE__);}
 423         if ((vv1 == int2str(-1234567891011121314151617181920)
 424         and (int2str(-1234567891011121314151617181920) == vv1)))
 425              {setverdict(pass);}
 426         else {setverdict(fail, __LINE__);}
 427         if ((int2str(-1234567891011121314151617181910 - 10) == vv1)
 428         and (vv1 == int2str(-1234567891011121314151617181910 - 10)))
 429              {setverdict(pass);}
 430         else {setverdict(fail, __LINE__);}
 431         if ((vv1 == int2str(ii1)
 432         and (int2str(-1234567891011121314151617181920) == vv1)))
 433              {setverdict(pass);}
 434         else {setverdict(fail, __LINE__);}
 435         if ((int2str(ii1 + 10 - 10) == vv1)
 436         and (vv1 == int2str(ii1 + 10 - 10)))
 437              {setverdict(pass);}
 438         else {setverdict(fail, __LINE__);}
 439         if ((i2spari2 == ii1)
 440         and (ii1 == i2spari2))
 441              {setverdict(pass);}
 442         else {setverdict(fail, __LINE__);}
 443         if ((int2str(i2spari2) == int2str(ii1))
 444         and (int2str(ii1) == int2str(i2spari2)))
 445              {setverdict(pass);}
 446         else {setverdict(fail, __LINE__);}
 447 }
 448
 449
 450
 451
 452 control {
 453         execute (int_to_bit());
 454         execute (int_to_char());
 455         execute (int_to_unichar());
 456
 457         execute (int_to_float());
 458         execute (int_to_hex());
 459         execute (int_to_oct());
 460         execute (int_to_str());
 461 }
 462
 463 }