regression_test/XML/NegativeTest/rec_of.ttcn

   1 /******************************************************************************
   2  * Copyright (c) 2000-2014 Ericsson Telecom AB
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  ******************************************************************************/
   8 module rec_of
   9 {
  10
  11 import from ReadXml all;
  12
  13 import from rec { type R , Neg; function test_match; };
  14 // We import the component Neg and testcases to have a single control part.
  15 // This is all bogus because everything is imported.
  16
  17 type record of R RS;
  18
  19 external function encRS(in RS pars) return octetstring
  20 with { extension "prototype(convert) encode(XER:XER_EXTENDED)" }
  21
  22 /*---------------------------- OMIT ----------------------------*/
  23
  24 const RS c_omit := {
  25   { 1, "first" , true ,  7.0 },
  26   { 2, "second", false, -3.7 }
  27 }
  28 with {
  29   erroneous ([1]) "value := omit";
  30 }
  31
  32 template Nodes t_omit := { // the equivalent of an 1-element record-of
  33   // node type             , depth, name   , value
  34   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
  35
  36   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
  37   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
  38   { XML_READER_TYPE_TEXT       , 3, "#text", "1", "" },
  39   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
  40   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
  41   { XML_READER_TYPE_TEXT       , 3, "#text", "first", "" },
  42   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
  43   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
  44   { XML_READER_TYPE_TEXT       , 3, "#text", "true", "" },
  45   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
  46   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
  47   { XML_READER_TYPE_TEXT       , 3, "#text", "7.000000", "" },
  48   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
  49   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
  50
  51   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" } // [15]
  52 }
  53
  54 testcase rof_omit() runs on Neg
  55 {
  56   var octetstring o;
  57   var Nodes nodes;
  58
  59   o := encRS(c_omit);
  60   nodes := gather(o, ignore_ws);
  61   check_match(nodes, t_omit);
  62 }
  63
  64 /*---------------------------- PLAIN ----------------------------*/
  65
  66 // int, charstring, boolean, float
  67 const RS c_plain := {
  68   { 1, "first" , true ,  7.0 },
  69   { 2, "second", false, -3.7 }
  70 }
  71
  72 template Nodes t_plain modifies t_omit := {
  73   // node type             , depth, name   , value
  74 [15] := { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
  75 [16] := { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
  76 [17] := { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
  77 [18] := { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
  78 [19] := { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
  79 [20] := { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
  80 [21] := { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
  81 [22] := { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
  82 [23] := { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
  83 [24] := { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
  84 [25] := { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
  85 [26] := { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
  86 [27] := { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
  87 [28] := { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
  88
  89 [29] := { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" }
  90 }
  91
  92 testcase rof_plain() runs on Neg
  93 {
  94   var octetstring o;
  95   var Nodes nodes;
  96
  97   o := encRS(c_plain);
  98   nodes := gather(o, ignore_ws);
  99   check_match(nodes, t_plain);
 100 }
 101
 102 /*--------------------------- BEFORE -----------------------------*/
 103
 104 type integer myinteger;
 105
 106 // int, charstring, boolean, float
 107 const RS c_before_elem := {
 108   { 1, "first" , true ,  7.0 },
 109   { 2, "second", false, -3.7 }
 110 }
 111 with {
 112   erroneous ([0]) "before := 42"
 113 }
 114
 115 // int, charstring, boolean, float
 116 const RS c_before_elem_named := {
 117   { 1, "first" , true ,  7.0 },
 118   { 2, "second", false, -3.7 }
 119 }
 120 with {
 121   erroneous ([0]) "before := myinteger : 42"
 122 }
 123
 124 const RS c_before_member := {
 125   { 1, "first" , true ,  7.0 },
 126   { 2, "second", false, -3.7 }
 127 }
 128 with {
 129   erroneous ([0].i) "before := 42"
 130 }
 131
 132 const RS c_before_member_named := {
 133   { 1, "first" , true ,  7.0 },
 134   { 2, "second", false, -3.7 }
 135 }
 136 with {
 137   erroneous ([0].i) "before := myinteger : 42"
 138 }
 139
 140 template Nodes t_before_elem := {
 141   // node type             , depth, name   , value
 142   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
 143
 144   // Perturbation: an extra element
 145   { XML_READER_TYPE_ELEMENT,     1, "INTEGER", "", "" },
 146   { XML_READER_TYPE_TEXT,        2, "#text", "42", "" },
 147   { XML_READER_TYPE_END_ELEMENT, 1, "INTEGER", "", "" },
 148
 149   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 150   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 151   { XML_READER_TYPE_TEXT       , 3, "#text", "1", "" },
 152   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 153   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 154   { XML_READER_TYPE_TEXT       , 3, "#text", "first", "" },
 155   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 156   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 157   { XML_READER_TYPE_TEXT       , 3, "#text", "true", "" },
 158   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 159   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 160   { XML_READER_TYPE_TEXT       , 3, "#text", "7.000000", "" },
 161   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 162   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 163   // node type             , depth, name   , value
 164   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 165   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 166   { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
 167   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 168   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 169   { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
 170   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 171   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 172   { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
 173   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 174   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 175   { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
 176   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 177   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 178
 179   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" }
 180 }
 181
 182 template Nodes t_before_member modifies t_before_elem :=
 183 {
 184   // just move the <INTEGER> inside the <R> (need to adjust depths)
 185   [1] := { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" }, //t_before_elem[4],
 186   [2] := { XML_READER_TYPE_ELEMENT,     2, "INTEGER", "", "" }, //t_before_elem[1],
 187   [3] := { XML_READER_TYPE_TEXT,        3, "#text", "42", "" }, //t_before_elem[2],
 188   [4] := { XML_READER_TYPE_END_ELEMENT, 2, "INTEGER", "", "" } //,t_before_elem[3]
 189 }
 190
 191 template Nodes t_before_elem_named modifies t_before_elem := {
 192   // the perturbation
 193   [1] := { XML_READER_TYPE_ELEMENT,     1, "myinteger", "", "" },
 194   //[2] := { XML_READER_TYPE_TEXT,        2, "#text", "42", "" }, // unmodified
 195   [3] := { XML_READER_TYPE_END_ELEMENT, 1, "myinteger", "", "" }
 196 }
 197
 198 template Nodes t_before_member_named modifies t_before_member := {
 199   [2] := { XML_READER_TYPE_ELEMENT,     2, "myinteger", "", "" },
 200   [4] := { XML_READER_TYPE_END_ELEMENT, 2, "myinteger", "", "" }
 201 }
 202
 203 testcase rof_before() runs on Neg
 204 {
 205   var octetstring o;
 206   var Nodes nodes;
 207
 208   o := encRS(c_before_elem);
 209   nodes := gather(o, ignore_ws);
 210   check_match(nodes, t_before_elem);
 211
 212   o := encRS(c_before_member);
 213   nodes := gather(o, ignore_ws);
 214   check_match(nodes, t_before_member);
 215
 216   o := encRS(c_before_elem_named);
 217   nodes := gather(o, ignore_ws);
 218   check_match(nodes, t_before_elem_named);
 219
 220   o := encRS(c_before_member_named);
 221   nodes := gather(o, ignore_ws);
 222   check_match(nodes, t_before_member_named);
 223 }
 224
 225
 226 // int, charstring, boolean, float
 227 const RS c_before_elem_raw := {
 228   { 1, "first" , true ,  7.0 },
 229   { 2, "second", false, -3.7 }
 230 }
 231 with {
 232   erroneous ([0]) "before(raw) := ""rawr before first elem"" "
 233 }
 234
 235 const RS c_before_member_raw := {
 236   { 1, "first" , true ,  7.0 },
 237   { 2, "second", false, -3.7 }
 238 }
 239 with {
 240   erroneous ([0].i) "before(raw) := ""rawr before member of first"" "
 241 }
 242
 243 template Nodes t_before_elem_raw := {
 244   // node type             , depth, name   , value
 245   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
 246
 247   // Perturbation: an extra text node
 248   { XML_READER_TYPE_TEXT,        1, "#text", pattern "\s#(1,)rawr before first elem\s#(1,)", "" },
 249
 250   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 251   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 252   { XML_READER_TYPE_TEXT       , 3, "#text", "1", "" },
 253   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 254   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 255   { XML_READER_TYPE_TEXT       , 3, "#text", "first", "" },
 256   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 257   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 258   { XML_READER_TYPE_TEXT       , 3, "#text", "true", "" },
 259   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 260   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 261   { XML_READER_TYPE_TEXT       , 3, "#text", "7.000000", "" },
 262   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 263   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 264   // node type             , depth, name   , value
 265   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 266   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 267   { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
 268   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 269   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 270   { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
 271   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 272   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 273   { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
 274   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 275   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 276   { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
 277   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 278   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 279
 280   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" }
 281 }
 282
 283 // <RS> text <R> <i>  becomes  <RS> <R> text <i>
 284 template Nodes t_before_member_raw modifies t_before_elem_raw :=
 285 {
 286   // just move the #text inside the <R> (need to adjust depths)
 287   [1] := { XML_READER_TYPE_ELEMENT, 1, "R"    , "", "" }, //t_before_elem_raw[2],
 288   [2] := { XML_READER_TYPE_TEXT,    2, "#text", pattern "\s#(1,)rawr before member of first\s#(1,)", "" } //t_before_elem_raw[1],
 289 }
 290
 291 testcase rof_before_raw() runs on Neg
 292 {
 293   var octetstring o;
 294   var Nodes nodes;
 295
 296   o := encRS(c_before_elem_raw);
 297   nodes := gather(o, ignore_ws);
 298   check_match(nodes, t_before_elem_raw);
 299
 300   o := encRS(c_before_member_raw);
 301   nodes := gather(o, ignore_ws);
 302   check_match(nodes, t_before_member_raw);
 303 }
 304
 305
 306
 307 /*---------------------------- REPLACE ----------------------------*/
 308
 309 const RS c_replace_elem := {
 310   { 1, "first" , true ,  7.0 },
 311   { 2, "second", false, -3.7 }
 312 }
 313 with {
 314   erroneous ([0]) "value := 42"
 315 }
 316
 317 const RS c_replace_member := {
 318   { 1, "first" , true ,  7.0 },
 319   { 2, "second", false, -3.7 }
 320 }
 321 with {
 322   erroneous ([0].i) "value := 42"
 323 }
 324
 325 template Nodes t_replace_elem := {
 326   // node type             , depth, name   , value
 327   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
 328
 329   // first record element replaced with single <INTEGER>
 330   { XML_READER_TYPE_ELEMENT,     1, "INTEGER", "", "" },
 331   { XML_READER_TYPE_TEXT,        2, "#text", "42", "" },
 332   { XML_READER_TYPE_END_ELEMENT, 1, "INTEGER", "", "" },
 333
 334   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 335   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 336   { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
 337   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 338   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 339   { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
 340   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 341   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 342   { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
 343   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 344   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 345   { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
 346   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 347   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 348
 349   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" } // [15]
 350 }
 351
 352 template Nodes t_replace_member := {
 353   // node type             , depth, name   , value
 354   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
 355
 356   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 357
 358   { XML_READER_TYPE_ELEMENT,     2, "INTEGER", "", "" },
 359   { XML_READER_TYPE_TEXT,        3, "#text", "42", "" },
 360   { XML_READER_TYPE_END_ELEMENT, 2, "INTEGER", "", "" },
 361
 362   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 363   { XML_READER_TYPE_TEXT       , 3, "#text", "first", "" },
 364   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 365   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 366   { XML_READER_TYPE_TEXT       , 3, "#text", "true", "" },
 367   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 368   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 369   { XML_READER_TYPE_TEXT       , 3, "#text", "7.000000", "" },
 370   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 371   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 372
 373   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 374   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 375   { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
 376   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 377   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 378   { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
 379   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 380   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 381   { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
 382   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 383   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 384   { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
 385   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 386   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 387
 388   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" } // [15]
 389 }
 390
 391 type float real;
 392
 393 const RS c_replace_elem_named := {
 394   { 1, "first" , true ,  7.0 },
 395   { 2, "second", false, -3.7 }
 396 }
 397 with {
 398   erroneous ([0]) "value := real : 42.42"
 399 }
 400
 401 const RS c_replace_member_named := {
 402   { 1, "first" , true ,  7.0 },
 403   { 2, "second", false, -3.7 }
 404 }
 405 with {
 406   erroneous ([0].i) "value := real : 42.42"
 407 }
 408
 409 template Nodes t_replace_elem_named modifies t_replace_elem := {
 410   [1] := { XML_READER_TYPE_ELEMENT,     1, "real", "", "" },
 411   [2] := { XML_READER_TYPE_TEXT,        2, "#text", "42.420000", "" },
 412   [3] := { XML_READER_TYPE_END_ELEMENT, 1, "real", "", "" }
 413 }
 414
 415 template Nodes t_replace_member_named modifies t_replace_member := {
 416   [2] := { XML_READER_TYPE_ELEMENT,     2, "real", "", "" },
 417   [3] := { XML_READER_TYPE_TEXT,        3, "#text", "42.420000", "" },
 418   [4] := { XML_READER_TYPE_END_ELEMENT, 2, "real", "", "" }
 419 }
 420
 421
 422 const RS c_replace_elem_raw := {
 423   { 1, "first" , true ,  7.0 },
 424   { 2, "second", false, -3.7 }
 425 }
 426 with {
 427   erroneous ([0]) "value(raw) := char2oct(""Nothing to see here"")"
 428 }
 429
 430 const RS c_replace_member_raw := {
 431   { 1, "first" , true ,  7.0 },
 432   { 2, "second", false, -3.7 }
 433 }
 434 with {
 435   erroneous ([0].i) "value(raw) := 'e5909be98194e381aee59fbae59cb0e381afe38081e585a8e381a643415453e3818ce38184e3819fe381a0e38184e3819f'O "
 436 }
 437
 438 template Nodes t_replace_elem_raw := {
 439   // node type             , depth, name   , value
 440   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
 441
 442   // first record element replaced with single text node
 443   { XML_READER_TYPE_TEXT,        1, "#text", "\nNothing to see here\t", "" },
 444
 445   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 446   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 447   { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
 448   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 449   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 450   { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
 451   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 452   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 453   { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
 454   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 455   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 456   { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
 457   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 458   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 459
 460   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" } // [15]
 461 }
 462
 463 template Nodes t_replace_member_raw := {
 464   // node type             , depth, name   , value
 465   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
 466
 467   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 468
 469   { XML_READER_TYPE_TEXT,        2, "#text", "\n" & "\xe5\x90\x9b\xe9\x81\x94\xe3\x81\xae\xe5\x9f\xba\xe5\x9c\xb0\xe3\x81\xaf\xe3\x80\x81\xe5\x85\xa8\xe3\x81\xa6\x43\x41\x54\x53\xe3\x81\x8c\xe3\x81\x84\xe3\x81\x9f\xe3\x81\xa0\xe3\x81\x84\xe3\x81\x9f" & "\t\t", "" },
 470
 471   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 472   { XML_READER_TYPE_TEXT       , 3, "#text", "first", "" },
 473   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 474   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 475   { XML_READER_TYPE_TEXT       , 3, "#text", "true", "" },
 476   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 477   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 478   { XML_READER_TYPE_TEXT       , 3, "#text", "7.000000", "" },
 479   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 480   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 481
 482   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 483   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 484   { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
 485   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 486   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 487   { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
 488   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 489   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 490   { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
 491   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 492   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 493   { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
 494   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 495   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 496
 497   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" } // [15]
 498 }
 499
 500
 501 testcase rof_replacer() runs on Neg
 502 {
 503   var octetstring o;
 504   var Nodes nodes;
 505
 506   o := encRS(c_replace_elem);
 507   nodes := gather(o, ignore_ws);
 508   check_match(nodes, t_replace_elem);
 509
 510   o := encRS(c_replace_member);
 511   nodes := gather(o, ignore_ws);
 512   check_match(nodes, t_replace_member);
 513
 514   o := encRS(c_replace_elem_named);
 515   nodes := gather(o, ignore_ws);
 516   check_match(nodes, t_replace_elem_named);
 517
 518   o := encRS(c_replace_member_named);
 519   nodes := gather(o, ignore_ws);
 520   check_match(nodes, t_replace_member_named);
 521 }
 522
 523 testcase rof_replacer_raw() runs on Neg
 524 {
 525   var octetstring o;
 526   var Nodes nodes;
 527
 528   o := encRS(c_replace_elem_raw);
 529   nodes := gather(o, ignore_ws);
 530   check_match(nodes, t_replace_elem_raw);
 531
 532   o := encRS(c_replace_member_raw);
 533   nodes := gather(o, ignore_ws);
 534   check_match(nodes, t_replace_member_raw);
 535 }
 536
 537
 538 /*--------------------------- AFTER -----------------------------*/
 539
 540
 541 // int, charstring, boolean, float
 542 const RS c_after_elem := {
 543   { 1, "first" , true ,  7.0 },
 544   { 2, "second", false, -3.7 }
 545 }
 546 with {
 547   erroneous ([0]) "after := 42"
 548 }
 549
 550 const RS c_after_member := {
 551   { 1, "first" , true ,  7.0 },
 552   { 2, "second", false, -3.7 }
 553 }
 554 with {
 555   erroneous ([0].i) "after := 42"
 556 }
 557
 558 template Nodes t_after_elem := {
 559   // node type             , depth, name   , value
 560   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
 561
 562   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 563   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 564   { XML_READER_TYPE_TEXT       , 3, "#text", "1", "" },
 565   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 566   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 567   { XML_READER_TYPE_TEXT       , 3, "#text", "first", "" },
 568   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 569   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 570   { XML_READER_TYPE_TEXT       , 3, "#text", "true", "" },
 571   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },// 10
 572   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 573   { XML_READER_TYPE_TEXT       , 3, "#text", "7.000000", "" },
 574   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 575   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },//14
 576
 577   // Perturbation: an extra element
 578   { XML_READER_TYPE_ELEMENT,     1, "INTEGER", "", "" },
 579   { XML_READER_TYPE_TEXT,        2, "#text", "42", "" },
 580   { XML_READER_TYPE_END_ELEMENT, 1, "INTEGER", "", "" },
 581
 582   // node type             , depth, name   , value
 583   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 584   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 585   { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
 586   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 587   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 588   { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
 589   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 590   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 591   { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
 592   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 593   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 594   { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
 595   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 596   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 597
 598   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" }
 599 }
 600
 601 template Nodes t_after_member :=
 602 {
 603   // node type             , depth, name   , value
 604   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
 605
 606   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 607   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 608   { XML_READER_TYPE_TEXT       , 3, "#text", "1", "" },
 609   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" }, //4
 610
 611   // Perturbation: an extra element
 612   { XML_READER_TYPE_ELEMENT,     2, "INTEGER", "", "" },
 613   { XML_READER_TYPE_TEXT,        3, "#text", "42", "" },
 614   { XML_READER_TYPE_END_ELEMENT, 2, "INTEGER", "", "" },
 615
 616   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 617   { XML_READER_TYPE_TEXT       , 3, "#text", "first", "" },
 618   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 619   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 620   { XML_READER_TYPE_TEXT       , 3, "#text", "true", "" },
 621   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },// 10
 622   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 623   { XML_READER_TYPE_TEXT       , 3, "#text", "7.000000", "" },
 624   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 625   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },//14
 626
 627   // node type             , depth, name   , value
 628   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 629   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 630   { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
 631   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 632   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 633   { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
 634   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 635   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 636   { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
 637   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 638   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 639   { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
 640   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 641   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 642
 643   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" }
 644 }
 645
 646 type universal charstring ustr;
 647
 648 const RS c_after_elem_named := {
 649   { 1, "first" , true ,  7.0 },
 650   { 2, "second", false, -3.7 }
 651 }
 652 with {
 653   erroneous ([0]) "after := ustr : ""fourty-two"" "
 654 }
 655
 656 const RS c_after_member_named := {
 657   { 1, "first" , true ,  7.0 },
 658   { 2, "second", false, -3.7 }
 659 }
 660 with {
 661   erroneous ([0].i) "after := ustr : ""fourty-two"" "
 662 }
 663
 664 template Nodes t_after_elem_named modifies t_after_elem := {
 665   // Perturbation: an extra element
 666   [15] := { XML_READER_TYPE_ELEMENT,     1, "ustr", "", "" },
 667   [16] := { XML_READER_TYPE_TEXT,        2, "#text", "fourty-two", "" },
 668   [17] := { XML_READER_TYPE_END_ELEMENT, 1, "ustr", "", "" }
 669 }
 670
 671 template Nodes t_after_member_named modifies t_after_member := {
 672   // Perturbation: an extra element
 673   [5] := { XML_READER_TYPE_ELEMENT,     2, "ustr", "", "" },
 674   [6] := { XML_READER_TYPE_TEXT,        3, "#text", "fourty-two", "" },
 675   [7] := { XML_READER_TYPE_END_ELEMENT, 2, "ustr", "", "" }
 676 }
 677
 678 testcase rof_after() runs on Neg
 679 {
 680   var octetstring o;
 681   var Nodes nodes;
 682
 683   o := encRS(c_after_elem);
 684   nodes := gather(o, ignore_ws);
 685   check_match(nodes, t_after_elem);
 686
 687   o := encRS(c_after_member);
 688   nodes := gather(o, ignore_ws);
 689   check_match(nodes, t_after_member);
 690
 691   o := encRS(c_after_elem_named);
 692   nodes := gather(o, ignore_ws);
 693   check_match(nodes, t_after_elem_named);
 694
 695   o := encRS(c_after_member_named);
 696   nodes := gather(o, ignore_ws);
 697   check_match(nodes, t_after_member_named);
 698 }
 699
 700
 701 // int, charstring, boolean, float
 702 const RS c_after_elem_raw := {
 703   { 1, "first" , true ,  7.0 },
 704   { 2, "second", false, -3.7 }
 705 }
 706 with {
 707   erroneous ([0]) "after(raw) := ""rawr after first elem"" "
 708 }
 709
 710 const RS c_after_member_raw := {
 711   { 1, "first" , true ,  7.0 },
 712   { 2, "second", false, -3.7 }
 713 }
 714 with {
 715   erroneous ([0].i) "after(raw) := ustr : ""rawr after member of first"" "
 716 }
 717
 718 template Nodes t_after_elem_raw := {
 719   // node type             , depth, name   , value
 720   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
 721
 722   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 723   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 724   { XML_READER_TYPE_TEXT       , 3, "#text", "1", "" },
 725   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 726   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 727   { XML_READER_TYPE_TEXT       , 3, "#text", "first", "" },
 728   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 729   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 730   { XML_READER_TYPE_TEXT       , 3, "#text", "true", "" },
 731   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 732   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 733   { XML_READER_TYPE_TEXT       , 3, "#text", "7.000000", "" },
 734   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 735   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 736
 737   // Perturbation: an extra text node
 738   { XML_READER_TYPE_TEXT,        1, "#text", pattern "\s#(1,)rawr after first elem\s#(1,)", "" },
 739
 740   // node type             , depth, name   , value
 741   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 742   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 743   { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
 744   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 745   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 746   { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
 747   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 748   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 749   { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
 750   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 751   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 752   { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
 753   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 754   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 755
 756   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" }
 757 }
 758
 759 // <RS> text <R> <i>  becomes  <RS> <R> text <i>
 760 template Nodes t_after_member_raw modifies t_after_elem_raw :=
 761 {
 762   // node type             , depth, name   , value
 763   { XML_READER_TYPE_ELEMENT    , 0, "RS"   , "", "" },
 764
 765   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 766   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 767   { XML_READER_TYPE_TEXT       , 3, "#text", "1", "" },
 768   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 769
 770   // Perturbation: an extra text node
 771   { XML_READER_TYPE_TEXT,        2, "#text", pattern "\s#(1,)rawr after member of first\s#(1,)", "" },
 772
 773   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 774   { XML_READER_TYPE_TEXT       , 3, "#text", "first", "" },
 775   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 776   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 777   { XML_READER_TYPE_TEXT       , 3, "#text", "true", "" },
 778   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 779   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 780   { XML_READER_TYPE_TEXT       , 3, "#text", "7.000000", "" },
 781   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 782   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 783   // node type             , depth, name   , value
 784   { XML_READER_TYPE_ELEMENT    , 1, "R"    , "", "" },
 785   { XML_READER_TYPE_ELEMENT    , 2, "i"    , "", "" },
 786   { XML_READER_TYPE_TEXT       , 3, "#text", "2", "" },
 787   { XML_READER_TYPE_END_ELEMENT, 2, "i"    , "", "" },
 788   { XML_READER_TYPE_ELEMENT    , 2, "s"    , "", "" },
 789   { XML_READER_TYPE_TEXT       , 3, "#text", "second", "" },
 790   { XML_READER_TYPE_END_ELEMENT, 2, "s"    , "", "" },
 791   { XML_READER_TYPE_ELEMENT    , 2, "b"    , "", "" },
 792   { XML_READER_TYPE_TEXT       , 3, "#text", "false", "" },
 793   { XML_READER_TYPE_END_ELEMENT, 2, "b"    , "", "" },
 794   { XML_READER_TYPE_ELEMENT    , 2, "f"    , "", "" },
 795   { XML_READER_TYPE_TEXT       , 3, "#text", "-3.700000", "" },
 796   { XML_READER_TYPE_END_ELEMENT, 2, "f"    , "", "" },
 797   { XML_READER_TYPE_END_ELEMENT, 1, "R"    , "", "" },
 798
 799   { XML_READER_TYPE_END_ELEMENT, 0, "RS"   , "", "" }
 800 }
 801
 802 testcase rof_after_raw() runs on Neg
 803 {
 804   var octetstring o;
 805   var Nodes nodes;
 806
 807   o := encRS(c_after_elem_raw);
 808   nodes := gather(o, ignore_ws);
 809   check_match(nodes, t_after_elem_raw);
 810
 811   o := encRS(c_after_member_raw);
 812   nodes := gather(o, ignore_ws);
 813   check_match(nodes, t_after_member_raw);
 814 }
 815
 816
 817
 818
 819 }  // end of module
 820 with {
 821   encode "XML"
 822 }