regression_test/ucharstrOper/cstr_content.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 cstr_content {
   9
  10 type component empty {}
  11
  12 external function tc_univ_char_cpp() return integer;
  13
  14 testcase tc_charstring_content() runs on empty {
  15         const charstring cl_s1 := "abcd";
  16         const charstring cl_s2 := "efghi";
  17         const charstring cl_res1 := "abcdefghi";
  18         const charstring cl_res2 := "aefghi";
  19         const universal charstring cl_ures2 := cl_res2;
  20         const charstring cl_res3 := "abcde";
  21         const universal charstring cl_ures3 := cl_res3;
  22         const charstring cl_res4 := "bcda";
  23         const universal charstring cl_ures4 := cl_res4;
  24         const charstring cl_res5 := "dabc";
  25         const universal charstring cl_ures5 := cl_res5;
  26         const universal charstring cl_us1 := char(0,0,1,20) & char(0,0,1,21) & char(0,0,1,22) & char(0,0,1,23) & char(0,0,1,24);
  27         const universal charstring cl_us2 := char(0,0,1,25) & char(0,0,1,26) & char(0,0,1,27) & char(0,0,1,28) & char(0,0,1,29);
  28         const universal charstring cl_us3 := char(0,0,1,20) & char(0,0,1,21) & char(0,0,1,22) & char(0,0,1,23) & char(0,0,1,24) & char(0,0,1,25) & char(0,0,1,26) & char(0,0,1,27) & char(0,0,1,28) & char(0,0,1,29);
  29         const universal charstring cl_us4 := "abcd" & char(0,0,1,20) & char(0,0,1,21) & char(0,0,1,22) & char(0,0,1,23) & char(0,0,1,24);
  30         const universal charstring cl_ures6 := "a" & char(0,0,1,20) & char(0,0,1,21) & char(0,0,1,22) & char(0,0,1,23) & char(0,0,1,24);
  31         const universal charstring cl_ures7 := char(0,0,1,25) & char(0,0,1,20) & char(0,0,1,21) & char(0,0,1,22) & char(0,0,1,23) & char(0,0,1,24);
  32         const universal charstring cl_ures8 := char(0,0,1,20) & char(0,0,1,21) & char(0,0,1,22) & char(0,0,1,23) & char(0,0,1,24) & "a";
  33         var universal charstring vl_us1 := cl_s1;
  34         var universal charstring vl_us2 := cl_s2;
  35         var universal charstring vl_us3 := cl_us1;
  36         var universal charstring vl_res1 := vl_us1 & vl_us2;
  37         log(vl_res1);
  38         if (vl_res1 != cl_res1) { setverdict(fail); }
  39         vl_res1 := vl_us1 & cl_s2;
  40         log(vl_res1);
  41         if (vl_res1 != cl_res1) { setverdict(fail); }
  42         vl_res1 := cl_s1 & vl_us2;
  43         log(vl_res1);
  44         if (vl_res1 != cl_res1) { setverdict(fail); }
  45         vl_res1 := vl_us1[0] & vl_us2;
  46         log(vl_res1);
  47         if (vl_res1 != cl_res2 or vl_res1 != cl_ures2) { setverdict(fail); }
  48         vl_res1 := vl_us1 & vl_us2[0];
  49         log(vl_res1);
  50         if (vl_res1 != cl_res3 or vl_res1 != cl_ures3) { setverdict(fail); }
  51         vl_res1 := cl_s1[0] & vl_us2;
  52         log(vl_res1);
  53         if (vl_res1 != cl_res2 or vl_res1 != cl_ures2) { setverdict(fail); }
  54         vl_res1 := vl_us1 & cl_s2[0];
  55         log(vl_res1);
  56         if (vl_res1 != cl_res3 or vl_res1 != cl_ures3) { setverdict(fail); }
  57         vl_res1 := vl_us1[0] & cl_us1;
  58         log(vl_res1);
  59         if (vl_res1 != cl_ures6) { setverdict(fail); }
  60         vl_res1 := cl_us2[0] & cl_us1;
  61         log(vl_res1);
  62         if (vl_res1 != cl_ures7) { setverdict(fail); }
  63         vl_res1 := cl_us1 & vl_us1[0];
  64         log(vl_res1);
  65         if (vl_res1 != cl_ures8) { setverdict(fail); }
  66         vl_res1 := cl_us1 & cl_s1[0];
  67         log(vl_res1);
  68         if (vl_res1 != cl_ures8) { setverdict(fail); }
  69         vl_res1 := cl_us1 & "a";
  70         log(vl_res1);
  71         if (vl_res1 != cl_ures8) { setverdict(fail); }
  72         vl_res1 := vl_us1[0];
  73         log(vl_res1);
  74         if (vl_res1 != "a" or vl_res1 != cl_s1[0] or vl_res1 != vl_us1[0]) { setverdict(fail); }
  75         vl_res1 := cl_s1[0];
  76         log(vl_res1);
  77         if (vl_res1 != "a" or vl_res1 != cl_s1[0] or vl_res1 != vl_us1[0]) { setverdict(fail); }
  78         vl_res1 := vl_us1 <@ 1;
  79         log(vl_res1);
  80         if (vl_res1 != "bcda" or vl_res1 != cl_res4 or vl_res1 != cl_ures4) { setverdict(fail); }
  81         vl_res1 := vl_us1 @> 1;
  82         log(vl_res1);
  83         if (vl_res1 != "dabc" or vl_res1 != cl_res5 or vl_res1 != cl_ures5) { setverdict(fail); }
  84         vl_res1 := char(1,1,1,1);
  85         log(vl_res1);
  86         if (vl_res1 != char(1,1,1,1)) { setverdict(fail); }
  87         vl_res1 := vl_us1;
  88         log(vl_res1);
  89         if (vl_res1 != vl_us1 or vl_res1 != cl_s1) { setverdict(fail); }
  90         vl_res1 := cl_us1;
  91         log(vl_res1);
  92         if (vl_res1 != cl_us1) { setverdict(fail); }
  93         vl_res1 := cl_us1 & cl_us2;
  94         log(vl_res1);
  95         if (vl_res1 != cl_us3) { setverdict(fail); }
  96         vl_res1 := cl_s1 & cl_us1;
  97         log(vl_res1);
  98         if (vl_res1 != cl_us4) { setverdict(fail); }
  99         vl_res1 := "abcd" & cl_us1;
 100         log(vl_res1);
 101         if (vl_res1 != cl_us4) { setverdict(fail); }
 102         setverdict(pass);
 103 }
 104
 105 testcase tc_cpp_test() runs on empty {
 106         var integer ret_val := tc_univ_char_cpp();
 107         if (ret_val != 0) { setverdict(fail, "Failed in external function in line: ", ret_val); }
 108         setverdict(pass);
 109 }
 110
 111 const           charstring c_str  := "\xA5\xC3";
 112 const           charstring c_str0 := "\xA5";
 113
 114 modulepar           charstring mp_str  := "\xA5\xC3"
 115 modulepar universal charstring mp_us   := "\xA5\xC3";
 116 modulepar universal charstring mp_uscs := c_str;
 117
 118 modulepar           charstring mp_str0  := "\xA5";
 119 modulepar universal charstring mp_us0   := "\xA5";
 120 modulepar universal charstring mp_uscs0 := c_str[0];
 121
 122
 123 testcase tc_compareHN89648() runs on empty {
 124   if (mp_str == c_str) { setverdict(pass); }
 125   else { setverdict(fail, mp_str, " != ", c_str); } // fail
 126
 127   if (c_str == mp_str) { setverdict(pass); }
 128   else { setverdict(fail, c_str, " != ", mp_str); }
 129
 130   if (mp_str == mp_us) { setverdict(pass); }
 131   else { setverdict(fail, mp_str, " != ", mp_us); } // fail
 132
 133   if (mp_us == mp_str) { setverdict(pass); }
 134   else { setverdict(fail, mp_us, " != ", mp_str); }
 135
 136   if (mp_str == mp_uscs) { setverdict(pass); }
 137   else { setverdict(fail, mp_str, " != ", mp_uscs); }
 138
 139   if (mp_uscs == mp_str) { setverdict(pass); }
 140   else { setverdict(fail, mp_uscs, " != ", mp_str); }
 141
 142   if (mp_us == mp_uscs) { setverdict(pass); }
 143   else { setverdict(fail, mp_us, " != ", mp_uscs); }
 144
 145   if (mp_uscs == mp_us) { setverdict(pass); }
 146   else { setverdict(fail, mp_uscs, " != ", mp_us); }
 147
 148 // elem on left
 149   if (mp_str[0] == c_str0) { setverdict(pass); }
 150   else { setverdict(fail, mp_str[0], " != ", c_str0); }
 151
 152   if (c_str[0] == mp_str0) { setverdict(pass); }
 153   else { setverdict(fail, c_str[0], " != ", mp_str0); }
 154
 155   if (mp_str[0] == mp_us0) { setverdict(pass); }
 156   else { setverdict(fail, mp_str[0], " != ", mp_us0); }
 157
 158   if (mp_us[0] == mp_str0) { setverdict(pass); }
 159   else { setverdict(fail, mp_us[0], " != ", mp_str0); }
 160
 161   if (mp_str[0] == mp_uscs0) { setverdict(pass); }
 162   else { setverdict(fail, mp_str[0], " != ", mp_uscs0); }
 163
 164   if (mp_uscs[0] == mp_str0) { setverdict(pass); }
 165   else { setverdict(fail, mp_uscs[0], " != ", mp_str0); }
 166
 167   if (mp_us[0] == mp_uscs0) { setverdict(pass); }
 168   else { setverdict(fail, mp_us[0], " != ", mp_uscs0); }
 169
 170   if (mp_uscs[0] == mp_us0) { setverdict(pass); }
 171   else { setverdict(fail, mp_uscs[0], " != ", mp_us0); }
 172
 173 // elem on right
 174   if (mp_str0 == c_str[0]) { setverdict(pass); }
 175   else { setverdict(fail, mp_str0, " != ", c_str[0]); }
 176
 177   if (c_str0 == mp_str[0]) { setverdict(pass); }
 178   else { setverdict(fail, c_str0, " != ", mp_str[0]); }
 179
 180   if (mp_str0 == mp_us[0]) { setverdict(pass); }
 181   else { setverdict(fail, mp_str0, " != ", mp_us[0]); }
 182
 183   if (mp_us0 == mp_str[0]) { setverdict(pass); }
 184   else { setverdict(fail, mp_us0, " != ", mp_str[0]); }
 185
 186   if (mp_str0 == mp_uscs[0]) { setverdict(pass); }
 187   else { setverdict(fail, mp_str0, " != ", mp_uscs[0]); }
 188
 189   if (mp_uscs0 == mp_str[0]) { setverdict(pass); }
 190   else { setverdict(fail, mp_uscs0, " != ", mp_str[0]); }
 191
 192   if (mp_us0 == mp_uscs[0]) { setverdict(pass); }
 193   else { setverdict(fail, mp_us0, " != ", mp_uscs[0]); }
 194
 195   if (mp_uscs0 == mp_us[0]) { setverdict(pass); }
 196   else { setverdict(fail, mp_uscs0, " != ", mp_us[0]); }
 197
 198 // elem both
 199   if (mp_str[0] == c_str[0]) { setverdict(pass); }
 200   else { setverdict(fail, mp_str[0], " != ", c_str[0]); }
 201
 202   if (c_str[0] == mp_str[0]) { setverdict(pass); }
 203   else { setverdict(fail, c_str[0], " != ", mp_str[0]); }
 204
 205   if (mp_str[0] == mp_us[0]) { setverdict(pass); }
 206   else { setverdict(fail, mp_str[0], " != ", mp_us[0]); }
 207
 208   if (mp_us[0] == mp_str[0]) { setverdict(pass); }
 209   else { setverdict(fail, mp_us[0], " != ", mp_str[0]); }
 210
 211   if (mp_str[0] == mp_uscs[0]) { setverdict(pass); }
 212   else { setverdict(fail, mp_str[0], " != ", mp_uscs[0]); }
 213
 214   if (mp_uscs[0] == mp_str[0]) { setverdict(pass); }
 215   else { setverdict(fail, mp_uscs[0], " != ", mp_str[0]); }
 216
 217   if (mp_us[0] == mp_uscs[0]) { setverdict(pass); }
 218   else { setverdict(fail, mp_us[0], " != ", mp_uscs[0]); }
 219
 220   if (mp_uscs[0] == mp_us[0]) { setverdict(pass); }
 221   else { setverdict(fail, mp_uscs[0], " != ", mp_us[0]); }
 222
 223
 224 // This was the original error report
 225 //   var charstring vl_charSample := "\xC3\xA5";
 226 //   var universal charstring vl_cmp1 := "\xC3\xA5";
 227 //   var universal charstring vl_cmp2 := vl_charSample;
 228 //   if (match(vl_cmp1, vl_cmp2)) { setverdict(pass); }
 229 //   else { setverdict(fail, match(vl_cmp1, vl_cmp2)); }
 230
 231 }
 232
 233 // In Release 4.2 in June of 2014 the unichar behaviour significantly improved
 234 // From that point universal charstring can get utf-8 charstring which will be well mapped to unicode value
 235 // If the charstring cannot be identified as utf-8 charstring it will transformed byte by byte. It is tested
 236 // in the prev. testcase tc_compareHN89648
 237 // If the charstring can be identified a utf-8 charstring it will be transformed to unicode according its rule i.e. on 1, 2, 3 or 4 byte basis.
 238 // If the charstring is concatenated with unicode chars e.g char(1,1,1,1) the utf-8 conversion is not applied.
 239
 240 const           charstring c_str1  := "\xC3\xA5"; //hexa E5
 241 const universal charstring c_u1cs := c_str1;
 242 const universal charstring c_u1 := "\xC3\xA5" ;
 243 const universal charstring c_u1ch := char(0,0,0,229);
 244
 245 template universal charstring t_u1cs := c_str1;
 246 template universal charstring t_u1 := "\xC3\xA5" ;
 247 template universal charstring t_u1ch := char(0,0,0,229);
 248
 249
 250
 251
 252 testcase tc_unichar_utf8_const() runs on empty {
 253   //const vs literal
 254   if ( c_u1 == c_u1cs) { setverdict(pass); }
 255   else { setverdict(fail,   c_u1,"!=", c_u1cs); }
 256
 257   //const vs unicode
 258   if ( c_u1 == c_u1ch) { setverdict(pass); }
 259   else { setverdict(fail,   c_u1,"!=", c_u1ch); } //fail
 260
 261   //const vs unicode
 262   if ( c_u1ch == c_u1) { setverdict(pass); }
 263   else { setverdict(fail,   c_u1ch,"!=", c_u1); } //fail
 264 }
 265
 266 testcase tc_unichar_utf8_var() runs on empty {
 267   // var vs literal
 268   var charstring vl_charSample := "\xC3\xA5";
 269   var universal charstring vl_cmp1 := "\xC3\xA5";
 270   var universal charstring vl_cmp2 := vl_charSample;
 271
 272   if (match(vl_cmp1, vl_cmp2)) { setverdict(pass); }
 273   else { setverdict(fail, match(vl_cmp1, vl_cmp2)); }
 274
 275   if ( vl_cmp1 == vl_cmp2) { setverdict(pass); }
 276   else { setverdict(fail,  vl_cmp1,"!=", vl_cmp2); }
 277
 278   if ( vl_cmp2 == vl_cmp1) { setverdict(pass); }
 279   else { setverdict(fail,  vl_cmp1,"!=", vl_cmp2); }
 280
 281
 282   if ( vl_cmp1 == c_u1ch) { setverdict(pass); }
 283   else { setverdict(fail,  vl_cmp1,"!=", c_u1ch); }
 284
 285   if ( vl_cmp1 == c_u1) { setverdict(pass); }
 286   else { setverdict(fail,  vl_cmp1,"!=", c_u1); }
 287 }
 288
 289
 290 const universal charstring c_arvizturo := char(0,0,0,193)&"rv"&char(0,0,0,237)&"zt"&char(0,0,1,113)&"r"&char(0,0,1,81) & " t" & char(0,0,0,252)&"k"&char(0,0,0,246)&"rf"&char(0,0,0,250)&"r"&char(0,0,0,243)&"g"&char(0,0,0,233)&"p";
 291
 292 testcase tc_unichar_utf8_var_hungarian_text() runs on empty {
 293   // var vs literal
 294   //var charstring vl_charSample :=  "Árvíztűrő tükörfúrógép";
 295   var universal charstring vl_cmp1 := "Árvíztűrő tükörfúrógép";
 296   //var universal charstring vl_cmp2 := vl_charSample;
 297
 298   /*if (match(vl_cmp1, vl_cmp2)) { setverdict(pass); }
 299   else { setverdict(fail, match(vl_cmp1, vl_cmp2)); }
 300
 301   if ( vl_cmp1 == vl_cmp2) { setverdict(pass); }
 302   else { setverdict(fail,  vl_cmp1,"!=", vl_cmp2); }
 303
 304   if ( vl_cmp2 == vl_cmp1) { setverdict(pass); }
 305   else { setverdict(fail,  vl_cmp1,"!=", vl_cmp2); }*/
 306
 307
 308   if ( vl_cmp1 == c_arvizturo) { setverdict(pass); }
 309   else { setverdict(fail,  vl_cmp1,"!=", c_arvizturo); }
 310
 311   /*if ( vl_cmp2 == c_arvizturo) { setverdict(pass); }
 312   else { setverdict(fail,  vl_cmp1,"!=", c_arvizturo); }*/
 313 }
 314
 315
 316 modulepar {
 317   charstring mp_str1  := "\xC3\xA5"; //hexa E5
 318   universal charstring mp_u1cs := c_str1;
 319   universal charstring mp_u1 := "\xC3\xA5" ;
 320   universal charstring mp_u1ch := char(0,0,0,229);
 321
 322   charstring mp_str2  := "\xC3\xA4"; //hexa E4, dec 228.ie wrong
 323   universal charstring mp_u2cs := c_str1;
 324   universal charstring mp_u2 := "\xC3\xA3" ;
 325   universal charstring mp_u2ch := char(0,0,0,227);
 326 }
 327
 328 testcase tc_unichar_utf8_mp1() runs on empty {
 329   if (match(mp_u1cs, mp_u1)) { setverdict(pass); }
 330   else { setverdict(fail, match(mp_u1cs, mp_u1)); }
 331
 332   if ( mp_u1cs == mp_u1ch) { setverdict(pass); }
 333   else { setverdict(fail,  mp_u1cs,"!=", mp_u1ch); }
 334
 335   if ( mp_u1 == c_u1 ) { setverdict(pass,mp_u1,"==", c_u1); }
 336   else { setverdict(fail,  mp_u1,"!=", c_u1); }
 337
 338   if ( mp_u1 == mp_u1ch ) { setverdict(pass, mp_u1,"==", mp_u1ch); }
 339   else { setverdict(fail,  mp_u1,"!=", mp_u1ch); }
 340 }
 341
 342 testcase tc_unichar_utf8_mp2() runs on empty {
 343   if (match(mp_u2cs, mp_u2)) { setverdict(pass); }
 344   else { setverdict(fail, match(mp_u2cs, mp_u2)); }
 345
 346   if ( mp_u2cs == mp_u2ch) { setverdict(pass,mp_u2cs,"==", mp_u2ch ); }
 347   else { setverdict(fail,  mp_u2cs,"!=", mp_u2ch); } //fail
 348
 349   if ( mp_u2 == c_u1 ) { setverdict(pass, mp_u2,"==", c_u1); }
 350   else { setverdict(fail,  mp_u2,"!=", c_u1); }
 351
 352   if ( mp_u2 == mp_u2ch ) { setverdict(pass,mp_u2,"==", mp_u2ch ); }
 353   else { setverdict(fail,  mp_u2,"!=", mp_u2ch); }
 354 }
 355
 356 testcase tc_unichar_utf8_template() runs on empty {
 357   //t vs literal
 358   if ( match(c_u1ch,t_u1cs)) { setverdict(pass); }
 359   else { setverdict(fail,  match(c_u1ch,t_u1cs)  ); }
 360
 361   //t vs unicode
 362   if ( valueof(t_u1) == valueof(t_u1ch) ) { setverdict(pass); }
 363   else { setverdict(fail,   valueof(t_u1),"!=", valueof(t_u1ch)); }
 364
 365   //t vs unicode
 366   if ( valueof(t_u1ch) == valueof(t_u1)) { setverdict(pass); }
 367   else { setverdict(fail,   valueof(t_u1ch), "!=", valueof(t_u1)); }
 368 }
 369
 370 // Fixed indexing errors when the string only contained ASCII characters (HT70680)
 371 function f_changeUnichar(in universal charstring pl_char)
 372 return universal charstring
 373 {
 374   log("lengthof(pl_char): ", lengthof(pl_char))
 375   log("pl_char: ", pl_char); // garbage here
 376   return pl_char;
 377 }
 378
 379 function f_modifyUnichar(in universal charstring pl_str)
 380 return universal charstring
 381 {
 382   var integer vl_size := lengthof(pl_str);
 383   var universal charstring vl_tmp;
 384
 385   for (var integer vl_i := 0; vl_i < vl_size; vl_i := vl_i + 1)
 386   {
 387     log("pl_str[vl_i]: ", pl_str[vl_i])
 388     vl_tmp := f_changeUnichar(pl_str[vl_i]);
 389     log("vl_tmp: ", vl_tmp); // garbage here
 390     pl_str[vl_i] := vl_tmp; // segmentation fault here
 391   }
 392
 393   return pl_str;
 394 }
 395
 396 testcase tc_indexing_HT70680() runs on empty
 397 {
 398   // must contain only ASCII characters
 399   var universal charstring v_str := "alma123";
 400   var universal charstring v_res := f_modifyUnichar(v_str);
 401   if (v_str == v_res) { setverdict(pass); }
 402   else { setverdict(fail, "got: ", v_res, " expected: ", v_str); }
 403 }
 404
 405
 406 control {
 407   execute(tc_charstring_content());
 408   execute(tc_cpp_test());
 409   execute(tc_compareHN89648());
 410   execute(tc_unichar_utf8_const());//fail
 411   execute(tc_unichar_utf8_var());
 412   execute(tc_unichar_utf8_var_hungarian_text());
 413   //execute(tc_unichar_utf8_mp1());
 414   //execute(tc_unichar_utf8_mp2());
 415   execute(tc_unichar_utf8_template());
 416   execute(tc_indexing_HT70680());
 417 }
 418
 419 }