regression_test/text2ttcn/charstring_test.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 module charstring_test {
   9
  10 //=========================================================================
  11 // Import Part
  12 //=========================================================================
  13
  14 import from types all;
  15 import from functions all;
  16
  17 //=========================================================================
  18 // Module Parameters
  19 //=========================================================================
  20 modulepar {
  21
  22   //modulepar charstrings not modified from cfg file
  23   template charstring tspt_cs_v := "ABBA";
  24   template charstring tspt_cs_o := omit;
  25   template charstring tspt_cs_a := *;
  26   template charstring tspt_cs_q := ?;
  27   template charstring tspt_cs_al1 := * length(2); //length restriction
  28   template charstring tspt_cs_al2 := * length(2..4);
  29   template charstring tspt_cs_ql1 := ? length(2);
  30   template charstring tspt_cs_ql2 := ? length(2..4);
  31   template charstring tspt_cs_vl1 := ("ABBA");
  32   template charstring tspt_cs_vl2 := ("ABBA","baba");
  33   template charstring tspt_cs_vl3 := ("ABBA","baba","Bye");
  34   template charstring tspt_cs_c1 := complement("ABBA")
  35   template charstring tspt_cs_c2 := complement("ABBA","baba");
  36   template charstring tspt_cs_c3 := complement("ABBA","baba","Bye");
  37   template charstring tspt_cs_r1 := ("A".."B"); //range
  38   template charstring tspt_cs_r2 := ("a".."c");
  39   template charstring tspt_cs_pa := pattern "abc*xyz"
  40   template charstring tspt_cs_pq := pattern "abc?xyz"
  41
  42   template charstring tspt_cs_vifp := "ABBA" ifpresent;
  43   template charstring tspt_cs_oifp := omit ifpresent;
  44   template charstring tspt_cs_aifp := * ifpresent;
  45   template charstring tspt_cs_qifp := ? ifpresent;
  46   template charstring tspt_cs_al1ifp := * length(2) ifpresent; //length restriction
  47   template charstring tspt_cs_al2ifp := * length(2..4) ifpresent;
  48   template charstring tspt_cs_ql1ifp := ? length(2) ifpresent;
  49   template charstring tspt_cs_ql2ifp := ? length(2..4) ifpresent;
  50   template charstring tspt_cs_vl1ifp := ("ABBA") ifpresent;
  51   template charstring tspt_cs_vl2ifp := ("ABBA","baba") ifpresent;
  52   template charstring tspt_cs_vl3ifp := ("ABBA","baba","Bye") ifpresent;
  53   template charstring tspt_cs_c1ifp := complement("ABBA") ifpresent
  54   template charstring tspt_cs_c2ifp := complement("ABBA","baba") ifpresent;
  55   template charstring tspt_cs_c3ifp := complement("ABBA","baba","Bye") ifpresent;
  56   template charstring tspt_cs_r1ifp := ("A".."B") ifpresent; //range
  57   template charstring tspt_cs_r2ifp := ("a".."c") ifpresent;
  58   template charstring tspt_cs_paifp := pattern "abc*xyz"  ifpresent
  59   template charstring tspt_cs_pqifp := pattern "abc?xyz"  ifpresent
  60
  61   //modulepar charstrings modified from cfg file
  62   template charstring tspt_cs_mod4v := * //after mod:"ABBA";
  63   template charstring tspt_cs_mod4o := * //omit;
  64   template charstring tspt_cs_mod4ol := * //omit;
  65   template charstring tspt_cs_mod4a := "A" //*;
  66   template charstring tspt_cs_mod4q := "" //?;
  67   template charstring tspt_cs_mod4al1 := "A" //* length(2); //length restriction
  68   template charstring tspt_cs_mod4al2 := "Original" //mofified for: * length(2..4);
  69   template charstring tspt_cs_mod4ql1 := "Original" //mofified for:? length(2);
  70   template charstring tspt_cs_mod4ql2 := "Original" //mofified for:? length(2..4);
  71   template charstring tspt_cs_mod4vl1 := ("ABBA") //TODO: Adam //It should be mofified for: ("ABBA");
  72   template charstring tspt_cs_mod4vl2 := "Original" //mofified for:("ABBA","baba");
  73   template charstring tspt_cs_mod4vl3 := "Original" //mofified for:("ABBA","baba","Bye");
  74   template charstring tspt_cs_mod4c1 := "Original" //mofified for:complement("ABBA")
  75   template charstring tspt_cs_mod4c2 := "Original" //mofified for:complement("ABBA","baba");
  76   template charstring tspt_cs_mod4c3 := "Original" //mofified for:complement("ABBA","baba","Bye");
  77   template charstring tspt_cs_mod4r1 := "Original" //mofified for:("A".."B"); //range
  78   template charstring tspt_cs_mod4r2 := "Original" //mofified for:("a".."c");
  79   template charstring tspt_cs_mod4pa := "Original" //mofified for:pattern "abc*xyz"
  80   template charstring tspt_cs_mod4pq := "Original" //mofified for:pattern "abc?xyz"
  81
  82   template charstring tspt_cs_mod4vifp := "Original" //mofified for:"ABBA" ifpresent;
  83   template charstring tspt_cs_mod4oifp := "Original" //mofified for:omit ifpresent;
  84   template charstring tspt_cs_mod4aifp := "Original" //mofified for:* ifpresent;
  85   template charstring tspt_cs_mod4qifp := "Original" //mofified for:? ifpresent;
  86   template charstring tspt_cs_mod4al1ifp := "Original" //mofified for:* length(2) ifpresent; //length restriction
  87   template charstring tspt_cs_mod4al2ifp := "Original" //mofified for:* length(2..4) ifpresent;
  88   template charstring tspt_cs_mod4ql1ifp := "Original" //mofified for:? length(2) ifpresent;
  89   template charstring tspt_cs_mod4ql2ifp := "Original" //mofified for:? length(2..4) ifpresent;
  90   template charstring tspt_cs_mod4vl1ifp :=  ("ABBA") ifpresent //TODO: Adam //It should be mofified for: ("ABBA");
  91   template charstring tspt_cs_mod4vl2ifp := "Original" //mofified for:("ABBA","baba") ifpresent;
  92   template charstring tspt_cs_mod4vl3ifp := "Original" //mofified for:("ABBA","baba","Bye") ifpresent;
  93   template charstring tspt_cs_mod4c1ifp := "Original" //mofified for:complement("ABBA") ifpresent
  94   template charstring tspt_cs_mod4c2ifp := "Original" //mofified for:complement("ABBA","baba") ifpresent;
  95   template charstring tspt_cs_mod4c3ifp := "Original" //mofified for:complement("ABBA","baba","Bye") ifpresent;
  96   template charstring tspt_cs_mod4r1ifp := "Original" //mofified for:("A".."B") ifpresent; //range
  97   template charstring tspt_cs_mod4r2ifp := "Original" //mofified for:("a".."c") ifpresent;
  98   template charstring tspt_cs_mod4paifp := "Original" //mofified for:pattern "abc*xyz"  ifpresent
  99   template charstring tspt_cs_mod4pqifp := "Original" //mofified for:pattern "abc?xyz"  ifpresent
 100
 101 }
 102
 103 //=========================================================================
 104 // Templates
 105 //=========================================================================
 106 // not modulepars
 107 template charstring t_cs_v := "ABBA";
 108 template charstring t_cs_o := omit;
 109 template charstring t_cs_a := *;
 110 template charstring t_cs_q := ?;
 111 template charstring t_cs_al1 := * length(2); //length restriction
 112 template charstring t_cs_al2 := * length(2..4);
 113 template charstring t_cs_ql1 := ? length(2);
 114 template charstring t_cs_ql2 := ? length(2..4);
 115 template charstring t_cs_vl1 := ("ABBA");
 116 template charstring t_cs_vl2 := ("ABBA","baba");
 117 template charstring t_cs_vl3 := ("ABBA","baba","Bye");
 118 template charstring t_cs_c1 := complement("ABBA")
 119 template charstring t_cs_c2 := complement("ABBA","baba");
 120 template charstring t_cs_c3 := complement("ABBA","baba","Bye");
 121 template charstring t_cs_r1 := ("A".."B"); //range
 122 template charstring t_cs_r2 := ("a".."c");
 123 template charstring t_cs_pa := pattern "abc*xyz"
 124 template charstring t_cs_pq := pattern "abc?xyz"
 125
 126 template charstring t_cs_vifp := "ABBA" ifpresent;
 127 template charstring t_cs_oifp := omit ifpresent;
 128 template charstring t_cs_aifp := * ifpresent;
 129 template charstring t_cs_qifp := ? ifpresent;
 130 template charstring t_cs_al1ifp := * length(2) ifpresent; //length restriction
 131 template charstring t_cs_al2ifp := * length(2..4) ifpresent;
 132 template charstring t_cs_ql1ifp := ? length(2) ifpresent;
 133 template charstring t_cs_ql2ifp := ? length(2..4) ifpresent;
 134 template charstring t_cs_vl1ifp := ("ABBA") ifpresent;
 135 template charstring t_cs_vl2ifp := ("ABBA","baba") ifpresent;
 136 template charstring t_cs_vl3ifp := ("ABBA","baba","Bye") ifpresent;
 137 template charstring t_cs_c1ifp := complement("ABBA") ifpresent
 138 template charstring t_cs_c2ifp := complement("ABBA","baba") ifpresent;
 139 template charstring t_cs_c3ifp := complement("ABBA","baba","Bye") ifpresent;
 140 template charstring t_cs_r1ifp := ("A".."B") ifpresent; //range
 141 template charstring t_cs_r2ifp := ("a".."c") ifpresent;
 142 template charstring t_cs_paifp := pattern "abc*xyz"  ifpresent
 143 template charstring t_cs_pqifp := pattern "abc?xyz"  ifpresent
 144
 145 //=========================================================================
 146 // Functions
 147 //=========================================================================
 148 function f_string2ttcn_cs_t(in charstring pl_cs, in template charstring pl_expected_result) {
 149   var template charstring vl_result;
 150   @try {
 151     string2ttcn(pl_cs,vl_result);
 152     setverdict(pass)
 153   }
 154   @catch(err_str) {
 155     log("string2ttcn() failed: ",err_str);
 156     setverdict(fail);
 157   }
 158   log(pl_expected_result);
 159   log(vl_result);
 160   if( log2str(pl_expected_result) == log2str(vl_result) ) { setverdict(pass) } else { setverdict(fail) }
 161 }
 162
 163 function f_string2ttcn_cs_t_str(in charstring pl_cs, in charstring pl_expected_result) {
 164   var template charstring vl_result;
 165   @try {
 166     string2ttcn(pl_cs,vl_result);
 167     setverdict(pass)
 168   }
 169   @catch(err_str) {
 170     log("str2ttcn() failed: ",err_str);
 171     setverdict(fail);
 172   }
 173   log("Expected result: ", pl_expected_result);
 174   log("Result: ", vl_result);
 175   if( pl_expected_result == log2str(vl_result) ) { setverdict(pass) } else { setverdict(fail) }
 176 }
 177
 178 //template string -> variable conversion
 179 //expected result: error
 180 function f_string2ttcn_cs_v(in charstring pl_cs, in template charstring pl_expected_result, in boolean pl_ok_expected) {
 181   var charstring vl_result;
 182   if( pl_ok_expected ) {
 183     @try {
 184       string2ttcn(pl_cs, vl_result);
 185       setverdict(pass);
 186     }
 187     @catch(err_str) {
 188       log("string2ttcn() failed: ",err_str);
 189       setverdict(fail);
 190     }
 191     if( log2str(pl_expected_result) == log2str(vl_result) ) { setverdict(pass) } else { setverdict(fail) }
 192   }
 193   else
 194   {
 195     @try {
 196       string2ttcn(pl_cs, vl_result);
 197       setverdict(fail);
 198     }
 199     @catch(err_str) {
 200       log("string2ttcn() conversion error: ",err_str);
 201       setverdict(pass,"Expected error, ok");
 202     }
 203
 204   }
 205   log("Expected result: ",pl_expected_result );
 206   log("Result: ", vl_result);
 207 }
 208
 209 //this function is the same but uses
 210 function f_string2ttcn_cs_v_str(in charstring pl_cs, charstring pl_expected_result, in boolean pl_ok_expected) {
 211   var charstring vl_result;
 212   if( pl_ok_expected ) {
 213     @try {
 214       string2ttcn(pl_cs, vl_result);
 215       setverdict(pass);
 216     }
 217     @catch(err_str) {
 218       log("str2ttcn() failed: ",err_str);
 219       setverdict(fail);
 220     }
 221     if( pl_expected_result == log2str(vl_result) ) { setverdict(pass) } else { setverdict(fail) }
 222   }
 223   else
 224   {
 225     @try {
 226       string2ttcn(pl_cs, vl_result);
 227       setverdict(fail);
 228     }
 229     @catch(err_str) {
 230       log("str2ttcn() conversion error: ",err_str);
 231       setverdict(pass,"Expected error, ok");
 232     }
 233
 234   }
 235   log("Expected result: ", pl_expected_result );
 236   log("Result: ", vl_result);
 237 }
 238
 239 //rrec
 240
 241 function f_string2ttcn_rcs_t(in charstring pl_rcs, in template RCS pl_expected_result) {
 242   var template RCS vl_result;
 243   @try {
 244     string2ttcn(pl_rcs,vl_result);
 245     setverdict(pass)
 246   }
 247   @catch(err_str) {
 248     log("string2ttcn() failed: ",err_str);
 249     setverdict(fail);
 250   }
 251   log(pl_expected_result);
 252   log(vl_result);
 253   if( log2str(pl_expected_result) == log2str(vl_result) ) { setverdict(pass) } else { setverdict(fail) }
 254 }
 255
 256 function f_string2ttcn_rcs_t_str(in charstring pl_cs, in charstring pl_expected_result) {
 257   var template RCS vl_result;
 258   @try {
 259     string2ttcn(pl_cs,vl_result);
 260     setverdict(pass)
 261   }
 262   @catch(err_str) {
 263     log("str2ttcn() failed: ",err_str);
 264     setverdict(fail);
 265   }
 266   log("Expected result: ", pl_expected_result);
 267   log("Result: ", vl_result);
 268   if( pl_expected_result == log2str(vl_result) ) { setverdict(pass) } else { setverdict(fail) }
 269 }
 270
 271 //template string -> variable conversion
 272 //expected result: error
 273 function f_string2ttcn_rcs_v(in charstring pl_cs, in template RCS pl_expected_result, in boolean pl_ok_expected) {
 274   var RCS vl_result;
 275   if( pl_ok_expected ) {
 276     @try {
 277       string2ttcn(pl_cs, vl_result);
 278       setverdict(pass);
 279     }
 280     @catch(err_str) {
 281       log("string2ttcn() failed: ",err_str);
 282       setverdict(fail);
 283     }
 284     if( log2str(pl_expected_result) == log2str(vl_result) ) { setverdict(pass) } else { setverdict(fail) }
 285   }
 286   else
 287   {
 288     @try {
 289       string2ttcn(pl_cs, vl_result);
 290       setverdict(fail);
 291     }
 292     @catch(err_str) {
 293       log("string2ttcn() conversion error: ",err_str);
 294       setverdict(pass,"Expected error, ok");
 295     }
 296
 297   }
 298   log("Expected result: ",pl_expected_result );
 299   log("Result: ", vl_result);
 300 }
 301
 302 //this function is the same but uses
 303 function f_string2ttcn_rcs_v_str(in charstring pl_cs, charstring pl_expected_result, in boolean pl_ok_expected) {
 304   var RCS vl_result;
 305   if( pl_ok_expected ) {
 306     @try {
 307       string2ttcn(pl_cs, vl_result);
 308       setverdict(pass);
 309     }
 310     @catch(err_str) {
 311       log("str2ttcn() failed: ",err_str);
 312       setverdict(fail);
 313     }
 314     if( pl_expected_result == log2str(vl_result) ) { setverdict(pass) } else { setverdict(fail) }
 315   }
 316   else
 317   {
 318     @try {
 319       string2ttcn(pl_cs, vl_result);
 320       setverdict(fail);
 321     }
 322     @catch(err_str) {
 323       log("str2ttcn() conversion error: ",err_str);
 324       setverdict(pass,"Expected error, ok");
 325     }
 326
 327   }
 328   log("Expected result: ", pl_expected_result );
 329   log("Result: ", vl_result);
 330 }
 331
 332 //=========================================================================
 333 // Testcases
 334 //=========================================================================
 335
 336 testcase tc_cs_v() runs on MC {
 337   var RoCS vl_good_values := {"ABBA"}
 338   var RoCS vl_wrong_values := {"","A","AB","ABB","ABBAB","abba","anything","XXXX","ABCDE"}
 339   f_checkMatchingValues_cs(t_cs_v, vl_good_values,vl_wrong_values);
 340 }
 341
 342 testcase tc_cs_o() runs on MC {
 343   var RoCS vl_good_values := {}
 344   var RoCS vl_wrong_values := {"","A","AB","ABB","ABBAB","abba","anything","XXXX","ABCDE"}
 345   f_checkMatchingValues_cs(t_cs_o, vl_good_values,vl_wrong_values);
 346 }
 347
 348 testcase tc_cs_a() runs on MC {
 349   var RoCS vl_good_values := {"","A","AB","ABB","ABBAB","abba","anything","XXXX","ABCDE"}
 350   var RoCS vl_wrong_values := {}
 351   f_checkMatchingValues_cs(t_cs_a, vl_good_values,vl_wrong_values);
 352 }
 353
 354 testcase tc_cs_q() runs on MC {
 355   var RoCS vl_good_values := {"","A","AB","ABB","ABBAB","abba","anything","XXXX","ABCDE"}
 356   var RoCS vl_wrong_values := {}
 357   f_checkMatchingValues_cs(t_cs_q, vl_good_values,vl_wrong_values);
 358 }
 359
 360 // t_cs_al1 := * length(2); //length restriction
 361 testcase tc_cs_al1() runs on MC {
 362   var RoCS vl_good_values := {"AB", "ab","ba","12","A1","  "}
 363   var RoCS vl_wrong_values := {"","A","ABB","ABBAB","abba","anything","XXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 364   f_checkMatchingValues_cs(t_cs_al1, vl_good_values,vl_wrong_values);
 365 }
 366
 367 // t_cs_al1 := * length(2..4); //length restriction
 368 testcase tc_cs_al2() runs on MC {
 369   var RoCS vl_good_values := {"AB", "ab","ba","12","A1","  ","123", "ABC","abc","ABBA"}
 370   var RoCS vl_wrong_values := {"","A", "ABBAB","anything","XXXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 371   f_checkMatchingValues_cs(t_cs_al2, vl_good_values,vl_wrong_values);
 372 }
 373
 374 // t_cs_al1 := ? length(2); //length restriction
 375 testcase tc_cs_ql1() runs on MC {
 376   var RoCS vl_good_values := {"AB", "ab","ba","12","A1","  "}
 377   var RoCS vl_wrong_values := {"","A","ABB","ABBAB","abba","anything","XXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 378   f_checkMatchingValues_cs(t_cs_ql1, vl_good_values,vl_wrong_values);
 379 }
 380
 381 // t_cs_al1 := ? length(2..4); //length restriction
 382 testcase tc_cs_ql2() runs on MC {
 383   var RoCS vl_good_values := {"AB", "ab","ba","12","A1","  ","123", "ABC","abc","ABBA"}
 384   var RoCS vl_wrong_values := {"","A", "ABBAB","anything","XXXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 385   f_checkMatchingValues_cs(t_cs_ql2, vl_good_values,vl_wrong_values);
 386 }
 387
 388 testcase tc_cs_vl1() runs on MC {
 389   var RoCS vl_good_values := {"ABBA"}
 390   var RoCS vl_wrong_values := {"AB", "ab","ba","12","A1","  ""","A","ABB","ABBAB","abba","anything","XXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 391   f_checkMatchingValues_cs(t_cs_vl1, vl_good_values,vl_wrong_values);
 392 }
 393
 394 testcase tc_cs_vl2() runs on MC {
 395   var RoCS vl_good_values := {"ABBA","baba"}
 396   var RoCS vl_wrong_values := {"AB", "ab","ba","12","A1","  ""","A","ABB","ABBAB","abba","anything","XXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 397   f_checkMatchingValues_cs(t_cs_vl2, vl_good_values,vl_wrong_values);
 398 }
 399
 400 testcase tc_cs_vl3() runs on MC {
 401   var RoCS vl_good_values := {"ABBA","baba","Bye"}
 402   var RoCS vl_wrong_values := {"AB", "ab","ba","12","A1","  ""","A","ABB","ABBAB","abba","anything","XXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 403   f_checkMatchingValues_cs(t_cs_vl3, vl_good_values,vl_wrong_values);
 404 }
 405
 406 testcase tc_cs_c1() runs on MC {
 407   var RoCS vl_good_values := {"AB", "ab","ba","12","A1","  ""","A","ABB","ABBAB","abba","anything","XXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 408   var RoCS vl_wrong_values := {"ABBA"}
 409   f_checkMatchingValues_cs(t_cs_c1, vl_good_values,vl_wrong_values);
 410 }
 411
 412 testcase tc_cs_c2() runs on MC {
 413   var RoCS vl_good_values :={"AB", "ab","ba","12","A1","  ""","A","ABB","ABBAB","abba","anything","XXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 414   var RoCS vl_wrong_values :=  {"ABBA","baba"}
 415   f_checkMatchingValues_cs(t_cs_c2, vl_good_values,vl_wrong_values);
 416 }
 417
 418 testcase tc_cs_c3() runs on MC {
 419   var RoCS vl_good_values := {"AB", "ab","ba","12","A1","  ""","A","ABB","ABBAB","abba","anything","XXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 420   var RoCS vl_wrong_values := {"ABBA","baba","Bye"}
 421   f_checkMatchingValues_cs(t_cs_c3, vl_good_values,vl_wrong_values);
 422 }
 423
 424 //("A".."B")
 425 testcase tc_cs_r1() runs on MC {
 426   var RoCS vl_good_values := {"A","B","ABBA","AB","AAAAAA","BBBBB","ABBABABA"}
 427   var RoCS vl_wrong_values := { "ab","ba","Bye","12","A1","  ","abba","anything","XXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 428   f_checkMatchingValues_cs(t_cs_r1, vl_good_values,vl_wrong_values);
 429 }
 430 //"a".."c"
 431 testcase tc_cs_r2() runs on MC {
 432   var RoCS vl_good_values := {"","a","b","c","ab","cba","abbac","abbababa","cabacccc"}
 433   var RoCS vl_wrong_values := {"A","B","ABBA","AB","AAAAAAc","BBBBB","ABBABABAc", "Bye","12","abcA1","  ","anything","XXXX","ABCDE","XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}
 434   f_checkMatchingValues_cs(t_cs_r2, vl_good_values,vl_wrong_values);
 435 }
 436
 437 testcase tc_cs_pa() runs on MC {
 438   var RoCS vl_good_values := { "abcxyz","abcAxyz","abc45xyz" }
 439   var RoCS vl_wrong_values := { "ab","ba","Bye", "abcyz"}
 440   f_checkMatchingValues_cs(t_cs_pa, vl_good_values,vl_wrong_values);
 441 }
 442
 443 testcase tc_cs_pq() runs on MC {
 444   var RoCS vl_good_values := {"abcAxyz","abc4xyz" }
 445   var RoCS vl_wrong_values := { "ab","ba","Bye", "abcxyz","abc45xyz"}
 446   f_checkMatchingValues_cs(t_cs_pq, vl_good_values,vl_wrong_values);
 447 }
 448
 449 //=== charstring embedded in record ====
 450
 451 testcase tc_cs_v_emb() runs on MC {
 452   var RoRCS vl_good_values := {{cs:="ABBA"}}
 453   var RoRCS vl_wrong_values := {{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 454   f_checkMatchingValues_rcs(t_rcs(t_cs_v), vl_good_values,vl_wrong_values);
 455 }
 456
 457 testcase tc_cs_o_emb() runs on MC {
 458   var RoRCS vl_good_values := {{omit},{cs:=omit}};
 459   var RoRCS vl_wrong_values := {{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"}}
 460   f_checkMatchingValues_rcs(t_rcs(t_cs_o), vl_good_values,vl_wrong_values);
 461 }
 462
 463 testcase tc_cs_a_emb() runs on MC {
 464   var RoRCS vl_good_values := {{omit},{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 465   var RoRCS vl_wrong_values := {{}}
 466   f_checkMatchingValues_rcs(t_rcs(t_cs_a), vl_good_values,vl_wrong_values);
 467 }
 468
 469 testcase tc_cs_q_emb() runs on MC {
 470   var RoRCS vl_good_values := {{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 471   var RoRCS vl_wrong_values := {{omit}}
 472   f_checkMatchingValues_rcs(t_rcs(t_cs_q), vl_good_values,vl_wrong_values);
 473 }
 474
 475 // t_rcs(t_cs_al1 := * length(2); //length restriction
 476 testcase tc_cs_al1_emb() runs on MC {
 477   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "}}
 478   var RoRCS vl_wrong_values := {{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 479   f_checkMatchingValues_rcs(t_rcs(t_cs_al1), vl_good_values,vl_wrong_values);
 480 }
 481
 482 // t_rcs(t_cs_al1 := * length(2..4); //length restriction
 483 testcase tc_cs_al2_emb() runs on MC {
 484   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{"123"},{ "ABC"},{"abc"},{"ABBA"}}
 485   var RoRCS vl_wrong_values := {{""},{"A"},{ "ABBAB"},{"anything"},{"XXXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 486   f_checkMatchingValues_rcs(t_rcs(t_cs_al2), vl_good_values,vl_wrong_values);
 487 }
 488
 489 // t_rcs(t_cs_al1 := ? length(2); //length restriction
 490 testcase tc_cs_ql1_emb() runs on MC {
 491   var RoRCS vl_good_values := {{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "}}
 492   var RoRCS vl_wrong_values := {{omit},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 493   f_checkMatchingValues_rcs(t_rcs(t_cs_ql1), vl_good_values,vl_wrong_values);
 494 }
 495
 496 // t_rcs(t_cs_al1 := ? length(2..4); //length restriction
 497 testcase tc_cs_ql2_emb() runs on MC {
 498   var RoRCS vl_good_values := {{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{"123"},{ "ABC"},{"abc"},{"ABBA"}}
 499   var RoRCS vl_wrong_values := {{omit},{""},{"A"},{ "ABBAB"},{"anything"},{"XXXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 500   f_checkMatchingValues_rcs(t_rcs(t_cs_ql2), vl_good_values,vl_wrong_values);
 501 }
 502 //("ABBA")
 503 testcase tc_cs_vl1_emb() runs on MC {
 504   var RoRCS vl_good_values := {{"ABBA"}}
 505   var RoRCS vl_wrong_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 506   f_checkMatchingValues_rcs(t_rcs(t_cs_vl1), vl_good_values,vl_wrong_values);
 507 }
 508 //("ABBA","baba")
 509 testcase tc_cs_vl2_emb() runs on MC {
 510   var RoRCS vl_good_values := {{"ABBA"},{"baba"}}
 511   var RoRCS vl_wrong_values := {{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 512   f_checkMatchingValues_rcs(t_rcs(t_cs_vl2), vl_good_values,vl_wrong_values);
 513 }
 514 //("ABBA","baba","Bye")
 515 testcase tc_cs_vl3_emb() runs on MC {
 516   var RoRCS vl_good_values := {{"ABBA"},{"baba"},{"Bye"}}
 517   var RoRCS vl_wrong_values := {{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 518   f_checkMatchingValues_rcs(t_rcs(t_cs_vl3), vl_good_values,vl_wrong_values);
 519 }
 520 // Note: this tests legacy behavior and requires the -M compiler option!
 521 //complement("ABBA")
 522 testcase tc_cs_c1_emb() runs on MC {
 523   var RoRCS vl_good_values := {{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  """},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 524   var RoRCS vl_wrong_values := {{"ABBA"}}
 525   f_checkMatchingValues_rcs(t_rcs(t_cs_c1), vl_good_values,vl_wrong_values);
 526 }
 527 // Note: this tests legacy behavior and requires the -M compiler option!
 528 //complement("ABBA","baba");
 529 testcase tc_cs_c2_emb() runs on MC {
 530   var RoRCS vl_good_values :={{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 531   var RoRCS vl_wrong_values :=  {{"ABBA"},{"baba"}}
 532   f_checkMatchingValues_rcs(t_rcs(t_cs_c2), vl_good_values,vl_wrong_values);
 533 }
 534 // Note: this tests legacy behavior and requires the -M compiler option!
 535 //complement("ABBA","baba","Bye");
 536 testcase tc_cs_c3_emb() runs on MC {
 537   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 538   var RoRCS vl_wrong_values := {{"ABBA"},{"baba"},{"Bye"}}
 539   f_checkMatchingValues_rcs(t_rcs(t_cs_c3), vl_good_values,vl_wrong_values);
 540 }
 541
 542 //("A".."B")
 543 testcase tc_cs_r1_emb() runs on MC {
 544   var RoRCS vl_good_values := {{"A"},{"B"},{"ABBA"},{"AB"},{"AAAAAA"},{"BBBBB"},{"ABBABABA"}}
 545   var RoRCS vl_wrong_values := {{omit},{"ab"},{"ba"},{"Bye"},{"12"},{"A1"},{"  "},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 546   f_checkMatchingValues_rcs(t_rcs(t_cs_r1),vl_good_values,vl_wrong_values);
 547 }
 548 //"a".."c"
 549 testcase tc_cs_r2_emb() runs on MC {
 550   var RoRCS vl_good_values := {{""},{"a"},{"b"},{"c"},{"ab"},{"cba"},{"abbac"},{"abbababa"},{"cabacccc"}}
 551   var RoRCS vl_wrong_values := {{omit},{"A"},{"B"},{"ABBA"},{"AB"},{"AAAAAAc"},{"BBBBB"},{"ABBABABAc"},{ "Bye"},{"12"},{"abcA1"},{"  "},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 552   f_checkMatchingValues_rcs(t_rcs(t_cs_r2), vl_good_values,vl_wrong_values);
 553 }
 554 //pattern "abc*xyz"
 555 testcase tc_cs_pa_emb() runs on MC {
 556   var RoRCS vl_good_values := {{ "abcxyz"},{"abcAxyz"},{"abc45xyz" }}
 557   var RoRCS vl_wrong_values := {{""},{"ab"},{"ba"},{"Bye"},{"abcyz"}}
 558   f_checkMatchingValues_rcs(t_rcs(t_cs_pa), vl_good_values,vl_wrong_values);
 559 }
 560 //pattern "abc?xyz"
 561 testcase tc_cs_pq_emb() runs on MC {
 562   var RoRCS vl_good_values := {{"abcAxyz"},{"abc4xyz" }}
 563   var RoRCS vl_wrong_values := {{ "ab"},{"ba"},{"Bye"},{ "abcxyz"},{"abc45xyz"}}
 564   f_checkMatchingValues_rcs(t_rcs(t_cs_pq), vl_good_values,vl_wrong_values);
 565 }
 566
 567 //=========== Charstring Tests without Module Params and with "ifpresent" clause
 568 //=== charstring embedded in record ====
 569
 570 testcase tc_cs_vifp_emb() runs on MC {
 571   var RoRCS vl_good_values := {{omit},{cs:="ABBA"}}
 572   var RoRCS vl_wrong_values := {{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 573   f_checkMatchingValues_rcs(t_rcs(t_cs_vifp), vl_good_values,vl_wrong_values);
 574 }
 575
 576 testcase tc_cs_oifp_emb() runs on MC {
 577   var RoRCS vl_good_values := {{omit},{cs:=omit}};
 578   var RoRCS vl_wrong_values := {{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"}}
 579   f_checkMatchingValues_rcs(t_rcs(t_cs_oifp), vl_good_values,vl_wrong_values);
 580 }
 581
 582 testcase tc_cs_aifp_emb() runs on MC {
 583   var RoRCS vl_good_values := {{omit},{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 584   var RoRCS vl_wrong_values := {{}}
 585   f_checkMatchingValues_rcs(t_rcs(t_cs_aifp), vl_good_values,vl_wrong_values);
 586 }
 587
 588 testcase tc_cs_qifp_emb() runs on MC {
 589   var RoRCS vl_good_values := {{omit},{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 590   var RoRCS vl_wrong_values := {}
 591   f_checkMatchingValues_rcs(t_rcs(t_cs_qifp), vl_good_values,vl_wrong_values);
 592 }
 593
 594 // t_rcs(t_cs_al1 := * length(2); //length restriction
 595 testcase tc_cs_al1ifp_emb() runs on MC {
 596   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "}}
 597   var RoRCS vl_wrong_values := {{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 598   f_checkMatchingValues_rcs(t_rcs(t_cs_al1ifp), vl_good_values,vl_wrong_values);
 599 }
 600
 601 // t_rcs(t_cs_al1 := * length(2..4); //length restriction
 602 testcase tc_cs_al2ifp_emb() runs on MC {
 603   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{"123"},{ "ABC"},{"abc"},{"ABBA"}}
 604   var RoRCS vl_wrong_values := {{""},{"A"},{ "ABBAB"},{"anything"},{"XXXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 605   f_checkMatchingValues_rcs(t_rcs(t_cs_al2ifp), vl_good_values,vl_wrong_values);
 606 }
 607
 608 // t_rcs(t_cs_al1 := ? length(2); //length restriction
 609 testcase tc_cs_ql1ifp_emb() runs on MC {
 610   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "}}
 611   var RoRCS vl_wrong_values := {{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 612   f_checkMatchingValues_rcs(t_rcs(t_cs_ql1ifp), vl_good_values,vl_wrong_values);
 613 }
 614
 615 // t_rcs(t_cs_al1ifp := ? length(2..4); //length restriction
 616 testcase tc_cs_ql2ifp_emb() runs on MC {
 617   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{"123"},{ "ABC"},{"abc"},{"ABBA"}}
 618   var RoRCS vl_wrong_values := {{""},{"A"},{ "ABBAB"},{"anything"},{"XXXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 619   f_checkMatchingValues_rcs(t_rcs(t_cs_ql2ifp), vl_good_values,vl_wrong_values);
 620 }
 621 //("ABBA")
 622 testcase tc_cs_vl1ifp_emb() runs on MC {
 623   var RoRCS vl_good_values := {{omit},{"ABBA"}}
 624   var RoRCS vl_wrong_values := {{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 625   f_checkMatchingValues_rcs(t_rcs(t_cs_vl1ifp), vl_good_values,vl_wrong_values);
 626 }
 627 //("ABBA","baba")
 628 testcase tc_cs_vl2ifp_emb() runs on MC {
 629   var RoRCS vl_good_values := {{omit},{"ABBA"},{"baba"}}
 630   var RoRCS vl_wrong_values := {{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 631   f_checkMatchingValues_rcs(t_rcs(t_cs_vl2ifp), vl_good_values,vl_wrong_values);
 632 }
 633 //("ABBA","baba","Bye")
 634 testcase tc_cs_vl3ifp_emb() runs on MC {
 635   var RoRCS vl_good_values := {{omit},{"ABBA"},{"baba"},{"Bye"}}
 636   var RoRCS vl_wrong_values := {{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 637   f_checkMatchingValues_rcs(t_rcs(t_cs_vl3ifp), vl_good_values,vl_wrong_values);
 638 }
 639 //complement("ABBA")
 640 testcase tc_cs_c1ifp_emb() runs on MC {
 641   var RoRCS vl_good_values := {{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  """},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 642   var RoRCS vl_wrong_values := {{"ABBA"}}
 643   f_checkMatchingValues_rcs(t_rcs(t_cs_c1ifp), vl_good_values,vl_wrong_values);
 644 }
 645 //complement("ABBA","baba");
 646 testcase tc_cs_c2ifp_emb() runs on MC {
 647   var RoRCS vl_good_values :={{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 648   var RoRCS vl_wrong_values :=  {{"ABBA"},{"baba"}}
 649   f_checkMatchingValues_rcs(t_rcs(t_cs_c2ifp), vl_good_values,vl_wrong_values);
 650 }
 651 //complement("ABBA","baba","Bye");
 652 testcase tc_cs_c3ifp_emb() runs on MC {
 653   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 654   var RoRCS vl_wrong_values := {{"ABBA"},{"baba"},{"Bye"}}
 655   f_checkMatchingValues_rcs(t_rcs(t_cs_c3ifp), vl_good_values,vl_wrong_values);
 656 }
 657
 658 //("A".."B")
 659 testcase tc_cs_r1ifp_emb() runs on MC {
 660   var RoRCS vl_good_values := {{omit},{"A"},{"B"},{"ABBA"},{"AB"},{"AAAAAA"},{"BBBBB"},{"ABBABABA"}}
 661   var RoRCS vl_wrong_values := {{"ab"},{"ba"},{"Bye"},{"12"},{"A1"},{"  "},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 662   f_checkMatchingValues_rcs(t_rcs(t_cs_r1ifp),vl_good_values,vl_wrong_values);
 663 }
 664 //"a".."c"
 665 testcase tc_cs_r2ifp_emb() runs on MC {
 666   var RoRCS vl_good_values := {{omit},{""},{"a"},{"b"},{"c"},{"ab"},{"cba"},{"abbac"},{"abbababa"},{"cabacccc"}}
 667   var RoRCS vl_wrong_values := {{"A"},{"B"},{"ABBA"},{"AB"},{"AAAAAAc"},{"BBBBB"},{"ABBABABAc"},{ "Bye"},{"12"},{"abcA1"},{"  "},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 668   f_checkMatchingValues_rcs(t_rcs(t_cs_r2ifp), vl_good_values,vl_wrong_values);
 669 }
 670 //pattern "abc*xyz"
 671 testcase tc_cs_paifp_emb() runs on MC {
 672   var RoRCS vl_good_values := {{omit},{"abcxyz"},{"abcAxyz"},{"abc45xyz" }}
 673   var RoRCS vl_wrong_values := {{""},{"ab"},{"ba"},{"Bye"},{"abcyz"}}
 674   f_checkMatchingValues_rcs(t_rcs(t_cs_paifp), vl_good_values,vl_wrong_values);
 675 }
 676 //pattern "abc?xyz"
 677 testcase tc_cs_pqifp_emb() runs on MC {
 678   var RoRCS vl_good_values := {{omit},{"abcAxyz"},{"abc4xyz" }}
 679   var RoRCS vl_wrong_values := {{"ab"},{"ba"},{"Bye"},{ "abcxyz"},{"abc45xyz"}}
 680   f_checkMatchingValues_rcs(t_rcs(t_cs_pqifp), vl_good_values,vl_wrong_values);
 681 }
 682
 683
 684 //=========== Charstring Tests with Module Parameters ======
 685 testcase tc_cs_ModulePar_emb() runs on MC {
 686   log(t_rcs(tspt_cs_mod4v));
 687   if(log2str(t_rcs(tspt_cs_mod4v)) != "{ cs := \"ABBA\" }") {setverdict(fail)} else {setverdict(pass)};
 688   log(t_rcs(tspt_cs_mod4o));
 689   if(log2str(t_rcs(tspt_cs_mod4o)) != "{ cs := omit }") {setverdict(fail)} else {setverdict(pass)};
 690   log(t_rcs(tspt_cs_mod4a));
 691   if(log2str(t_rcs(tspt_cs_mod4a)) != "{ cs := * }") {setverdict(fail)} else {setverdict(pass)};
 692   log(t_rcs(tspt_cs_mod4q));
 693   if(log2str(t_rcs(tspt_cs_mod4q)) != "{ cs := ? }") {setverdict(fail)} else {setverdict(pass)};
 694   log(t_rcs(tspt_cs_mod4al1));
 695   if(log2str(t_rcs(tspt_cs_mod4al1)) != "{ cs := * length (2) }") {setverdict(fail)} else {setverdict(pass)};
 696   log(t_rcs(tspt_cs_mod4al2));
 697   if(log2str(t_rcs(tspt_cs_mod4al2)) != "{ cs := * length (2 .. 4) }") {setverdict(fail)} else {setverdict(pass)};
 698   log(t_rcs(tspt_cs_mod4ql1));
 699   if(log2str(t_rcs(tspt_cs_mod4ql1)) != "{ cs := ? length (2) }") {setverdict(fail)} else {setverdict(pass)};
 700   log(t_rcs(tspt_cs_mod4ql2));
 701   if(log2str(t_rcs(tspt_cs_mod4ql2)) != "{ cs := ? length (2 .. 4) }") {setverdict(fail)} else {setverdict(pass)};
 702   log(">",t_rcs(tspt_cs_mod4vl1),"<");
 703   if(log2str(t_rcs(tspt_cs_mod4vl1)) != "{ cs := \"ABBA\" }") {setverdict(fail)} else {setverdict(pass)};
 704   log(t_rcs(tspt_cs_mod4vl2));
 705   if(log2str(t_rcs(tspt_cs_mod4vl2)) != "{ cs := (\"ABBA\", \"baba\") }") {setverdict(fail)} else {setverdict(pass)};
 706   log(t_rcs(tspt_cs_mod4vl3));
 707   if(log2str(t_rcs(tspt_cs_mod4vl3)) != "{ cs := (\"ABBA\", \"baba\", \"Bye\") }") {setverdict(fail)} else {setverdict(pass)};
 708   log(t_rcs(tspt_cs_mod4c1));
 709   if(log2str(t_rcs(tspt_cs_mod4c1)) != "{ cs := complement (\"ABBA\") }") {setverdict(fail)} else {setverdict(pass)};
 710   log(t_rcs(tspt_cs_mod4c2));
 711   if(log2str(t_rcs(tspt_cs_mod4c2)) != "{ cs := complement (\"ABBA\", \"baba\") }") {setverdict(fail)} else {setverdict(pass)};
 712   log(t_rcs(tspt_cs_mod4c3));
 713   if(log2str(t_rcs(tspt_cs_mod4c3)) != "{ cs := complement (\"ABBA\", \"baba\", \"Bye\") }") {setverdict(fail)} else {setverdict(pass)};
 714   log(t_rcs(tspt_cs_mod4r1));
 715   if(log2str(t_rcs(tspt_cs_mod4r1)) != "{ cs := (\"A\" .. \"B\") }") {setverdict(fail)} else {setverdict(pass)};
 716   log(t_rcs(tspt_cs_mod4r2));
 717   if(log2str(t_rcs(tspt_cs_mod4r2)) != "{ cs := (\"a\" .. \"c\") }") {setverdict(fail)} else {setverdict(pass)};
 718   log(t_rcs(tspt_cs_mod4pa));
 719   if(log2str(t_rcs(tspt_cs_mod4pa)) != "{ cs := pattern \"abc*xyz\" }") {setverdict(fail)} else {setverdict(pass)};
 720   log(t_rcs(tspt_cs_mod4pq));
 721   if(log2str(t_rcs(tspt_cs_mod4pq)) != "{ cs := pattern \"abc?xyz\" }") {setverdict(fail)} else {setverdict(pass)};
 722   //==
 723   log(t_rcs(tspt_cs_mod4vifp));
 724   if(log2str(t_rcs(tspt_cs_mod4vifp)) != "{ cs := \"ABBA\" ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 725   log(t_rcs(tspt_cs_mod4oifp));
 726   if(log2str(t_rcs(tspt_cs_mod4oifp)) != "{ cs := omit ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 727   log(t_rcs(tspt_cs_mod4aifp));
 728   if(log2str(t_rcs(tspt_cs_mod4aifp)) != "{ cs := * ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 729   log(t_rcs(tspt_cs_mod4qifp));
 730   if(log2str(t_rcs(tspt_cs_mod4qifp)) != "{ cs := ? ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 731   log(t_rcs(tspt_cs_mod4al1ifp));
 732   if(log2str(t_rcs(tspt_cs_mod4al1ifp)) != "{ cs := * length (2) ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 733   log(t_rcs(tspt_cs_mod4al2ifp));
 734   if(log2str(t_rcs(tspt_cs_mod4al2ifp)) != "{ cs := * length (2 .. 4) ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 735   log(t_rcs(tspt_cs_mod4ql1ifp));
 736   if(log2str(t_rcs(tspt_cs_mod4ql1ifp)) != "{ cs := ? length (2) ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 737   log(t_rcs(tspt_cs_mod4ql2ifp));
 738   if(log2str(t_rcs(tspt_cs_mod4ql2ifp)) != "{ cs := ? length (2 .. 4) ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 739   log(t_rcs(tspt_cs_mod4vl1ifp));
 740   if(log2str(t_rcs(tspt_cs_mod4vl1ifp)) != "{ cs := \"ABBA\" ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 741   log(t_rcs(tspt_cs_mod4vl2ifp));
 742   if(log2str(t_rcs(tspt_cs_mod4vl2ifp)) != "{ cs := (\"ABBA\", \"baba\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 743   log(t_rcs(tspt_cs_mod4vl3ifp));
 744   if(log2str(t_rcs(tspt_cs_mod4vl3ifp)) != "{ cs := (\"ABBA\", \"baba\", \"Bye\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 745   log(t_rcs(tspt_cs_mod4c1ifp));
 746   if(log2str(t_rcs(tspt_cs_mod4c1ifp)) != "{ cs := complement (\"ABBA\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 747   log(t_rcs(tspt_cs_mod4c2ifp));
 748   if(log2str(t_rcs(tspt_cs_mod4c2ifp)) != "{ cs := complement (\"ABBA\", \"baba\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 749   log(t_rcs(tspt_cs_mod4c3ifp));
 750   if(log2str(t_rcs(tspt_cs_mod4c3ifp)) != "{ cs := complement (\"ABBA\", \"baba\", \"Bye\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 751   log(t_rcs(tspt_cs_mod4r1ifp));
 752   if(log2str(t_rcs(tspt_cs_mod4r1ifp)) != "{ cs := (\"A\" .. \"B\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 753   log(t_rcs(tspt_cs_mod4r2ifp));
 754   if(log2str(t_rcs(tspt_cs_mod4r2ifp)) != "{ cs := (\"a\" .. \"c\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 755   log(t_rcs(tspt_cs_mod4paifp));
 756   if(log2str(t_rcs(tspt_cs_mod4paifp)) != "{ cs := pattern \"abc*xyz\" ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 757   log(t_rcs(tspt_cs_mod4pqifp));
 758   if(log2str(t_rcs(tspt_cs_mod4pqifp)) != "{ cs := pattern \"abc?xyz\" ifpresent }") {setverdict(fail)} else {setverdict(pass)};
 759 }
 760
 761
 762 testcase tc_cs_mod4v_emb() runs on MC {
 763   var RoRCS vl_good_values := {{cs:="ABBA"}}
 764   var RoRCS vl_wrong_values := {{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 765   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4v), vl_good_values,vl_wrong_values);
 766 }
 767
 768 testcase tc_cs_mod4o_emb() runs on MC {
 769   var RoRCS vl_good_values := {{omit},{cs:=omit}};
 770   var RoRCS vl_wrong_values := {{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"}}
 771   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4o), vl_good_values,vl_wrong_values);
 772 }
 773
 774 testcase tc_cs_mod4a_emb() runs on MC {
 775   var RoRCS vl_good_values := {{omit},{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 776   var RoRCS vl_wrong_values := {{}}
 777   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4a), vl_good_values,vl_wrong_values);
 778 }
 779
 780 testcase tc_cs_mod4q_emb() runs on MC {
 781   var RoRCS vl_good_values := {{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 782   var RoRCS vl_wrong_values := {{omit}}
 783   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4q), vl_good_values,vl_wrong_values);
 784 }
 785
 786 // t_rcs(tspt_cs_mod4al1 := * length(2); //length restriction
 787 testcase tc_cs_mod4al1_emb() runs on MC {
 788   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "}}
 789   var RoRCS vl_wrong_values := {{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 790   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4al1), vl_good_values,vl_wrong_values);
 791 }
 792
 793 // t_rcs(tspt_cs_mod4al2 := * length(2..4); //length restriction
 794 testcase tc_cs_mod4al2_emb() runs on MC {
 795   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{"123"},{ "ABC"},{"abc"},{"ABBA"}}
 796   var RoRCS vl_wrong_values := {{""},{"A"},{ "ABBAB"},{"anything"},{"XXXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 797   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4al2), vl_good_values,vl_wrong_values);
 798 }
 799
 800 // t_rcs(tspt_cs_mod4ql1 := ? length(2); //length restriction
 801 testcase tc_cs_mod4ql1_emb() runs on MC {
 802   var RoRCS vl_good_values := {{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "}}
 803   var RoRCS vl_wrong_values := {{omit},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 804   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4ql1), vl_good_values,vl_wrong_values);
 805 }
 806
 807 // t_rcs(tspt_cs_mod4ql2 := ? length(2..4); //length restriction
 808 testcase tc_cs_mod4ql2_emb() runs on MC {
 809   var RoRCS vl_good_values := {{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{"123"},{ "ABC"},{"abc"},{"ABBA"}}
 810   var RoRCS vl_wrong_values := {{omit},{""},{"A"},{ "ABBAB"},{"anything"},{"XXXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 811   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4ql2), vl_good_values,vl_wrong_values);
 812 }
 813 //("ABBA")
 814 /* TODO:Adam*/
 815 testcase tc_cs_mod4vl1_emb() runs on MC {
 816   var RoRCS vl_good_values := {{"ABBA"}}
 817   var RoRCS vl_wrong_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 818   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4vl1), vl_good_values,vl_wrong_values);
 819 }
 820
 821 //("ABBA", "baba")
 822 testcase tc_cs_mod4vl2_emb() runs on MC {
 823   var RoRCS vl_good_values := {{"ABBA"},{"baba"}}
 824   var RoRCS vl_wrong_values := {{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 825   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4vl2), vl_good_values,vl_wrong_values);
 826 }
 827 //("ABBA","baba","Bye")
 828 testcase tc_cs_mod4vl3_emb() runs on MC {
 829   var RoRCS vl_good_values := {{"ABBA"},{"baba"},{"Bye"}}
 830   var RoRCS vl_wrong_values := {{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 831   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4vl3), vl_good_values,vl_wrong_values);
 832 }
 833 // Note: this tests legacy behavior and requires the -M compiler option!
 834 //complement("ABBA")
 835 testcase tc_cs_mod4c1_emb() runs on MC {
 836   var RoRCS vl_good_values := {{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  """},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 837   var RoRCS vl_wrong_values := {{"ABBA"}}
 838   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4c1), vl_good_values,vl_wrong_values);
 839 }
 840 // Note: this tests legacy behavior and requires the -M compiler option!
 841 //complement("ABBA","baba");
 842 testcase tc_cs_mod4c2_emb() runs on MC {
 843   var RoRCS vl_good_values :={{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 844   var RoRCS vl_wrong_values :=  {{"ABBA"},{"baba"}}
 845   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4c2), vl_good_values,vl_wrong_values);
 846 }
 847 // Note: this tests legacy behavior and requires the -M compiler option!
 848 //complement("ABBA","baba","Bye");
 849 testcase tc_cs_mod4c3_emb() runs on MC {
 850   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 851   var RoRCS vl_wrong_values := {{"ABBA"},{"baba"},{"Bye"}}
 852   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4c3), vl_good_values,vl_wrong_values);
 853 }
 854
 855 //("A".."B")
 856 testcase tc_cs_mod4r1_emb() runs on MC {
 857   var RoRCS vl_good_values := {{"A"},{"B"},{"ABBA"},{"AB"},{"AAAAAA"},{"BBBBB"},{"ABBABABA"}}
 858   var RoRCS vl_wrong_values := {{omit},{"ab"},{"ba"},{"Bye"},{"12"},{"A1"},{"  "},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 859   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4r1),vl_good_values,vl_wrong_values);
 860 }
 861 //"a".."c"
 862 testcase tc_cs_mod4r2_emb() runs on MC {
 863   var RoRCS vl_good_values := {{""},{"a"},{"b"},{"c"},{"ab"},{"cba"},{"abbac"},{"abbababa"},{"cabacccc"}}
 864   var RoRCS vl_wrong_values := {{omit},{"A"},{"B"},{"ABBA"},{"AB"},{"AAAAAAc"},{"BBBBB"},{"ABBABABAc"},{ "Bye"},{"12"},{"abcA1"},{"  "},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 865   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4r2), vl_good_values,vl_wrong_values);
 866 }
 867 //pattern "abc*xyz"
 868 testcase tc_cs_mod4pa_emb() runs on MC {
 869   var RoRCS vl_good_values := {{ "abcxyz"},{"abcAxyz"},{"abc45xyz" }}
 870   var RoRCS vl_wrong_values := {{""},{"ab"},{"ba"},{"Bye"},{"abcyz"}}
 871   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4pa), vl_good_values,vl_wrong_values);
 872 }
 873 //pattern "abc?xyz"
 874 testcase tc_cs_mod4pq_emb() runs on MC {
 875   var RoRCS vl_good_values := {{"abcAxyz"},{"abc4xyz" }}
 876   var RoRCS vl_wrong_values := {{ "ab"},{"ba"},{"Bye"},{ "abcxyz"},{"abc45xyz"}}
 877   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4pq), vl_good_values,vl_wrong_values);
 878 }
 879
 880 //===
 881 testcase tc_cs_mod4vifp_emb() runs on MC {
 882   var RoRCS vl_good_values := {{omit},{cs:="ABBA"}}
 883   var RoRCS vl_wrong_values := {{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 884   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4vifp), vl_good_values,vl_wrong_values);
 885 }
 886
 887 testcase tc_cs_mod4oifp_emb() runs on MC {
 888   var RoRCS vl_good_values := {{omit},{cs:=omit}};
 889   var RoRCS vl_wrong_values := {{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"}}
 890   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4oifp), vl_good_values,vl_wrong_values);
 891 }
 892
 893 testcase tc_cs_mod4aifp_emb() runs on MC {
 894   var RoRCS vl_good_values := {{omit},{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 895   var RoRCS vl_wrong_values := {{}}
 896   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4aifp), vl_good_values,vl_wrong_values);
 897 }
 898
 899 testcase tc_cs_mod4qifp_emb() runs on MC {
 900   var RoRCS vl_good_values := {{omit},{""},{"A"},{"AB"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"}}
 901   var RoRCS vl_wrong_values := {}
 902   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4qifp), vl_good_values,vl_wrong_values);
 903 }
 904
 905 // t_rcs(tspt_cs_mod4al1 := * length(2); //length restriction
 906 testcase tc_cs_mod4al1ifp_emb() runs on MC {
 907   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "}}
 908   var RoRCS vl_wrong_values := {{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 909   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4al1ifp), vl_good_values,vl_wrong_values);
 910 }
 911
 912 // t_rcs(tspt_cs_mod4al1 := * length(2..4); //length restriction
 913 testcase tc_cs_mod4al2ifp_emb() runs on MC {
 914   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{"123"},{ "ABC"},{"abc"},{"ABBA"}}
 915   var RoRCS vl_wrong_values := {{""},{"A"},{ "ABBAB"},{"anything"},{"XXXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 916   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4al2ifp), vl_good_values,vl_wrong_values);
 917 }
 918
 919 // t_rcs(tspt_cs_mod4al1 := ? length(2); //length restriction
 920 testcase tc_cs_mod4ql1ifp_emb() runs on MC {
 921   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "}}
 922   var RoRCS vl_wrong_values := {{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 923   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4ql1ifp), vl_good_values,vl_wrong_values);
 924 }
 925
 926 // t_rcs(tspt_cs_mod4al1ifp := ? length(2..4); //length restriction
 927 testcase tc_cs_mod4ql2ifp_emb() runs on MC {
 928   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{"123"},{ "ABC"},{"abc"},{"ABBA"}}
 929   var RoRCS vl_wrong_values := {{""},{"A"},{ "ABBAB"},{"anything"},{"XXXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 930   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4ql2ifp), vl_good_values,vl_wrong_values);
 931 }
 932 //("ABBA")
 933 /* TODO:Adam*/
 934 testcase tc_cs_mod4vl1ifp_emb() runs on MC {
 935   var RoRCS vl_good_values := {{omit},{"ABBA"}}
 936   var RoRCS vl_wrong_values := {{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 937   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4vl1ifp), vl_good_values,vl_wrong_values);
 938 }
 939
 940 //("ABBA","baba") //TR: HR98602, 'Matching fault in case of template ("A","B") ifpresent'
 941 testcase tc_cs_mod4vl2ifp_emb() runs on MC {
 942   var RoRCS vl_good_values := {{omit},{"ABBA"},{"baba"}}
 943   var RoRCS vl_wrong_values := {{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 944   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4vl2ifp), vl_good_values,vl_wrong_values);
 945 }
 946 //("ABBA","baba","Bye")
 947 testcase tc_cs_mod4vl3ifp_emb() runs on MC {
 948   var RoRCS vl_good_values := {{omit},{"ABBA"},{"baba"},{"Bye"}}
 949   var RoRCS vl_wrong_values := {{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 950   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4vl3ifp), vl_good_values,vl_wrong_values);
 951 }
 952 //complement("ABBA")
 953 testcase tc_cs_mod4c1ifp_emb() runs on MC {
 954   var RoRCS vl_good_values := {{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  """},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 955   var RoRCS vl_wrong_values := {{"ABBA"}}
 956   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4c1ifp), vl_good_values,vl_wrong_values);
 957 }
 958 //complement("ABBA","baba");
 959 testcase tc_cs_mod4c2ifp_emb() runs on MC {
 960   var RoRCS vl_good_values :={{omit},{"AB"},{"ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 961   var RoRCS vl_wrong_values :=  {{"ABBA"},{"baba"}}
 962   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4c2ifp), vl_good_values,vl_wrong_values);
 963 }
 964 //complement("ABBA","baba","Bye");
 965 testcase tc_cs_mod4c3ifp_emb() runs on MC {
 966   var RoRCS vl_good_values := {{omit},{"AB"},{ "ab"},{"ba"},{"12"},{"A1"},{"  "},{""},{"A"},{"ABB"},{"ABBAB"},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 967   var RoRCS vl_wrong_values := {{"ABBA"},{"baba"},{"Bye"}}
 968   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4c3ifp), vl_good_values,vl_wrong_values);
 969 }
 970
 971 //("A".."B")
 972 testcase tc_cs_mod4r1ifp_emb() runs on MC {
 973   var RoRCS vl_good_values := {{omit},{"A"},{"B"},{"ABBA"},{"AB"},{"AAAAAA"},{"BBBBB"},{"ABBABABA"}}
 974   var RoRCS vl_wrong_values := {{"ab"},{"ba"},{"Bye"},{"12"},{"A1"},{"  "},{"abba"},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 975   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4r1ifp),vl_good_values,vl_wrong_values);
 976 }
 977 //"a".."c"
 978 testcase tc_cs_mod4r2ifp_emb() runs on MC {
 979   var RoRCS vl_good_values := {{omit},{""},{"a"},{"b"},{"c"},{"ab"},{"cba"},{"abbac"},{"abbababa"},{"cabacccc"}}
 980   var RoRCS vl_wrong_values := {{"A"},{"B"},{"ABBA"},{"AB"},{"AAAAAAc"},{"BBBBB"},{"ABBABABAc"},{ "Bye"},{"12"},{"abcA1"},{"  "},{"anything"},{"XXXX"},{"ABCDE"},{"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"}}
 981   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4r2ifp), vl_good_values,vl_wrong_values);
 982 }
 983 //pattern "abc*xyz"
 984 testcase tc_cs_mod4paifp_emb() runs on MC {
 985   var RoRCS vl_good_values := {{omit},{"abcxyz"},{"abcAxyz"},{"abc45xyz" }}
 986   var RoRCS vl_wrong_values := {{""},{"ab"},{"ba"},{"Bye"},{"abcyz"}}
 987   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4paifp), vl_good_values,vl_wrong_values);
 988 }
 989 //pattern "abc?xyz"
 990 testcase tc_cs_mod4pqifp_emb() runs on MC {
 991   var RoRCS vl_good_values := {{omit},{"abcAxyz"},{"abc4xyz" }}
 992   var RoRCS vl_wrong_values := {{"ab"},{"ba"},{"Bye"},{ "abcxyz"},{"abc45xyz"}}
 993   f_checkMatchingValues_rcs(t_rcs(tspt_cs_mod4pqifp), vl_good_values,vl_wrong_values);
 994 }
 995
 996 //=
 997 testcase tc_cs_ttcn2string_emb() runs on MC {
 998   log(t_rcs(tspt_cs_mod4v));
 999   if(ttcn2string(t_rcs(tspt_cs_mod4v)) != "{ cs := \"ABBA\" }") {setverdict(fail)} else {setverdict(pass)};
1000   log(t_rcs(tspt_cs_mod4o));
1001   if(ttcn2string(t_rcs(tspt_cs_mod4o)) != "{ cs := omit }") {setverdict(fail)} else {setverdict(pass)};
1002   log(t_rcs(tspt_cs_mod4a));
1003   if(ttcn2string(t_rcs(tspt_cs_mod4a)) != "{ cs := * }") {setverdict(fail)} else {setverdict(pass)};
1004   log(t_rcs(tspt_cs_mod4q));
1005   if(ttcn2string(t_rcs(tspt_cs_mod4q)) != "{ cs := ? }") {setverdict(fail)} else {setverdict(pass)};
1006   log(t_rcs(tspt_cs_mod4al1));
1007   if(ttcn2string(t_rcs(tspt_cs_mod4al1)) != "{ cs := * length (2) }") {setverdict(fail)} else {setverdict(pass)};
1008   log(t_rcs(tspt_cs_mod4al2));
1009   if(ttcn2string(t_rcs(tspt_cs_mod4al2)) != "{ cs := * length (2 .. 4) }") {setverdict(fail)} else {setverdict(pass)};
1010   log(t_rcs(tspt_cs_mod4ql1));
1011   if(ttcn2string(t_rcs(tspt_cs_mod4ql1)) != "{ cs := ? length (2) }") {setverdict(fail)} else {setverdict(pass)};
1012   log(t_rcs(tspt_cs_mod4ql2));
1013   if(ttcn2string(t_rcs(tspt_cs_mod4ql2)) != "{ cs := ? length (2 .. 4) }") {setverdict(fail)} else {setverdict(pass)};
1014   log(">",t_rcs(tspt_cs_mod4vl1),"<");
1015   if(ttcn2string(t_rcs(tspt_cs_mod4vl1)) != "{ cs := \"ABBA\" }") {setverdict(fail)} else {setverdict(pass)};
1016   log(t_rcs(tspt_cs_mod4vl2));
1017   if(ttcn2string(t_rcs(tspt_cs_mod4vl2)) != "{ cs := (\"ABBA\", \"baba\") }") {setverdict(fail)} else {setverdict(pass)};
1018   log(t_rcs(tspt_cs_mod4vl3));
1019   if(ttcn2string(t_rcs(tspt_cs_mod4vl3)) != "{ cs := (\"ABBA\", \"baba\", \"Bye\") }") {setverdict(fail)} else {setverdict(pass)};
1020   log(t_rcs(tspt_cs_mod4c1));
1021   if(ttcn2string(t_rcs(tspt_cs_mod4c1)) != "{ cs := complement (\"ABBA\") }") {setverdict(fail)} else {setverdict(pass)};
1022   log(t_rcs(tspt_cs_mod4c2));
1023   if(ttcn2string(t_rcs(tspt_cs_mod4c2)) != "{ cs := complement (\"ABBA\", \"baba\") }") {setverdict(fail)} else {setverdict(pass)};
1024   log(t_rcs(tspt_cs_mod4c3));
1025   if(ttcn2string(t_rcs(tspt_cs_mod4c3)) != "{ cs := complement (\"ABBA\", \"baba\", \"Bye\") }") {setverdict(fail)} else {setverdict(pass)};
1026   log(t_rcs(tspt_cs_mod4r1));
1027   if(ttcn2string(t_rcs(tspt_cs_mod4r1)) != "{ cs := (\"A\" .. \"B\") }") {setverdict(fail)} else {setverdict(pass)};
1028   log(t_rcs(tspt_cs_mod4r2));
1029   if(ttcn2string(t_rcs(tspt_cs_mod4r2)) != "{ cs := (\"a\" .. \"c\") }") {setverdict(fail)} else {setverdict(pass)};
1030   log(t_rcs(tspt_cs_mod4pa));
1031   if(ttcn2string(t_rcs(tspt_cs_mod4pa)) != "{ cs := pattern \"abc*xyz\" }") {setverdict(fail)} else {setverdict(pass)};
1032   log(t_rcs(tspt_cs_mod4pq));
1033   if(ttcn2string(t_rcs(tspt_cs_mod4pq)) != "{ cs := pattern \"abc?xyz\" }") {setverdict(fail)} else {setverdict(pass)};
1034   //==
1035   log(t_rcs(tspt_cs_mod4vifp));
1036   if(ttcn2string(t_rcs(tspt_cs_mod4vifp)) != "{ cs := \"ABBA\" ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1037   log(t_rcs(tspt_cs_mod4oifp));
1038   if(ttcn2string(t_rcs(tspt_cs_mod4oifp)) != "{ cs := omit ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1039   log(t_rcs(tspt_cs_mod4aifp));
1040   if(ttcn2string(t_rcs(tspt_cs_mod4aifp)) != "{ cs := * ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1041   log(t_rcs(tspt_cs_mod4qifp));
1042   if(ttcn2string(t_rcs(tspt_cs_mod4qifp)) != "{ cs := ? ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1043   log(t_rcs(tspt_cs_mod4al1ifp));
1044   if(ttcn2string(t_rcs(tspt_cs_mod4al1ifp)) != "{ cs := * length (2) ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1045   log(t_rcs(tspt_cs_mod4al2ifp));
1046   if(ttcn2string(t_rcs(tspt_cs_mod4al2ifp)) != "{ cs := * length (2 .. 4) ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1047   log(t_rcs(tspt_cs_mod4ql1ifp));
1048   if(ttcn2string(t_rcs(tspt_cs_mod4ql1ifp)) != "{ cs := ? length (2) ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1049   log(t_rcs(tspt_cs_mod4ql2ifp));
1050   if(ttcn2string(t_rcs(tspt_cs_mod4ql2ifp)) != "{ cs := ? length (2 .. 4) ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1051   log(t_rcs(tspt_cs_mod4vl1ifp));
1052   if(ttcn2string(t_rcs(tspt_cs_mod4vl1ifp)) != "{ cs := \"ABBA\" ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1053   log(t_rcs(tspt_cs_mod4vl2ifp));
1054   if(ttcn2string(t_rcs(tspt_cs_mod4vl2ifp)) != "{ cs := (\"ABBA\", \"baba\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1055   log(t_rcs(tspt_cs_mod4vl3ifp));
1056   if(ttcn2string(t_rcs(tspt_cs_mod4vl3ifp)) != "{ cs := (\"ABBA\", \"baba\", \"Bye\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1057   log(t_rcs(tspt_cs_mod4c1ifp));
1058   if(ttcn2string(t_rcs(tspt_cs_mod4c1ifp)) != "{ cs := complement (\"ABBA\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1059   log(t_rcs(tspt_cs_mod4c2ifp));
1060   if(ttcn2string(t_rcs(tspt_cs_mod4c2ifp)) != "{ cs := complement (\"ABBA\", \"baba\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1061   log(t_rcs(tspt_cs_mod4c3ifp));
1062   if(ttcn2string(t_rcs(tspt_cs_mod4c3ifp)) != "{ cs := complement (\"ABBA\", \"baba\", \"Bye\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1063   log(t_rcs(tspt_cs_mod4r1ifp));
1064   if(ttcn2string(t_rcs(tspt_cs_mod4r1ifp)) != "{ cs := (\"A\" .. \"B\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1065   log(t_rcs(tspt_cs_mod4r2ifp));
1066   if(ttcn2string(t_rcs(tspt_cs_mod4r2ifp)) != "{ cs := (\"a\" .. \"c\") ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1067   log(t_rcs(tspt_cs_mod4paifp));
1068   if(ttcn2string(t_rcs(tspt_cs_mod4paifp)) != "{ cs := pattern \"abc*xyz\" ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1069   log(t_rcs(tspt_cs_mod4pqifp));
1070   if(ttcn2string(t_rcs(tspt_cs_mod4pqifp)) != "{ cs := pattern \"abc?xyz\" ifpresent }") {setverdict(fail)} else {setverdict(pass)};
1071 }
1072
1073 //==== string2ttcn testcases ===============================================================
1074 //These testcases tests if
1075 // 1. string2ttcn can generate the expected template
1076 // 2. string2ttcn can generate the expected value, if possible/required (=true the third arg)
1077 //===========================================================================================
1078 testcase tc_cs_string2ttcn_mod4v() runs on MC {
1079   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4v)),t_rcs(tspt_cs_mod4v));
1080   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4v)),t_rcs(tspt_cs_mod4v),true);
1081 }
1082
1083 testcase tc_cs_string2ttcn_mod4o() runs on MC {
1084   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4o)),t_rcs(tspt_cs_mod4o));
1085   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4o)),t_rcs(tspt_cs_mod4o),true);
1086 }
1087
1088 //omit length
1089 testcase tc_cs_string2ttcn_mod4ol() runs on MC {
1090   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4ol)),t_rcs(tspt_cs_mod4ol));
1091   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4ol)),t_rcs(tspt_cs_mod4ol),false);
1092 }
1093
1094 testcase tc_cs_string2ttcn_mod4a() runs on MC {
1095   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4a)),t_rcs(tspt_cs_mod4a));
1096   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4a)),t_rcs(tspt_cs_mod4a),false);
1097 }
1098
1099 testcase tc_cs_string2ttcn_mod4q() runs on MC {
1100   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4q)),t_rcs(tspt_cs_mod4q));
1101   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4q)),t_rcs(tspt_cs_mod4q),false);
1102 }
1103
1104 testcase tc_cs_string2ttcn_mod4al1() runs on MC {
1105   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4al1)),t_rcs(tspt_cs_mod4al1));
1106   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4al1)),t_rcs(tspt_cs_mod4al1),false);
1107 }
1108
1109 testcase tc_cs_string2ttcn_mod4al2() runs on MC {
1110   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4al2)),t_rcs(tspt_cs_mod4al2));
1111   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4al2)),t_rcs(tspt_cs_mod4al2),false);
1112 }
1113
1114 testcase tc_cs_string2ttcn_mod4ql1() runs on MC {
1115   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4ql1)),t_rcs(tspt_cs_mod4ql1));
1116   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4ql1)),t_rcs(tspt_cs_mod4ql1),false);
1117 }
1118
1119 testcase tc_cs_string2ttcn_mod4ql2() runs on MC {
1120   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4ql2)),t_rcs(tspt_cs_mod4ql2));
1121   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4ql2)),t_rcs(tspt_cs_mod4ql2),false);
1122 }
1123
1124 testcase tc_cs_string2ttcn_mod4vl1() runs on MC {
1125   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4vl1)),t_rcs(tspt_cs_mod4vl1));
1126   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4vl1)),t_rcs(tspt_cs_mod4vl1),true);
1127 }
1128
1129 testcase tc_cs_string2ttcn_mod4vl2() runs on MC {
1130   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4vl2)),t_rcs(tspt_cs_mod4vl2));
1131   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4vl2)),t_rcs(tspt_cs_mod4vl2),false);
1132 }
1133
1134 testcase tc_cs_string2ttcn_mod4vl3() runs on MC {
1135   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4vl3)),t_rcs(tspt_cs_mod4vl3));
1136   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4vl3)),t_rcs(tspt_cs_mod4vl3),false);
1137 }
1138
1139 testcase tc_cs_string2ttcn_mod4c1() runs on MC {
1140   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4c1)),t_rcs(tspt_cs_mod4c1));
1141   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4c1)),t_rcs(tspt_cs_mod4c1),false);
1142 }
1143
1144 testcase tc_cs_string2ttcn_mod4c2() runs on MC {
1145   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4c2)),t_rcs(tspt_cs_mod4c2));
1146   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4c2)),t_rcs(tspt_cs_mod4c2),false);
1147 }
1148
1149 testcase tc_cs_string2ttcn_mod4c3() runs on MC {
1150   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4c3)),t_rcs(tspt_cs_mod4c3));
1151   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4c3)),t_rcs(tspt_cs_mod4c3),false);
1152 }
1153
1154 testcase tc_cs_string2ttcn_mod4r1() runs on MC {
1155   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4r1)),t_rcs(tspt_cs_mod4r1));
1156   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4r1)),t_rcs(tspt_cs_mod4r1),false);
1157 }
1158
1159 testcase tc_cs_string2ttcn_mod4r2() runs on MC {
1160   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4r2)),t_rcs(tspt_cs_mod4r2));
1161   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4r2)),t_rcs(tspt_cs_mod4r2),false);
1162 }
1163
1164 testcase tc_cs_string2ttcn_mod4pa() runs on MC {
1165   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4pa)),t_rcs(tspt_cs_mod4pa));
1166   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4pa)),t_rcs(tspt_cs_mod4pa),false);
1167 }
1168
1169 testcase tc_cs_string2ttcn_mod4pq() runs on MC {
1170   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4pq)),t_rcs(tspt_cs_mod4pq));
1171   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4pq)),t_rcs(tspt_cs_mod4pq),false);
1172 }
1173
1174 // ifp
1175
1176 testcase tc_cs_string2ttcn_mod4vifp() runs on MC {
1177   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4vifp)),t_rcs(tspt_cs_mod4vifp));
1178   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4vifp)),t_rcs(tspt_cs_mod4vifp),false);
1179 }
1180
1181 testcase tc_cs_string2ttcn_mod4oifp() runs on MC {
1182   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4oifp)),t_rcs(tspt_cs_mod4oifp));
1183   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4oifp)),t_rcs(tspt_cs_mod4oifp),false);
1184 }
1185
1186 testcase tc_cs_string2ttcn_mod4aifp() runs on MC {
1187   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4aifp)),t_rcs(tspt_cs_mod4aifp));
1188   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4aifp)),t_rcs(tspt_cs_mod4aifp),false);
1189 }
1190
1191 testcase tc_cs_string2ttcn_mod4qifp() runs on MC {
1192   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4qifp)),t_rcs(tspt_cs_mod4qifp));
1193   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4qifp)),t_rcs(tspt_cs_mod4qifp),false);
1194 }
1195
1196 testcase tc_cs_string2ttcn_mod4al1ifp() runs on MC {
1197   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4al1ifp)),t_rcs(tspt_cs_mod4al1ifp));
1198   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4al1ifp)),t_rcs(tspt_cs_mod4al1ifp),false);
1199 }
1200
1201 testcase tc_cs_string2ttcn_mod4al2ifp() runs on MC {
1202   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4al2ifp)),t_rcs(tspt_cs_mod4al2ifp));
1203   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4al2ifp)),t_rcs(tspt_cs_mod4al2ifp),false);
1204 }
1205
1206 testcase tc_cs_string2ttcn_mod4ql1ifp() runs on MC {
1207   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4ql1ifp)),t_rcs(tspt_cs_mod4ql1ifp));
1208   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4ql1ifp)),t_rcs(tspt_cs_mod4ql1ifp),false);
1209 }
1210
1211 testcase tc_cs_string2ttcn_mod4ql2ifp() runs on MC {
1212   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4ql2ifp)),t_rcs(tspt_cs_mod4ql2ifp));
1213   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4ql2ifp)),t_rcs(tspt_cs_mod4ql2ifp),false);
1214 }
1215
1216 testcase tc_cs_string2ttcn_mod4vl1ifp() runs on MC {
1217   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4vl1ifp)),t_rcs(tspt_cs_mod4vl1ifp));
1218   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4vl1ifp)),t_rcs(tspt_cs_mod4vl1ifp),false);
1219 }
1220
1221 testcase tc_cs_string2ttcn_mod4vl2ifp() runs on MC {
1222   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4vl2ifp)),t_rcs(tspt_cs_mod4vl2ifp));
1223   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4vl2ifp)),t_rcs(tspt_cs_mod4vl2ifp),false);
1224 }
1225
1226 testcase tc_cs_string2ttcn_mod4vl3ifp() runs on MC {
1227   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4vl3ifp)),t_rcs(tspt_cs_mod4vl3ifp));
1228   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4vl3ifp)),t_rcs(tspt_cs_mod4vl3ifp),false);
1229 }
1230
1231 testcase tc_cs_string2ttcn_mod4c1ifp() runs on MC {
1232   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4c1ifp)),t_rcs(tspt_cs_mod4c1ifp));
1233   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4c1ifp)),t_rcs(tspt_cs_mod4c1ifp),false);
1234 }
1235
1236 testcase tc_cs_string2ttcn_mod4c2ifp() runs on MC {
1237   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4c2ifp)),t_rcs(tspt_cs_mod4c2ifp));
1238   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4c2ifp)),t_rcs(tspt_cs_mod4c2ifp),false);
1239 }
1240
1241 testcase tc_cs_string2ttcn_mod4c3ifp() runs on MC {
1242   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4c3ifp)),t_rcs(tspt_cs_mod4c3ifp));
1243   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4c3ifp)),t_rcs(tspt_cs_mod4c3ifp),false);
1244 }
1245
1246 testcase tc_cs_string2ttcn_mod4r1ifp() runs on MC {
1247   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4r1ifp)),t_rcs(tspt_cs_mod4r1ifp));
1248   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4r1ifp)),t_rcs(tspt_cs_mod4r1ifp),false);
1249 }
1250
1251 testcase tc_cs_string2ttcn_mod4r2ifp() runs on MC {
1252   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4r2ifp)),t_rcs(tspt_cs_mod4r2ifp));
1253   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4r2ifp)),t_rcs(tspt_cs_mod4r2ifp),false);
1254 }
1255
1256 testcase tc_cs_string2ttcn_mod4paifp() runs on MC {
1257   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4paifp)),t_rcs(tspt_cs_mod4paifp));
1258   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4paifp)),t_rcs(tspt_cs_mod4paifp),false);
1259 }
1260
1261 testcase tc_cs_string2ttcn_mod4pqifp() runs on MC {
1262   f_string2ttcn_rcs_t(ttcn2string(t_rcs(tspt_cs_mod4pqifp)),t_rcs(tspt_cs_mod4pqifp));
1263   f_string2ttcn_rcs_v(ttcn2string(t_rcs(tspt_cs_mod4pqifp)),t_rcs(tspt_cs_mod4pqifp),false);
1264 }
1265
1266 control {
1267
1268   log("***charstring tests****");
1269   execute(tc_cs_v());
1270   execute(tc_cs_o());
1271   execute(tc_cs_a());
1272   execute(tc_cs_q());
1273   execute(tc_cs_al1());
1274   execute(tc_cs_al2());
1275   execute(tc_cs_ql1());
1276   execute(tc_cs_ql2());
1277   //execute(tc_cs_c());
1278   execute(tc_cs_vl1());
1279   execute(tc_cs_vl2());
1280   execute(tc_cs_vl3());
1281   execute(tc_cs_c1());
1282   execute(tc_cs_c2());
1283   execute(tc_cs_c3());
1284   execute(tc_cs_r1());
1285   execute(tc_cs_r2());
1286   execute(tc_cs_pa());
1287   execute(tc_cs_pq());
1288   //=== charstring embedded in record ====
1289   execute(tc_cs_v_emb());
1290   execute(tc_cs_o_emb());
1291   execute(tc_cs_a_emb());
1292   execute(tc_cs_q_emb());
1293   execute(tc_cs_al1_emb());
1294   execute(tc_cs_al2_emb());
1295   execute(tc_cs_ql1_emb());
1296   execute(tc_cs_ql2_emb());
1297   //execute(tc_cs_c_emb());
1298   execute(tc_cs_vl1_emb());
1299   execute(tc_cs_vl2_emb());
1300   execute(tc_cs_vl3_emb());
1301   execute(tc_cs_c1_emb());
1302   execute(tc_cs_c2_emb());
1303   execute(tc_cs_c3_emb());
1304   execute(tc_cs_r1_emb());
1305   execute(tc_cs_r2_emb());
1306   execute(tc_cs_pa_emb());
1307   execute(tc_cs_pq_emb());
1308   //embedded + ifpresent
1309   execute(tc_cs_vifp_emb());
1310   execute(tc_cs_oifp_emb());
1311   execute(tc_cs_aifp_emb());
1312   execute(tc_cs_qifp_emb());
1313   execute(tc_cs_al1ifp_emb());
1314   execute(tc_cs_al2ifp_emb());
1315   execute(tc_cs_ql1ifp_emb());
1316   execute(tc_cs_ql2ifp_emb());
1317   execute(tc_cs_vl1ifp_emb());
1318   //execute(tc_cs_vl2ifp_emb());
1319   execute(tc_cs_vl3ifp_emb());
1320   execute(tc_cs_c1ifp_emb());
1321   execute(tc_cs_c2ifp_emb());
1322   execute(tc_cs_c3ifp_emb());
1323   execute(tc_cs_r1ifp_emb());
1324   execute(tc_cs_r2ifp_emb());
1325   execute(tc_cs_paifp_emb());
1326   execute(tc_cs_pqifp_emb());
1327
1328   //======modified modulepar template wth type of charstring====
1329   execute(tc_cs_ModulePar_emb());
1330   execute(tc_cs_mod4v_emb());
1331   execute(tc_cs_mod4o_emb());
1332   execute(tc_cs_mod4a_emb());
1333   execute(tc_cs_mod4q_emb());
1334   execute(tc_cs_mod4al1_emb());
1335   execute(tc_cs_mod4al2_emb());
1336   execute(tc_cs_mod4ql1_emb());
1337   execute(tc_cs_mod4ql2_emb());
1338   execute(tc_cs_mod4vl1_emb());
1339   execute(tc_cs_mod4vl2_emb());
1340   execute(tc_cs_mod4vl3_emb());
1341   execute(tc_cs_mod4c1_emb());
1342   execute(tc_cs_mod4c2_emb());
1343   execute(tc_cs_mod4c3_emb());
1344   execute(tc_cs_mod4r1_emb());
1345   execute(tc_cs_mod4r2_emb());
1346   execute(tc_cs_mod4pa_emb());
1347   execute(tc_cs_mod4pq_emb());
1348   //embedded + ifpresent
1349   execute(tc_cs_mod4vifp_emb());
1350   execute(tc_cs_mod4oifp_emb());
1351   execute(tc_cs_mod4aifp_emb());
1352   execute(tc_cs_mod4qifp_emb());
1353   execute(tc_cs_mod4al1ifp_emb());
1354   execute(tc_cs_mod4al2ifp_emb());
1355   execute(tc_cs_mod4ql1ifp_emb());
1356   execute(tc_cs_mod4ql2ifp_emb());
1357   execute(tc_cs_mod4vl1ifp_emb()); //Adam solved
1358   execute(tc_cs_mod4vl2ifp_emb()); //Fixed: TR: HR98602, 'Matching fault in case of template ("A","B") ifpresent'
1359   execute(tc_cs_mod4vl3ifp_emb());
1360   execute(tc_cs_mod4c1ifp_emb());
1361   execute(tc_cs_mod4c2ifp_emb());
1362   execute(tc_cs_mod4c3ifp_emb());
1363   execute(tc_cs_mod4r1ifp_emb());
1364   execute(tc_cs_mod4r2ifp_emb());
1365   execute(tc_cs_mod4paifp_emb());
1366   execute(tc_cs_mod4pqifp_emb());
1367
1368   //ttcn2string:
1369   execute(tc_cs_ttcn2string_emb());
1370   execute(tc_cs_string2ttcn_mod4v());
1371   execute(tc_cs_string2ttcn_mod4o());
1372   execute(tc_cs_string2ttcn_mod4ol());
1373   execute(tc_cs_string2ttcn_mod4a());
1374   execute(tc_cs_string2ttcn_mod4q());
1375   execute(tc_cs_string2ttcn_mod4al1());
1376   execute(tc_cs_string2ttcn_mod4al2());
1377   execute(tc_cs_string2ttcn_mod4ql1());
1378   execute(tc_cs_string2ttcn_mod4ql2());
1379   execute(tc_cs_string2ttcn_mod4vl1());
1380   execute(tc_cs_string2ttcn_mod4vl2());
1381   execute(tc_cs_string2ttcn_mod4vl3());
1382   execute(tc_cs_string2ttcn_mod4c1());
1383   execute(tc_cs_string2ttcn_mod4c2());
1384   execute(tc_cs_string2ttcn_mod4c3());
1385   execute(tc_cs_string2ttcn_mod4r1());
1386   execute(tc_cs_string2ttcn_mod4r2());
1387   execute(tc_cs_string2ttcn_mod4pa());
1388   execute(tc_cs_string2ttcn_mod4pq());
1389   //ttcn2string with ifpresent
1390   execute(tc_cs_string2ttcn_mod4vifp());
1391   execute(tc_cs_string2ttcn_mod4oifp());
1392   execute(tc_cs_string2ttcn_mod4aifp());
1393   execute(tc_cs_string2ttcn_mod4qifp());
1394   execute(tc_cs_string2ttcn_mod4al1ifp());
1395   execute(tc_cs_string2ttcn_mod4al2ifp());
1396   execute(tc_cs_string2ttcn_mod4ql1ifp());
1397   execute(tc_cs_string2ttcn_mod4ql2ifp());
1398   execute(tc_cs_string2ttcn_mod4vl1ifp());
1399   execute(tc_cs_string2ttcn_mod4vl2ifp());
1400   execute(tc_cs_string2ttcn_mod4vl3ifp());
1401   execute(tc_cs_string2ttcn_mod4c1ifp());
1402   execute(tc_cs_string2ttcn_mod4c2ifp());
1403   execute(tc_cs_string2ttcn_mod4c3ifp());
1404   execute(tc_cs_string2ttcn_mod4r1ifp());
1405   execute(tc_cs_string2ttcn_mod4r2ifp());
1406   execute(tc_cs_string2ttcn_mod4paifp());
1407   execute(tc_cs_string2ttcn_mod4pqifp());
1408
1409 }
1410
1411 }