regression_test/XML/NegativeTest/rec.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 rec {
   9 import from ReadXml all;
  10
  11 type record R {
  12   integer i,
  13   charstring s,
  14   boolean b,
  15   float f
  16 }
  17
  18 external function encR(in R par) return octetstring
  19 with { extension "prototype(convert) encode(XER:XER_EXTENDED)" }
  20
  21 type component Neg {}
  22
  23 function check_match(in Nodes nodes, in template Nodes tmpl)
  24 {
  25   //log("check_match: ", nodes);
  26   if (not match(lengthof(nodes), lengthof(tmpl))) {
  27     setverdict(fail, match(lengthof(nodes), lengthof(tmpl)));
  28   }
  29   if (match(nodes, tmpl))
  30        { setverdict(pass); }
  31   else { setverdict(fail, match(nodes, tmpl)); }
  32 }
  33
  34 /* * * * * * * * Plain old unmolested record value * * * * * * * */
  35 const R c_plain :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
  36
  37 /* The expected XML for the unmolested value:
  38 <R>
  39         <i>42</i>
  40         <s>fourty-two</s>
  41         <b>true</b>
  42         <f>2.700000</f>
  43 </R>
  44 */
  45 template Nodes t_plain := {
  46   // node type             , depth, name   , value
  47   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
  48
  49   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
  50   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
  51   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
  52   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
  53   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
  54   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
  55   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
  56   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
  57   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
  58   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
  59   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
  60   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
  61   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
  62 }
  63 with {
  64   optional "implicit omit";
  65 }
  66
  67 testcase plain() runs on Neg
  68 {
  69   var Nodes nodes;
  70   var octetstring o;
  71   o := encR(c_plain);
  72   nodes := gather(o, ignore_ws);
  73   check_match(nodes, t_plain);
  74 }
  75
  76 /* * * * * * * * Charstring before the first member * * * * * * * */
  77
  78 // Inserting a charstring value results in an XML element with name <CHARSTRING>
  79 // This is not particularly useful.
  80 const R c_before_i := c_plain //{ i := 42, s := "fourty-two", b := true, f := 2.7 }
  81 with {
  82   erroneous (i) "before := ""string before i"" "
  83 }
  84
  85 template Nodes t_before_i := {
  86   // node type             , depth, name   , value
  87   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
  88
  89   // Perturbation: an extra element
  90   { XML_READER_TYPE_ELEMENT,     1, "CHARSTRING", "", "" },
  91   { XML_READER_TYPE_TEXT,        2, "#text", "string before i", "" },
  92   { XML_READER_TYPE_END_ELEMENT, 1, "CHARSTRING", "", "" },
  93
  94   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
  95   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
  96   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
  97   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
  98   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
  99   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 100   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 101   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 102   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 103   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 104   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 105   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 106   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 107 }
 108
 109 testcase before() runs on Neg
 110 {
 111   var Nodes nodes;
 112   var octetstring o;
 113   o := encR(c_plain);
 114   nodes := gather(o, ignore_ws);
 115   check_match(nodes, t_plain);
 116
 117   o := encR(c_before_i);
 118   //log("before_i", o);
 119   nodes := gather(o, ignore_ws);
 120   //log(nodes);
 121   check_match(nodes, t_before_i);
 122 }
 123
 124 // To insert an XML element with a given name (not "CHARSTRING"),
 125 // a type alias needs to be created.
 126 type charstring jumbo;
 127 type octetstring myos;
 128
 129 const R c_before_i_named :=  c_plain // { i := 42, s := "fourty-two", b := true, f := 2.7 }
 130 with {
 131   erroneous (i) "before := jumbo : ""747 before i"" "
 132 }
 133
 134 template Nodes t_before_i_named := {
 135   // node type             , depth, name   , value
 136   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 137
 138   // Perturbation: an extra element
 139   { XML_READER_TYPE_ELEMENT,     1, "jumbo", "", "" },
 140   { XML_READER_TYPE_TEXT,        2, "#text", "747 before i", "" },
 141   { XML_READER_TYPE_END_ELEMENT, 1, "jumbo", "", "" },
 142
 143   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 144   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 145   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 146   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 147   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 148   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 149   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 150   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 151   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 152   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 153   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 154   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 155   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 156 }
 157
 158 testcase before_named() runs on Neg
 159 {
 160   var Nodes nodes;
 161   var octetstring o;
 162
 163   o := encR(c_before_i_named);
 164   nodes := gather(o, ignore_ws);
 165   check_match(nodes, t_before_i_named);
 166 }
 167
 168 // Inserting some text (a text node), not an element
 169 const R c_before_i_raw :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 170 with {
 171   erroneous (i) "before(raw) := ""raw before i"" "
 172 }
 173
 174 template Nodes t_before_i_raw := {
 175   // node type             , depth, name   , value
 176   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 177
 178   // Perturbation: an extra text node (replaces a whitespace node)
 179   { XML_READER_TYPE_TEXT,        1, "#text", pattern "\s#(1,)raw before i\s#(1,)", "" },
 180
 181   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 182   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 183   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 184   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 185   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 186   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 187   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 188   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 189   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 190   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 191   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 192   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 193   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 194 }
 195
 196 testcase before_raw() runs on Neg
 197 {
 198   var Nodes nodes;
 199   var octetstring o;
 200
 201   o := encR(c_before_i_raw);
 202   nodes := gather(o, ignore_ws);
 203   check_match(nodes, t_before_i_raw);
 204 }
 205
 206 /* * * * * Replace * * * * */
 207
 208 const R c_replace_i :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 209 with {
 210   erroneous (i) "value := ""negyvenketto"" "
 211 }
 212
 213 template Nodes t_replace_i := {
 214   // node type             , depth, name   , value
 215   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 216   { XML_READER_TYPE_ELEMENT    , 1, "CHARSTRING", "", "" },             // replaced
 217   { XML_READER_TYPE_TEXT       , 2, "#text"     , "negyvenketto", "" }, // replaced
 218   { XML_READER_TYPE_END_ELEMENT, 1, "CHARSTRING", "", "" },             // replaced
 219   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 220   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 221   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 222   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 223   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 224   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 225   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 226   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 227   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 228   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 229 }
 230
 231 const R c_replace_i_named :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 232 with {
 233   erroneous (i) "value := jumbo : ""jet"" "
 234 }
 235
 236 template Nodes t_replace_i_named := {
 237   // node type             , depth, name   , value
 238   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 239   { XML_READER_TYPE_ELEMENT    , 1, "jumbo", "", "" },    // replaced
 240   { XML_READER_TYPE_TEXT       , 2, "#text", "jet", "" }, // replaced
 241   { XML_READER_TYPE_END_ELEMENT, 1, "jumbo", "", "" },    // replaced
 242   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 243   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 244   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 245   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 246   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 247   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 248   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 249   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 250   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 251   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 252 }
 253
 254 const R c_replace_i_raw :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 255 with {
 256   erroneous (i) "value(raw) := ""negyvenketto"" "
 257 }
 258
 259 // value(raw) replaces the element with the exact string
 260 template Nodes t_replace_i_raw := {
 261   // node type             , depth, name   , value
 262   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 263   { XML_READER_TYPE_TEXT       , 1, "#text", pattern "\s#(1,)negyvenketto\s#(1,)", "" }, // replaced
 264   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 265   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 266   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 267   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 268   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 269   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 270   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 271   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 272   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 273   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 274 }
 275
 276 // If you want an XML element, you have to write it in the replacement string
 277 const R c_replace_i_xml :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 278 with {
 279   erroneous (i) "value(raw) := ""<i>negyvenketto</i>"" "
 280 }
 281
 282 template Nodes t_replace_i_xml := {
 283   // node type             , depth, name   , value
 284   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 285   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 286   { XML_READER_TYPE_TEXT       , 2, "#text", "negyvenketto", "" }, // replaced
 287   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 288   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 289   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 290   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 291   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 292   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 293   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 294   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 295   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 296   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 297   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 298 }
 299
 300
 301 const R c_replace_i_os :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 302 with {
 303   erroneous (i) "value := '4242'O "
 304 }
 305
 306 template Nodes t_replace_i_os := {
 307   // node type             , depth, name   , value
 308   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 309   { XML_READER_TYPE_ELEMENT    , 1, "OCTET_STRING", "", "" },             // replaced
 310   { XML_READER_TYPE_TEXT       , 2, "#text"     , "4242", "" }, // replaced
 311   { XML_READER_TYPE_END_ELEMENT, 1, "OCTET_STRING", "", "" },             // replaced
 312   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 313   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 314   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 315   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 316   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 317   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 318   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 319   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 320   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 321   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 322 }
 323
 324 const R c_replace_i_myos :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 325 with {
 326   erroneous (i) "value := myos : '4242'O "
 327 }
 328
 329 template Nodes t_replace_i_myos := {
 330   // node type             , depth, name   , value
 331   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 332   { XML_READER_TYPE_ELEMENT    , 1, "myos",  "", "" },     // replaced
 333   { XML_READER_TYPE_TEXT       , 2, "#text", "4242", "" }, // replaced
 334   { XML_READER_TYPE_END_ELEMENT, 1, "myos",  "", "" },     // replaced
 335   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 336   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 337   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 338   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 339   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 340   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 341   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 342   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 343   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 344   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 345 }
 346
 347
 348 const R c_replace_i_os_raw :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 349 with {
 350   erroneous (i) "value(raw) := '3237'O " // '27' in ascii
 351 }
 352
 353 // value(raw) replaces the element with the exact string
 354 template Nodes t_replace_i_os_raw := {
 355   // node type             , depth, name   , value
 356   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 357   { XML_READER_TYPE_TEXT       , 1, "#text", pattern "\s#(1,)27\s#(1,)", "" }, // replaced
 358   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 359   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 360   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 361   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 362   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 363   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 364   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 365   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 366   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 367   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 368 }
 369
 370 testcase replacer() runs on Neg
 371 {
 372   var Nodes nodes;
 373   var octetstring o;
 374
 375   o := encR(c_replace_i);
 376   nodes := gather(o, ignore_ws);
 377   check_match(nodes, t_replace_i);
 378
 379   o := encR(c_replace_i_named);
 380   nodes := gather(o, ignore_ws);
 381   check_match(nodes, t_replace_i_named);
 382
 383   o := encR(c_replace_i_raw);
 384   nodes := gather(o, ignore_ws);
 385   check_match(nodes, t_replace_i_raw);
 386
 387   o := encR(c_replace_i_xml);
 388   nodes := gather(o, ignore_ws);
 389   check_match(nodes, t_replace_i_xml);
 390
 391   o := encR(c_replace_i_os);
 392   nodes := gather(o, ignore_ws);
 393   check_match(nodes, t_replace_i_os);
 394
 395   o := encR(c_replace_i_myos);
 396   nodes := gather(o, ignore_ws);
 397   check_match(nodes, t_replace_i_myos);
 398
 399   o := encR(c_replace_i_os_raw);
 400   nodes := gather(o, ignore_ws);
 401   check_match(nodes, t_replace_i_os_raw);
 402 }
 403
 404 /* * * * * After * * * * */
 405
 406 const R c_after_i :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 407 with {
 408   erroneous (i) "after := 'BABEFACE'O "
 409 }
 410
 411 template Nodes t_after_i := {
 412   // node type             , depth, name   , value
 413   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 414   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 415   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 416   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 417
 418   // Perturbation: an extra element
 419   { XML_READER_TYPE_ELEMENT,     1, "OCTET_STRING", "", "" },
 420   { XML_READER_TYPE_TEXT,        2, "#text", "BABEFACE", "" },
 421   { XML_READER_TYPE_END_ELEMENT, 1, "OCTET_STRING", "", "" },
 422
 423   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 424   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 425   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 426   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 427   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 428   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 429   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 430   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 431   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 432   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 433 }
 434
 435 const R c_after_i_named :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 436 with {
 437   erroneous (i) "after := myos : 'BABEFACE'O "
 438 }
 439
 440 template Nodes t_after_i_named := {
 441   // node type             , depth, name   , value
 442   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 443   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 444   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 445   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 446
 447   // Perturbation: an extra element
 448   { XML_READER_TYPE_ELEMENT,     1, "myos", "", "" },
 449   { XML_READER_TYPE_TEXT,        2, "#text", "BABEFACE", "" },
 450   { XML_READER_TYPE_END_ELEMENT, 1, "myos", "", "" },
 451
 452   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 453   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 454   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 455   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 456   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 457   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 458   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 459   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 460   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 461   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 462 }
 463
 464 const R c_after_i_raw :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 465 with {
 466   erroneous (i) "after(raw) := 'E29795 E280BF E280BF E29795'O " // must be valid UTF-8 bytes
 467 }
 468
 469 template Nodes t_after_i_raw := {
 470   // node type             , depth, name   , value
 471   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 472   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 473   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 474   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 475
 476   // Perturbation: text node replaces element
 477   { XML_READER_TYPE_TEXT,        1, "#text", "\n" & "\xE2\x97\x95" & "\xE2\x80\xBF" & "\xE2\x80\xBF" & "\xE2\x97\x95" & "\t", "" },
 478
 479   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 480   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 481   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 482   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 483   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 484   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 485   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 486   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 487   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 488   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 489 }
 490
 491 testcase after() runs on Neg
 492 {
 493   var Nodes nodes;
 494   var octetstring o;
 495
 496   o := encR(c_after_i);
 497   nodes := gather(o, ignore_ws);
 498   check_match(nodes, t_after_i);
 499
 500   o := encR(c_after_i_named);
 501   nodes := gather(o, ignore_ws);
 502   check_match(nodes, t_after_i_named);
 503
 504   o := encR(c_after_i_raw);
 505   nodes := gather(o, ignore_ws);
 506   check_match(nodes, t_after_i_raw);
 507 }
 508
 509 /* * * * * Omit * * * * */
 510
 511 const R c_omit_i :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 512 with {
 513   erroneous (i) "value := omit";
 514 }
 515
 516 /*
 517 <R>
 518                 <s>fourty-two</s>
 519                 <b>true</b>
 520                 <f>2.700000</f>
 521 </R>
 522 */
 523 template Nodes t_omit_i := {
 524   // node type             , depth, name   , value
 525   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 526   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 527   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 528   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 529   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 530   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 531   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 532   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 533   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 534   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 535   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 536   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 537   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 538   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 539 }
 540
 541 const R c_omit_s :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 542 with {
 543   erroneous (s) "value := omit";
 544 }
 545
 546 /*
 547 <R>
 548                 <i>42</i>
 549                 <b>true</b>
 550                 <f>2.700000</f>
 551 </R>
 552 */
 553 template Nodes t_omit_s := {
 554   // node type             , depth, name   , value
 555   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 556   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 557   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 558   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 559   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 560   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 561   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 562   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 563   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 564   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 565   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 566   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 567   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 568   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 569 }
 570
 571 const R c_omit_after_i :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 572 with {
 573   //sema error: erroneous (i) "before := omit all";
 574   erroneous (i) "after := omit all";
 575 }
 576
 577 /*
 578 <R>
 579                 <i>42</i>
 580 </R>
 581 */
 582 template Nodes t_omit_after_i := {
 583   // node type             , depth, name   , value
 584   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 585   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 586   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 587   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 588   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 589   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 590   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 591   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 592   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 593   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 594   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 595   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 596   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 597   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 598 }
 599
 600 const R c_omit_after_s :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 601 with {
 602   erroneous (s) "after := omit all";
 603 }
 604
 605 /*
 606 <R>
 607                 <i>42</i>
 608                 <s>fourty-two</s>
 609 </R>
 610 */
 611 template Nodes t_omit_after_s := {
 612   // node type             , depth, name   , value
 613   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 614   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 615   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 616   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 617   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 618   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 619   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 620   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 621   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 622   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 623   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 624   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 625   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 626   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 627 }
 628
 629 const R c_omit_after_b :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 630 with {
 631   erroneous (b) "after := omit all";
 632 }
 633
 634 /*
 635 <R>
 636                 <i>42</i>
 637                 <s>fourty-two</s>
 638                 <b>true</b>
 639 </R>
 640 */
 641 template Nodes t_omit_after_b := {
 642   // node type             , depth, name   , value
 643   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 644   { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 645   { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 646   { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 647   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 648   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 649   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 650   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 651   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 652   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 653   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 654   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 655   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 656   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 657 }
 658
 659 const R c_omit_before_f :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 660 with {
 661   erroneous (f) "before := omit all";
 662 }
 663
 664 /*
 665 <R>
 666                 <f>2.700000</f>
 667 </R>
 668 */
 669 template Nodes t_omit_before_f := {
 670   // node type             , depth, name   , value
 671   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 672   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 673   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 674   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 675   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 676   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 677   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 678   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 679   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 680   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 681   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 682   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 683   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 684   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 685 }
 686
 687 const R c_omit_before_b :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 688 with {
 689   erroneous (b) "before := omit all";
 690 }
 691
 692 /*
 693 <R>
 694                 <b>true</b>
 695                 <f>2.700000</f>
 696 </R>
 697 */
 698 template Nodes t_omit_before_b := {
 699   // node type             , depth, name   , value
 700   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 701   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 702   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 703   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 704   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 705   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 706   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 707   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 708   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 709   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 710   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 711   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 712   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 713   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 714 }
 715
 716 const R c_omit_before_s :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 717 with {
 718   erroneous (s) "before := omit all";
 719 }
 720
 721 /*
 722 <R>
 723                 <s>fourty-two</s>
 724                 <b>true</b>
 725                 <f>2.700000</f>
 726 </R>
 727 */
 728 template Nodes t_omit_before_s := {
 729   // node type             , depth, name   , value
 730   { XML_READER_TYPE_ELEMENT    , 0, "R"    , "", "" },
 731   //omitted: { XML_READER_TYPE_ELEMENT    , 1, "i"    , "", "" },
 732   //omitted: { XML_READER_TYPE_TEXT       , 2, "#text", "42", "" },
 733   //omitted: { XML_READER_TYPE_END_ELEMENT, 1, "i"    , "", "" },
 734   { XML_READER_TYPE_ELEMENT    , 1, "s"    , "", "" },
 735   { XML_READER_TYPE_TEXT       , 2, "#text", "fourty-two", "" },
 736   { XML_READER_TYPE_END_ELEMENT, 1, "s"    , "", "" },
 737   { XML_READER_TYPE_ELEMENT    , 1, "b"    , "", "" },
 738   { XML_READER_TYPE_TEXT       , 2, "#text", "true", "" },
 739   { XML_READER_TYPE_END_ELEMENT, 1, "b"    , "", "" },
 740   { XML_READER_TYPE_ELEMENT    , 1, "f"    , "", "" },
 741   { XML_READER_TYPE_TEXT       , 2, "#text", "2.700000", "" },
 742   { XML_READER_TYPE_END_ELEMENT, 1, "f"    , "", "" },
 743   { XML_READER_TYPE_END_ELEMENT, 0, "R"    , "", "" }
 744 }
 745
 746 testcase omitter() runs on Neg
 747 {
 748   var Nodes nodes;
 749   var octetstring o;
 750
 751   o := encR(c_omit_i);
 752   nodes := gather(o, ignore_ws);
 753   check_match(nodes, t_omit_i);
 754
 755   o := encR(c_omit_s);
 756   nodes := gather(o, ignore_ws);
 757   check_match(nodes, t_omit_s);
 758
 759   o := encR(c_omit_after_i);
 760   nodes := gather(o, ignore_ws);
 761   check_match(nodes, t_omit_after_i);
 762
 763   o := encR(c_omit_after_s);
 764   nodes := gather(o, ignore_ws);
 765   check_match(nodes, t_omit_after_s);
 766
 767   o := encR(c_omit_after_b);
 768   nodes := gather(o, ignore_ws);
 769   check_match(nodes, t_omit_after_b);
 770
 771
 772   o := encR(c_omit_before_f);
 773   nodes := gather(o, ignore_ws);
 774   check_match(nodes, t_omit_before_f);
 775
 776   o := encR(c_omit_before_b);
 777   nodes := gather(o, ignore_ws);
 778   check_match(nodes, t_omit_before_b);
 779
 780   o := encR(c_omit_before_s);
 781   nodes := gather(o, ignore_ws);
 782   check_match(nodes, t_omit_before_s);
 783 }
 784
 785 // !! !! DO NOT FORGET TO execute() IN THE CONTROL PART OF rec_of.ttcn !! !!
 786
 787 /* copy-paste from here
 788 const R | :=  { i := 42, s := "fourty-two", b := true, f := 2.7 }
 789 with {
 790   erroneous () ""
 791 }
 792 */
 793
 794 }
 795 with {
 796   encode "XML"
 797 }
 798