tests/regex/regex.inc

   1 /*
   2  * Test data for wxRegEx (UTF-8 encoded)
   3  *
   4  * Generated Thu Jun 30 10:26:38 2005 by regex.pl from the following files:
   5  *
   6  *   reg.test: Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
   7  *   wxreg.test: Copyright (c) 2004 Mike Wetherell.
   8  *
   9  * Test types:
  10  *      e       compile error expected
  11  *      f       match failure expected
  12  *      m       successful match
  13  *      i       successful match with -indices (used in checking things like
  14  *              nonparticipating subexpressions)
  15  *      p       unsuccessful match with -indices (!!) (used in checking
  16  *              partial-match reporting)
  17  *
  18  * Flag characters:
  19  *      -       no-op (placeholder)
  20  *      +       provide fake xy equivalence class and ch collating element
  21  *      %       force small state-set cache in matcher (to test cache replace)
  22  *      ^       beginning of string is not beginning of line
  23  *      $       end of string is not end of line
  24  *      *       test is Unicode-specific, needs big character set
  25  *
  26  *      &       test as both ARE and BRE
  27  *      b       BRE
  28  *      e       ERE
  29  *      a       turn advanced-features bit on (error unless ERE already)
  30  *      q       literal string, no metacharacters at all
  31  *
  32  *      i       case-independent matching
  33  *      o       ("opaque") no subexpression capture
  34  *      p       newlines are half-magic, excluded from . and [^ only
  35  *      w       newlines are half-magic, significant to ^ and $ only
  36  *      n       newlines are fully magic, both effects
  37  *      x       expanded RE syntax
  38  *      t       incomplete-match reporting
  39  *
  40  *      A       backslash-_a_lphanumeric seen
  41  *      B       ERE/ARE literal-_b_race heuristic used
  42  *      E       backslash (_e_scape) seen within []
  43  *      H       looka_h_ead constraint seen
  44  *      I       _i_mpossible to match
  45  *      L       _l_ocale-specific construct seen
  46  *      M       unportable (_m_achine-specific) construct seen
  47  *      N       RE can match empty (_n_ull) string
  48  *      P       non-_P_OSIX construct seen
  49  *      Q       {} _q_uantifier seen
  50  *      R       back _r_eference seen
  51  *      S       POSIX-un_s_pecified syntax seen
  52  *      T       prefers shortest (_t_iny)
  53  *      U       saw original-POSIX botch:  unmatched right paren in ERE (_u_gh)
  54  */
  55
  56
  57 /*
  58  * 1 basic sanity checks
  59  */
  60
  61 class regextest_1 : public RegExTestSuite
  62 {
  63 public:
  64     regextest_1() : RegExTestSuite("regex.1") { }
  65     static Test *suite();
  66 };
  67
  68 Test *regextest_1::suite()
  69 {
  70     RegExTestSuite *suite = new regextest_1;
  71
  72     suite->add("m", "1", "&", "abc", "abc", "abc", NULL);
  73     suite->add("f", "2", "&", "abc", "def", NULL);
  74     suite->add("m", "3", "&", "abc", "xyabxabce", "abc", NULL);
  75
  76     return suite;
  77 }
  78
  79 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_1, "regex.1");
  80
  81
  82 /*
  83  * 2 invalid option combinations
  84  */
  85
  86 class regextest_2 : public RegExTestSuite
  87 {
  88 public:
  89     regextest_2() : RegExTestSuite("regex.2") { }
  90     static Test *suite();
  91 };
  92
  93 Test *regextest_2::suite()
  94 {
  95     RegExTestSuite *suite = new regextest_2;
  96
  97     suite->add("e", "1", "qe", "a", "INVARG", NULL);
  98     suite->add("e", "2", "qa", "a", "INVARG", NULL);
  99     suite->add("e", "3", "qx", "a", "INVARG", NULL);
 100     suite->add("e", "4", "qn", "a", "INVARG", NULL);
 101     suite->add("e", "5", "ba", "a", "INVARG", NULL);
 102
 103     return suite;
 104 }
 105
 106 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_2, "regex.2");
 107
 108
 109 /*
 110  * 3 basic syntax
 111  */
 112
 113 class regextest_3 : public RegExTestSuite
 114 {
 115 public:
 116     regextest_3() : RegExTestSuite("regex.3") { }
 117     static Test *suite();
 118 };
 119
 120 Test *regextest_3::suite()
 121 {
 122     RegExTestSuite *suite = new regextest_3;
 123
 124     suite->add("i", "1", "&NS", "", "a", "0 -1", NULL);
 125     suite->add("m", "2", "NS", "a|", "a", "a", NULL);
 126     suite->add("m", "3", "-", "a|b", "a", "a", NULL);
 127     suite->add("m", "4", "-", "a|b", "b", "b", NULL);
 128     suite->add("m", "5", "NS", "a||b", "b", "b", NULL);
 129     suite->add("m", "6", "&", "ab", "ab", "ab", NULL);
 130
 131     return suite;
 132 }
 133
 134 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_3, "regex.3");
 135
 136
 137 /*
 138  * 4 parentheses
 139  */
 140
 141 class regextest_4 : public RegExTestSuite
 142 {
 143 public:
 144     regextest_4() : RegExTestSuite("regex.4") { }
 145     static Test *suite();
 146 };
 147
 148 Test *regextest_4::suite()
 149 {
 150     RegExTestSuite *suite = new regextest_4;
 151
 152     suite->add("m", "1", "-", "(a)e", "ae", "ae", "a", NULL);
 153     suite->add("m", "2", "o", "(a)e", "ae", NULL);
 154     suite->add("m", "3", "b", "\\(a\\)b", "ab", "ab", "a", NULL);
 155     suite->add("m", "4", "-", "a((b)c)", "abc", "abc", "bc", "b", NULL);
 156     suite->add("m", "5", "-", "a(b)(c)", "abc", "abc", "b", "c", NULL);
 157     suite->add("e", "6", "-", "a(b", "EPAREN", NULL);
 158     suite->add("e", "7", "b", "a\\(b", "EPAREN", NULL);
 159     suite->add("m", "8", "eU", "a)b", "a)b", "a)b", NULL);
 160     suite->add("e", "9", "-", "a)b", "EPAREN", NULL);
 161     suite->add("e", "10", "b", "a\\)b", "EPAREN", NULL);
 162     suite->add("m", "11", "P", "a(?:b)c", "abc", "abc", NULL);
 163     suite->add("e", "12", "e", "a(?:b)c", "BADRPT", NULL);
 164     suite->add("i", "13", "S", "a()b", "ab", "0 1", "1 0", NULL);
 165     suite->add("m", "14", "SP", "a(?:)b", "ab", "ab", NULL);
 166     suite->add("i", "15", "S", "a(|b)c", "ac", "0 1", "1 0", NULL);
 167     suite->add("m", "16", "S", "a(b|)c", "abc", "abc", "b", NULL);
 168
 169     return suite;
 170 }
 171
 172 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_4, "regex.4");
 173
 174
 175 /*
 176  * 5 simple one-char matching
 177  */
 178
 179 class regextest_5 : public RegExTestSuite
 180 {
 181 public:
 182     regextest_5() : RegExTestSuite("regex.5") { }
 183     static Test *suite();
 184 };
 185
 186 Test *regextest_5::suite()
 187 {
 188     RegExTestSuite *suite = new regextest_5;
 189
 190     suite->add("m", "1", "&", "a.b", "axb", "axb", NULL);
 191     suite->add("f", "2", "&n", "a.b", "a\nb", NULL);
 192     suite->add("m", "3", "&", "a[bc]d", "abd", "abd", NULL);
 193     suite->add("m", "4", "&", "a[bc]d", "acd", "acd", NULL);
 194     suite->add("f", "5", "&", "a[bc]d", "aed", NULL);
 195     suite->add("f", "6", "&", "a[^bc]d", "abd", NULL);
 196     suite->add("m", "7", "&", "a[^bc]d", "aed", "aed", NULL);
 197     suite->add("f", "8", "&p", "a[^bc]d", "a\nd", NULL);
 198
 199     return suite;
 200 }
 201
 202 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_5, "regex.5");
 203
 204
 205 /*
 206  * 6 context-dependent syntax
 207  */
 208
 209 class regextest_6 : public RegExTestSuite
 210 {
 211 public:
 212     regextest_6() : RegExTestSuite("regex.6") { }
 213     static Test *suite();
 214 };
 215
 216 Test *regextest_6::suite()
 217 {
 218     RegExTestSuite *suite = new regextest_6;
 219
 220     suite->add("e", "1", "-", "*", "BADRPT", NULL);
 221     suite->add("m", "2", "b", "*", "*", "*", NULL);
 222     suite->add("m", "3", "b", "\\(*\\)", "*", "*", "*", NULL);
 223     suite->add("e", "4", "-", "(*)", "BADRPT", NULL);
 224     suite->add("m", "5", "b", "^*", "*", "*", NULL);
 225     suite->add("e", "6", "-", "^*", "BADRPT", NULL);
 226     suite->add("f", "7", "&", "^b", "^b", NULL);
 227     suite->add("m", "8", "b", "x^", "x^", "x^", NULL);
 228     suite->add("f", "9", "I", "x^", "x", NULL);
 229     suite->add("m", "10", "n", "\n^", "x\nb", "\n", NULL);
 230     suite->add("f", "11", "bS", "\\(^b\\)", "^b", NULL);
 231     suite->add("m", "12", "-", "(^b)", "b", "b", "b", NULL);
 232     suite->add("m", "13", "&", "x$", "x", "x", NULL);
 233     suite->add("m", "14", "bS", "\\(x$\\)", "x", "x", "x", NULL);
 234     suite->add("m", "15", "-", "(x$)", "x", "x", "x", NULL);
 235     suite->add("m", "16", "b", "x$y", "x$y", "x$y", NULL);
 236     suite->add("f", "17", "I", "x$y", "xy", NULL);
 237     suite->add("m", "18", "n", "x$\n", "x\n", "x\n", NULL);
 238     suite->add("e", "19", "-", "+", "BADRPT", NULL);
 239     suite->add("e", "20", "-", "?", "BADRPT", NULL);
 240
 241     return suite;
 242 }
 243
 244 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_6, "regex.6");
 245
 246
 247 /*
 248  * 7 simple quantifiers
 249  */
 250
 251 class regextest_7 : public RegExTestSuite
 252 {
 253 public:
 254     regextest_7() : RegExTestSuite("regex.7") { }
 255     static Test *suite();
 256 };
 257
 258 Test *regextest_7::suite()
 259 {
 260     RegExTestSuite *suite = new regextest_7;
 261
 262     suite->add("m", "1", "&N", "a*", "aa", "aa", NULL);
 263     suite->add("i", "2", "&N", "a*", "b", "0 -1", NULL);
 264     suite->add("m", "3", "-", "a+", "aa", "aa", NULL);
 265     suite->add("m", "4", "-", "a?b", "ab", "ab", NULL);
 266     suite->add("m", "5", "-", "a?b", "b", "b", NULL);
 267     suite->add("e", "6", "-", "**", "BADRPT", NULL);
 268     suite->add("m", "7", "bN", "**", "***", "***", NULL);
 269     suite->add("e", "8", "&", "a**", "BADRPT", NULL);
 270     suite->add("e", "9", "&", "a**b", "BADRPT", NULL);
 271     suite->add("e", "10", "&", "***", "BADRPT", NULL);
 272     suite->add("e", "11", "-", "a++", "BADRPT", NULL);
 273     suite->add("e", "12", "-", "a?+", "BADRPT", NULL);
 274     suite->add("e", "13", "-", "a?*", "BADRPT", NULL);
 275     suite->add("e", "14", "-", "a+*", "BADRPT", NULL);
 276     suite->add("e", "15", "-", "a*+", "BADRPT", NULL);
 277
 278     return suite;
 279 }
 280
 281 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_7, "regex.7");
 282
 283
 284 /*
 285  * 8 braces
 286  */
 287
 288 class regextest_8 : public RegExTestSuite
 289 {
 290 public:
 291     regextest_8() : RegExTestSuite("regex.8") { }
 292     static Test *suite();
 293 };
 294
 295 Test *regextest_8::suite()
 296 {
 297     RegExTestSuite *suite = new regextest_8;
 298
 299     suite->add("m", "1", "NQ", "a{0,1}", "", "", NULL);
 300     suite->add("m", "2", "NQ", "a{0,1}", "ac", "a", NULL);
 301     suite->add("e", "3", "-", "a{1,0}", "BADBR", NULL);
 302     suite->add("e", "4", "-", "a{1,2,3}", "BADBR", NULL);
 303     suite->add("e", "5", "-", "a{257}", "BADBR", NULL);
 304     suite->add("e", "6", "-", "a{1000}", "BADBR", NULL);
 305     suite->add("e", "7", "-", "a{1", "EBRACE", NULL);
 306     suite->add("e", "8", "-", "a{1n}", "BADBR", NULL);
 307     suite->add("m", "9", "BS", "a{b", "a{b", "a{b", NULL);
 308     suite->add("m", "10", "BS", "a{", "a{", "a{", NULL);
 309     suite->add("m", "11", "bQ", "a\\{0,1\\}b", "cb", "b", NULL);
 310     suite->add("e", "12", "b", "a\\{0,1", "EBRACE", NULL);
 311     suite->add("e", "13", "-", "a{0,1\\", "BADBR", NULL);
 312     suite->add("m", "14", "Q", "a{0}b", "ab", "b", NULL);
 313     suite->add("m", "15", "Q", "a{0,0}b", "ab", "b", NULL);
 314     suite->add("m", "16", "Q", "a{0,1}b", "ab", "ab", NULL);
 315     suite->add("m", "17", "Q", "a{0,2}b", "b", "b", NULL);
 316     suite->add("m", "18", "Q", "a{0,2}b", "aab", "aab", NULL);
 317     suite->add("m", "19", "Q", "a{0,}b", "aab", "aab", NULL);
 318     suite->add("m", "20", "Q", "a{1,1}b", "aab", "ab", NULL);
 319     suite->add("m", "21", "Q", "a{1,3}b", "aaaab", "aaab", NULL);
 320     suite->add("f", "22", "Q", "a{1,3}b", "b", NULL);
 321     suite->add("m", "23", "Q", "a{1,}b", "aab", "aab", NULL);
 322     suite->add("f", "24", "Q", "a{2,3}b", "ab", NULL);
 323     suite->add("m", "25", "Q", "a{2,3}b", "aaaab", "aaab", NULL);
 324     suite->add("f", "26", "Q", "a{2,}b", "ab", NULL);
 325     suite->add("m", "27", "Q", "a{2,}b", "aaaab", "aaaab", NULL);
 326
 327     return suite;
 328 }
 329
 330 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_8, "regex.8");
 331
 332
 333 /*
 334  * 9 brackets
 335  */
 336
 337 class regextest_9 : public RegExTestSuite
 338 {
 339 public:
 340     regextest_9() : RegExTestSuite("regex.9") { }
 341     static Test *suite();
 342 };
 343
 344 Test *regextest_9::suite()
 345 {
 346     RegExTestSuite *suite = new regextest_9;
 347
 348     suite->add("m", "1", "&", "a[bc]", "ac", "ac", NULL);
 349     suite->add("m", "2", "&", "a[-]", "a-", "a-", NULL);
 350     suite->add("m", "3", "&", "a[[.-.]]", "a-", "a-", NULL);
 351     suite->add("m", "4", "&L", "a[[.zero.]]", "a0", "a0", NULL);
 352     suite->add("m", "5", "&LM", "a[[.zero.]-9]", "a2", "a2", NULL);
 353     suite->add("m", "6", "&M", "a[0-[.9.]]", "a2", "a2", NULL);
 354     suite->add("m", "7", "&+L", "a[[=x=]]", "ax", "ax", NULL);
 355     suite->add("m", "8", "&+L", "a[[=x=]]", "ay", "ay", NULL);
 356     suite->add("f", "9", "&+L", "a[[=x=]]", "az", NULL);
 357     suite->add("e", "10", "&", "a[0-[=x=]]", "ERANGE", NULL);
 358     suite->add("m", "11", "&L", "a[[:digit:]]", "a0", "a0", NULL);
 359     suite->add("e", "12", "&", "a[[:woopsie:]]", "ECTYPE", NULL);
 360     suite->add("f", "13", "&L", "a[[:digit:]]", "ab", NULL);
 361     suite->add("e", "14", "&", "a[0-[:digit:]]", "ERANGE", NULL);
 362     suite->add("m", "15", "&LP", "[[:<:]]a", "a", "a", NULL);
 363     suite->add("m", "16", "&LP", "a[[:>:]]", "a", "a", NULL);
 364     suite->add("e", "17", "&", "a[[..]]b", "ECOLLATE", NULL);
 365     suite->add("e", "18", "&", "a[[==]]b", "ECOLLATE", NULL);
 366     suite->add("e", "19", "&", "a[[::]]b", "ECTYPE", NULL);
 367     suite->add("e", "20", "&", "a[[.a", "EBRACK", NULL);
 368     suite->add("e", "21", "&", "a[[=a", "EBRACK", NULL);
 369     suite->add("e", "22", "&", "a[[:a", "EBRACK", NULL);
 370     suite->add("e", "23", "&", "a[", "EBRACK", NULL);
 371     suite->add("e", "24", "&", "a[b", "EBRACK", NULL);
 372     suite->add("e", "25", "&", "a[b-", "EBRACK", NULL);
 373     suite->add("e", "26", "&", "a[b-c", "EBRACK", NULL);
 374     suite->add("m", "27", "&M", "a[b-c]", "ab", "ab", NULL);
 375     suite->add("m", "28", "&", "a[b-b]", "ab", "ab", NULL);
 376     suite->add("m", "29", "&M", "a[1-2]", "a2", "a2", NULL);
 377     suite->add("e", "30", "&", "a[c-b]", "ERANGE", NULL);
 378     suite->add("e", "31", "&", "a[a-b-c]", "ERANGE", NULL);
 379     suite->add("m", "32", "&M", "a[--?]b", "a?b", "a?b", NULL);
 380     suite->add("m", "33", "&", "a[---]b", "a-b", "a-b", NULL);
 381     suite->add("m", "34", "&", "a[]b]c", "a]c", "a]c", NULL);
 382     suite->add("m", "35", "EP", "a[\\]]b", "a]b", "a]b", NULL);
 383     suite->add("f", "36", "bE", "a[\\]]b", "a]b", NULL);
 384     suite->add("m", "37", "bE", "a[\\]]b", "a\\]b", "a\\]b", NULL);
 385     suite->add("m", "38", "eE", "a[\\]]b", "a\\]b", "a\\]b", NULL);
 386     suite->add("m", "39", "EP", "a[\\\\]b", "a\\b", "a\\b", NULL);
 387     suite->add("m", "40", "eE", "a[\\\\]b", "a\\b", "a\\b", NULL);
 388     suite->add("m", "41", "bE", "a[\\\\]b", "a\\b", "a\\b", NULL);
 389     suite->add("e", "42", "-", "a[\\Z]b", "EESCAPE", NULL);
 390     suite->add("m", "43", "&", "a[[b]c", "a[c", "a[c", NULL);
 391     suite->add("m", "44", "EMP*", "a[\\u00fe-\\u0507][\\u00ff-\\u0300]b", "a\304\202\313\277b", "a\304\202\313\277b", NULL);
 392
 393     return suite;
 394 }
 395
 396 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_9, "regex.9");
 397
 398
 399 /*
 400  * 10 anchors and newlines
 401  */
 402
 403 class regextest_10 : public RegExTestSuite
 404 {
 405 public:
 406     regextest_10() : RegExTestSuite("regex.10") { }
 407     static Test *suite();
 408 };
 409
 410 Test *regextest_10::suite()
 411 {
 412     RegExTestSuite *suite = new regextest_10;
 413
 414     suite->add("m", "1", "&", "^a", "a", "a", NULL);
 415     suite->add("f", "2", "&^", "^a", "a", NULL);
 416     suite->add("i", "3", "&N", "^", "a", "0 -1", NULL);
 417     suite->add("i", "4", "&", "a$", "aba", "2 2", NULL);
 418     suite->add("f", "5", "&$", "a$", "a", NULL);
 419     suite->add("i", "6", "&N", "$", "ab", "2 1", NULL);
 420     suite->add("m", "7", "&n", "^a", "a", "a", NULL);
 421     suite->add("m", "8", "&n", "^a", "b\na", "a", NULL);
 422     suite->add("i", "9", "&w", "^a", "a\na", "0 0", NULL);
 423     suite->add("i", "10", "&n^", "^a", "a\na", "2 2", NULL);
 424     suite->add("m", "11", "&n", "a$", "a", "a", NULL);
 425     suite->add("m", "12", "&n", "a$", "a\nb", "a", NULL);
 426     suite->add("i", "13", "&n", "a$", "a\na", "0 0", NULL);
 427     suite->add("i", "14", "N", "^^", "a", "0 -1", NULL);
 428     suite->add("m", "15", "b", "^^", "^", "^", NULL);
 429     suite->add("i", "16", "N", "$$", "a", "1 0", NULL);
 430     suite->add("m", "17", "b", "$$", "$", "$", NULL);
 431     suite->add("m", "18", "&N", "^$", "", "", NULL);
 432     suite->add("f", "19", "&N", "^$", "a", NULL);
 433     suite->add("i", "20", "&nN", "^$", "a\n\nb", "2 1", NULL);
 434     suite->add("m", "21", "N", "$^", "", "", NULL);
 435     suite->add("m", "22", "b", "$^", "$^", "$^", NULL);
 436     suite->add("m", "23", "P", "\\Aa", "a", "a", NULL);
 437     suite->add("m", "24", "^P", "\\Aa", "a", "a", NULL);
 438     suite->add("f", "25", "^nP", "\\Aa", "b\na", NULL);
 439     suite->add("m", "26", "P", "a\\Z", "a", "a", NULL);
 440     suite->add("m", "27", "$P", "a\\Z", "a", "a", NULL);
 441     suite->add("f", "28", "$nP", "a\\Z", "a\nb", NULL);
 442     suite->add("e", "29", "-", "^*", "BADRPT", NULL);
 443     suite->add("e", "30", "-", "$*", "BADRPT", NULL);
 444     suite->add("e", "31", "-", "\\A*", "BADRPT", NULL);
 445     suite->add("e", "32", "-", "\\Z*", "BADRPT", NULL);
 446
 447     return suite;
 448 }
 449
 450 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_10, "regex.10");
 451
 452
 453 /*
 454  * 11 boundary constraints
 455  */
 456
 457 class regextest_11 : public RegExTestSuite
 458 {
 459 public:
 460     regextest_11() : RegExTestSuite("regex.11") { }
 461     static Test *suite();
 462 };
 463
 464 Test *regextest_11::suite()
 465 {
 466     RegExTestSuite *suite = new regextest_11;
 467
 468     suite->add("m", "1", "&LP", "[[:<:]]a", "a", "a", NULL);
 469     suite->add("m", "2", "&LP", "[[:<:]]a", "-a", "a", NULL);
 470     suite->add("f", "3", "&LP", "[[:<:]]a", "ba", NULL);
 471     suite->add("m", "4", "&LP", "a[[:>:]]", "a", "a", NULL);
 472     suite->add("m", "5", "&LP", "a[[:>:]]", "a-", "a", NULL);
 473     suite->add("f", "6", "&LP", "a[[:>:]]", "ab", NULL);
 474     suite->add("m", "7", "bLP", "\\<a", "a", "a", NULL);
 475     suite->add("f", "8", "bLP", "\\<a", "ba", NULL);
 476     suite->add("m", "9", "bLP", "a\\>", "a", "a", NULL);
 477     suite->add("f", "10", "bLP", "a\\>", "ab", NULL);
 478     suite->add("m", "11", "LP", "\\ya", "a", "a", NULL);
 479     suite->add("f", "12", "LP", "\\ya", "ba", NULL);
 480     suite->add("m", "13", "LP", "a\\y", "a", "a", NULL);
 481     suite->add("f", "14", "LP", "a\\y", "ab", NULL);
 482     suite->add("m", "15", "LP", "a\\Y", "ab", "a", NULL);
 483     suite->add("f", "16", "LP", "a\\Y", "a-", NULL);
 484     suite->add("f", "17", "LP", "a\\Y", "a", NULL);
 485     suite->add("f", "18", "LP", "-\\Y", "-a", NULL);
 486     suite->add("m", "19", "LP", "-\\Y", "-%", "-", NULL);
 487     suite->add("f", "20", "LP", "\\Y-", "a-", NULL);
 488     suite->add("e", "21", "-", "[[:<:]]*", "BADRPT", NULL);
 489     suite->add("e", "22", "-", "[[:>:]]*", "BADRPT", NULL);
 490     suite->add("e", "23", "b", "\\<*", "BADRPT", NULL);
 491     suite->add("e", "24", "b", "\\>*", "BADRPT", NULL);
 492     suite->add("e", "25", "-", "\\y*", "BADRPT", NULL);
 493     suite->add("e", "26", "-", "\\Y*", "BADRPT", NULL);
 494     suite->add("m", "27", "LP", "\\ma", "a", "a", NULL);
 495     suite->add("f", "28", "LP", "\\ma", "ba", NULL);
 496     suite->add("m", "29", "LP", "a\\M", "a", "a", NULL);
 497     suite->add("f", "30", "LP", "a\\M", "ab", NULL);
 498     suite->add("f", "31", "ILP", "\\Ma", "a", NULL);
 499     suite->add("f", "32", "ILP", "a\\m", "a", NULL);
 500
 501     return suite;
 502 }
 503
 504 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_11, "regex.11");
 505
 506
 507 /*
 508  * 12 character classes
 509  */
 510
 511 class regextest_12 : public RegExTestSuite
 512 {
 513 public:
 514     regextest_12() : RegExTestSuite("regex.12") { }
 515     static Test *suite();
 516 };
 517
 518 Test *regextest_12::suite()
 519 {
 520     RegExTestSuite *suite = new regextest_12;
 521
 522     suite->add("m", "1", "LP", "a\\db", "a0b", "a0b", NULL);
 523     suite->add("f", "2", "LP", "a\\db", "axb", NULL);
 524     suite->add("f", "3", "LP", "a\\Db", "a0b", NULL);
 525     suite->add("m", "4", "LP", "a\\Db", "axb", "axb", NULL);
 526     suite->add("m", "5", "LP", "a\\sb", "a b", "a b", NULL);
 527     suite->add("m", "6", "LP", "a\\sb", "a\tb", "a\tb", NULL);
 528     suite->add("m", "7", "LP", "a\\sb", "a\nb", "a\nb", NULL);
 529     suite->add("f", "8", "LP", "a\\sb", "axb", NULL);
 530     suite->add("m", "9", "LP", "a\\Sb", "axb", "axb", NULL);
 531     suite->add("f", "10", "LP", "a\\Sb", "a b", NULL);
 532     suite->add("m", "11", "LP", "a\\wb", "axb", "axb", NULL);
 533     suite->add("f", "12", "LP", "a\\wb", "a-b", NULL);
 534     suite->add("f", "13", "LP", "a\\Wb", "axb", NULL);
 535     suite->add("m", "14", "LP", "a\\Wb", "a-b", "a-b", NULL);
 536     suite->add("m", "15", "LP", "\\y\\w+z\\y", "adze-guz", "guz", NULL);
 537     suite->add("m", "16", "LPE", "a[\\d]b", "a1b", "a1b", NULL);
 538     suite->add("m", "17", "LPE", "a[\\s]b", "a b", "a b", NULL);
 539     suite->add("m", "18", "LPE", "a[\\w]b", "axb", "axb", NULL);
 540
 541     return suite;
 542 }
 543
 544 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_12, "regex.12");
 545
 546
 547 /*
 548  * 13 escapes
 549  */
 550
 551 class regextest_13 : public RegExTestSuite
 552 {
 553 public:
 554     regextest_13() : RegExTestSuite("regex.13") { }
 555     static Test *suite();
 556 };
 557
 558 Test *regextest_13::suite()
 559 {
 560     RegExTestSuite *suite = new regextest_13;
 561
 562     suite->add("e", "1", "&", "a\\", "EESCAPE", NULL);
 563     suite->add("m", "2", "-", "a\\<b", "a<b", "a<b", NULL);
 564     suite->add("m", "3", "e", "a\\<b", "a<b", "a<b", NULL);
 565     suite->add("m", "4", "bAS", "a\\wb", "awb", "awb", NULL);
 566     suite->add("m", "5", "eAS", "a\\wb", "awb", "awb", NULL);
 567     suite->add("m", "6", "PL", "a\\ab", "a\ab", "a\ab", NULL);
 568     suite->add("m", "7", "P", "a\\bb", "a\bb", "a\bb", NULL);
 569     suite->add("m", "8", "P", "a\\Bb", "a\\b", "a\\b", NULL);
 570     suite->add("m", "9", "MP", "a\\chb", "a\bb", "a\bb", NULL);
 571     suite->add("m", "10", "MP", "a\\cHb", "a\bb", "a\bb", NULL);
 572     suite->add("m", "11", "LMP", "a\\e", "a\033", "a\033", NULL);
 573     suite->add("m", "12", "P", "a\\fb", "a\fb", "a\fb", NULL);
 574     suite->add("m", "13", "P", "a\\nb", "a\nb", "a\nb", NULL);
 575     suite->add("m", "14", "P", "a\\rb", "a\rb", "a\rb", NULL);
 576     suite->add("m", "15", "P", "a\\tb", "a\tb", "a\tb", NULL);
 577     suite->add("m", "16", "P", "a\\u0008x", "a\bx", "a\bx", NULL);
 578     suite->add("e", "17", "-", "a\\u008x", "EESCAPE", NULL);
 579     suite->add("m", "18", "P", "a\\u00088x", "a\b8x", "a\b8x", NULL);
 580     suite->add("m", "19", "P", "a\\U00000008x", "a\bx", "a\bx", NULL);
 581     suite->add("e", "20", "-", "a\\U0000008x", "EESCAPE", NULL);
 582     suite->add("m", "21", "P", "a\\vb", "a\vb", "a\vb", NULL);
 583     suite->add("m", "22", "MP", "a\\x08x", "a\bx", "a\bx", NULL);
 584     suite->add("e", "23", "-", "a\\xq", "EESCAPE", NULL);
 585     suite->add("m", "24", "MP", "a\\x0008x", "a\bx", "a\bx", NULL);
 586     suite->add("e", "25", "-", "a\\z", "EESCAPE", NULL);
 587     suite->add("m", "26", "MP", "a\\010b", "a\bb", "a\bb", NULL);
 588
 589     return suite;
 590 }
 591
 592 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_13, "regex.13");
 593
 594
 595 /*
 596  * 14 back references
 597  */
 598
 599 class regextest_14 : public RegExTestSuite
 600 {
 601 public:
 602     regextest_14() : RegExTestSuite("regex.14") { }
 603     static Test *suite();
 604 };
 605
 606 Test *regextest_14::suite()
 607 {
 608     RegExTestSuite *suite = new regextest_14;
 609
 610     suite->add("m", "1", "RP", "a(b*)c\\1", "abbcbb", "abbcbb", "bb", NULL);
 611     suite->add("m", "2", "RP", "a(b*)c\\1", "ac", "ac", "", NULL);
 612     suite->add("f", "3", "RP", "a(b*)c\\1", "abbcb", NULL);
 613     suite->add("m", "4", "RP", "a(b*)\\1", "abbcbb", "abb", "b", NULL);
 614     suite->add("m", "5", "RP", "a(b|bb)\\1", "abbcbb", "abb", "b", NULL);
 615     suite->add("m", "6", "RP", "a([bc])\\1", "abb", "abb", "b", NULL);
 616     suite->add("f", "7", "RP", "a([bc])\\1", "abc", NULL);
 617     suite->add("m", "8", "RP", "a([bc])\\1", "abcabb", "abb", "b", NULL);
 618     suite->add("f", "9", "RP", "a([bc])*\\1", "abc", NULL);
 619     suite->add("f", "10", "RP", "a([bc])\\1", "abB", NULL);
 620     suite->add("m", "11", "iRP", "a([bc])\\1", "abB", "abB", "b", NULL);
 621     suite->add("m", "12", "RP", "a([bc])\\1+", "abbb", "abbb", "b", NULL);
 622     suite->add("m", "13", "QRP", "a([bc])\\1{3,4}", "abbbb", "abbbb", "b", NULL);
 623     suite->add("f", "14", "QRP", "a([bc])\\1{3,4}", "abbb", NULL);
 624     suite->add("m", "15", "RP", "a([bc])\\1*", "abbb", "abbb", "b", NULL);
 625     suite->add("m", "16", "RP", "a([bc])\\1*", "ab", "ab", "b", NULL);
 626     suite->add("m", "17", "RP", "a([bc])(\\1*)", "ab", "ab", "b", "", NULL);
 627     suite->add("e", "18", "-", "a((b)\\1)", "ESUBREG", NULL);
 628     suite->add("e", "19", "-", "a(b)c\\2", "ESUBREG", NULL);
 629     suite->add("m", "20", "bR", "a\\(b*\\)c\\1", "abbcbb", "abbcbb", "bb", NULL);
 630
 631     return suite;
 632 }
 633
 634 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_14, "regex.14");
 635
 636
 637 /*
 638  * 15 octal escapes vs back references
 639  */
 640
 641 class regextest_15 : public RegExTestSuite
 642 {
 643 public:
 644     regextest_15() : RegExTestSuite("regex.15") { }
 645     static Test *suite();
 646 };
 647
 648 Test *regextest_15::suite()
 649 {
 650     RegExTestSuite *suite = new regextest_15;
 651
 652     suite->add("m", "1", "MP", "a\\010b", "a\bb", "a\bb", NULL);
 653     suite->add("m", "2", "MP", "a\\0070b", "a\a0b", "a\a0b", NULL);
 654     suite->add("m", "3", "MP", "a\\07b", "a\ab", "a\ab", NULL);
 655     suite->add("m", "4", "MP", "a(b)(b)(b)(b)(b)(b)(b)(b)(b)(b)\\07c", "abbbbbbbbbb\ac", "abbbbbbbbbb\ac", "b", "b", "b", "b", "b", "b", "b", "b", "b", "b", NULL);
 656     suite->add("e", "5", "-", "a\\7b", "ESUBREG", NULL);
 657     suite->add("m", "6", "MP", "a\\10b", "a\bb", "a\bb", NULL);
 658     suite->add("m", "7", "MP", "a\\101b", "aAb", "aAb", NULL);
 659     suite->add("m", "8", "RP", "a(b)(b)(b)(b)(b)(b)(b)(b)(b)(b)\\10c", "abbbbbbbbbbbc", "abbbbbbbbbbbc", "b", "b", "b", "b", "b", "b", "b", "b", "b", "b", NULL);
 660     suite->add("e", "9", "-", "a((((((((((b\\10))))))))))c", "ESUBREG", NULL);
 661     suite->add("m", "10", "MP", "a\\12b", "a\nb", "a\nb", NULL);
 662     suite->add("e", "11", "b", "a\\12b", "ESUBREG", NULL);
 663     suite->add("m", "12", "eAS", "a\\12b", "a12b", "a12b", NULL);
 664
 665     return suite;
 666 }
 667
 668 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_15, "regex.15");
 669
 670
 671 /*
 672  * 16 expanded syntax
 673  */
 674
 675 class regextest_16 : public RegExTestSuite
 676 {
 677 public:
 678     regextest_16() : RegExTestSuite("regex.16") { }
 679     static Test *suite();
 680 };
 681
 682 Test *regextest_16::suite()
 683 {
 684     RegExTestSuite *suite = new regextest_16;
 685
 686     suite->add("m", "1", "xP", "a b c", "abc", "abc", NULL);
 687     suite->add("m", "2", "xP", "a b #oops\nc\td", "abcd", "abcd", NULL);
 688     suite->add("m", "3", "x", "a\\ b\\\tc", "a b\tc", "a b\tc", NULL);
 689     suite->add("m", "4", "xP", "a b\\#c", "ab#c", "ab#c", NULL);
 690     suite->add("m", "5", "xP", "a b[c d]e", "ab e", "ab e", NULL);
 691     suite->add("m", "6", "xP", "a b[c#d]e", "ab#e", "ab#e", NULL);
 692     suite->add("m", "7", "xP", "a b[c#d]e", "abde", "abde", NULL);
 693     suite->add("m", "8", "xSPB", "ab{ d", "ab{d", "ab{d", NULL);
 694     suite->add("m", "9", "xPQ", "ab{ 1 , 2 }c", "abc", "abc", NULL);
 695
 696     return suite;
 697 }
 698
 699 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_16, "regex.16");
 700
 701
 702 /*
 703  * 17 misc syntax
 704  */
 705
 706 class regextest_17 : public RegExTestSuite
 707 {
 708 public:
 709     regextest_17() : RegExTestSuite("regex.17") { }
 710     static Test *suite();
 711 };
 712
 713 Test *regextest_17::suite()
 714 {
 715     RegExTestSuite *suite = new regextest_17;
 716
 717     suite->add("m", "1", "P", "a(?#comment)b", "ab", "ab", NULL);
 718
 719     return suite;
 720 }
 721
 722 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_17, "regex.17");
 723
 724
 725 /*
 726  * 18 unmatchable REs
 727  */
 728
 729 class regextest_18 : public RegExTestSuite
 730 {
 731 public:
 732     regextest_18() : RegExTestSuite("regex.18") { }
 733     static Test *suite();
 734 };
 735
 736 Test *regextest_18::suite()
 737 {
 738     RegExTestSuite *suite = new regextest_18;
 739
 740     suite->add("f", "1", "I", "a^b", "ab", NULL);
 741
 742     return suite;
 743 }
 744
 745 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_18, "regex.18");
 746
 747
 748 /*
 749  * 19 case independence
 750  */
 751
 752 class regextest_19 : public RegExTestSuite
 753 {
 754 public:
 755     regextest_19() : RegExTestSuite("regex.19") { }
 756     static Test *suite();
 757 };
 758
 759 Test *regextest_19::suite()
 760 {
 761     RegExTestSuite *suite = new regextest_19;
 762
 763     suite->add("m", "1", "&i", "ab", "Ab", "Ab", NULL);
 764     suite->add("m", "2", "&i", "a[bc]", "aC", "aC", NULL);
 765     suite->add("f", "3", "&i", "a[^bc]", "aB", NULL);
 766     suite->add("m", "4", "&iM", "a[b-d]", "aC", "aC", NULL);
 767     suite->add("f", "5", "&iM", "a[^b-d]", "aC", NULL);
 768
 769     return suite;
 770 }
 771
 772 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_19, "regex.19");
 773
 774
 775 /*
 776  * 20 directors and embedded options
 777  */
 778
 779 class regextest_20 : public RegExTestSuite
 780 {
 781 public:
 782     regextest_20() : RegExTestSuite("regex.20") { }
 783     static Test *suite();
 784 };
 785
 786 Test *regextest_20::suite()
 787 {
 788     RegExTestSuite *suite = new regextest_20;
 789
 790     suite->add("e", "1", "&", "***?", "BADPAT", NULL);
 791     suite->add("m", "2", "q", "***?", "***?", "***?", NULL);
 792     suite->add("m", "3", "&P", "***=a*b", "a*b", "a*b", NULL);
 793     suite->add("m", "4", "q", "***=a*b", "***=a*b", "***=a*b", NULL);
 794     suite->add("m", "5", "bLP", "***:\\w+", "ab", "ab", NULL);
 795     suite->add("m", "6", "eLP", "***:\\w+", "ab", "ab", NULL);
 796     suite->add("e", "7", "&", "***:***=a*b", "BADRPT", NULL);
 797     suite->add("m", "8", "&P", "***:(?b)a+b", "a+b", "a+b", NULL);
 798     suite->add("m", "9", "P", "(?b)a+b", "a+b", "a+b", NULL);
 799     suite->add("e", "10", "e", "(?b)\\w+", "BADRPT", NULL);
 800     suite->add("m", "11", "bAS", "(?b)\\w+", "(?b)w+", "(?b)w+", NULL);
 801     suite->add("m", "12", "iP", "(?c)a", "a", "a", NULL);
 802     suite->add("f", "13", "iP", "(?c)a", "A", NULL);
 803     suite->add("m", "14", "APS", "(?e)\\W+", "WW", "WW", NULL);
 804     suite->add("m", "15", "P", "(?i)a+", "Aa", "Aa", NULL);
 805     suite->add("f", "16", "P", "(?m)a.b", "a\nb", NULL);
 806     suite->add("m", "17", "P", "(?m)^b", "a\nb", "b", NULL);
 807     suite->add("f", "18", "P", "(?n)a.b", "a\nb", NULL);
 808     suite->add("m", "19", "P", "(?n)^b", "a\nb", "b", NULL);
 809     suite->add("f", "20", "P", "(?p)a.b", "a\nb", NULL);
 810     suite->add("f", "21", "P", "(?p)^b", "a\nb", NULL);
 811     suite->add("m", "22", "P", "(?q)a+b", "a+b", "a+b", NULL);
 812     suite->add("m", "23", "nP", "(?s)a.b", "a\nb", "a\nb", NULL);
 813     suite->add("m", "24", "xP", "(?t)a b", "a b", "a b", NULL);
 814     suite->add("m", "25", "P", "(?w)a.b", "a\nb", "a\nb", NULL);
 815     suite->add("m", "26", "P", "(?w)^b", "a\nb", "b", NULL);
 816     suite->add("m", "27", "P", "(?x)a b", "ab", "ab", NULL);
 817     suite->add("e", "28", "-", "(?z)ab", "BADOPT", NULL);
 818     suite->add("m", "29", "P", "(?ici)a+", "Aa", "Aa", NULL);
 819     suite->add("e", "30", "P", "(?i)(?q)a+", "BADRPT", NULL);
 820     suite->add("m", "31", "P", "(?q)(?i)a+", "(?i)a+", "(?i)a+", NULL);
 821     suite->add("m", "32", "P", "(?qe)a+", "a", "a", NULL);
 822     suite->add("m", "33", "xP", "(?q)a b", "a b", "a b", NULL);
 823     suite->add("m", "34", "P", "(?qx)a b", "a b", "a b", NULL);
 824     suite->add("m", "35", "P", "(?qi)ab", "Ab", "Ab", NULL);
 825
 826     return suite;
 827 }
 828
 829 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_20, "regex.20");
 830
 831
 832 /*
 833  * 21 capturing
 834  */
 835
 836 class regextest_21 : public RegExTestSuite
 837 {
 838 public:
 839     regextest_21() : RegExTestSuite("regex.21") { }
 840     static Test *suite();
 841 };
 842
 843 Test *regextest_21::suite()
 844 {
 845     RegExTestSuite *suite = new regextest_21;
 846
 847     suite->add("m", "1", "-", "a(b)c", "abc", "abc", "b", NULL);
 848     suite->add("m", "2", "P", "a(?:b)c", "xabc", "abc", NULL);
 849     suite->add("m", "3", "-", "a((b))c", "xabcy", "abc", "b", "b", NULL);
 850     suite->add("m", "4", "P", "a(?:(b))c", "abcy", "abc", "b", NULL);
 851     suite->add("m", "5", "P", "a((?:b))c", "abc", "abc", "b", NULL);
 852     suite->add("m", "6", "P", "a(?:(?:b))c", "abc", "abc", NULL);
 853     suite->add("i", "7", "Q", "a(b){0}c", "ac", "0 1", "-1 -1", NULL);
 854     suite->add("m", "8", "-", "a(b)c(d)e", "abcde", "abcde", "b", "d", NULL);
 855     suite->add("m", "9", "-", "(b)c(d)e", "bcde", "bcde", "b", "d", NULL);
 856     suite->add("m", "10", "-", "a(b)(d)e", "abde", "abde", "b", "d", NULL);
 857     suite->add("m", "11", "-", "a(b)c(d)", "abcd", "abcd", "b", "d", NULL);
 858     suite->add("m", "12", "-", "(ab)(cd)", "xabcdy", "abcd", "ab", "cd", NULL);
 859     suite->add("m", "13", "-", "a(b)?c", "xabcy", "abc", "b", NULL);
 860     suite->add("i", "14", "-", "a(b)?c", "xacy", "1 2", "-1 -1", NULL);
 861     suite->add("m", "15", "-", "a(b)?c(d)?e", "xabcdey", "abcde", "b", "d", NULL);
 862     suite->add("i", "16", "-", "a(b)?c(d)?e", "xacdey", "1 4", "-1 -1", "3 3", NULL);
 863     suite->add("i", "17", "-", "a(b)?c(d)?e", "xabcey", "1 4", "2 2", "-1 -1", NULL);
 864     suite->add("i", "18", "-", "a(b)?c(d)?e", "xacey", "1 3", "-1 -1", "-1 -1", NULL);
 865     suite->add("m", "19", "-", "a(b)*c", "xabcy", "abc", "b", NULL);
 866     suite->add("i", "20", "-", "a(b)*c", "xabbbcy", "1 5", "4 4", NULL);
 867     suite->add("i", "21", "-", "a(b)*c", "xacy", "1 2", "-1 -1", NULL);
 868     suite->add("m", "22", "-", "a(b*)c", "xabbbcy", "abbbc", "bbb", NULL);
 869     suite->add("m", "23", "-", "a(b*)c", "xacy", "ac", "", NULL);
 870     suite->add("f", "24", "-", "a(b)+c", "xacy", NULL);
 871     suite->add("m", "25", "-", "a(b)+c", "xabcy", "abc", "b", NULL);
 872     suite->add("i", "26", "-", "a(b)+c", "xabbbcy", "1 5", "4 4", NULL);
 873     suite->add("m", "27", "-", "a(b+)c", "xabbbcy", "abbbc", "bbb", NULL);
 874     suite->add("i", "28", "Q", "a(b){2,3}c", "xabbbcy", "1 5", "4 4", NULL);
 875     suite->add("i", "29", "Q", "a(b){2,3}c", "xabbcy", "1 4", "3 3", NULL);
 876     suite->add("f", "30", "Q", "a(b){2,3}c", "xabcy", NULL);
 877     suite->add("m", "31", "LP", "\\y(\\w+)\\y", "-- abc-", "abc", "abc", NULL);
 878     suite->add("m", "32", "-", "a((b|c)d+)+", "abacdbd", "acdbd", "bd", "b", NULL);
 879     suite->add("m", "33", "N", "(.*).*", "abc", "abc", "abc", NULL);
 880     suite->add("m", "34", "N", "(a*)*", "bc", "", "", NULL);
 881
 882     return suite;
 883 }
 884
 885 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_21, "regex.21");
 886
 887
 888 /*
 889  * 22 multicharacter collating elements
 890  */
 891
 892 class regextest_22 : public RegExTestSuite
 893 {
 894 public:
 895     regextest_22() : RegExTestSuite("regex.22") { }
 896     static Test *suite();
 897 };
 898
 899 Test *regextest_22::suite()
 900 {
 901     RegExTestSuite *suite = new regextest_22;
 902
 903     suite->add("m", "1", "&+L", "a[c]e", "ace", "ace", NULL);
 904     suite->add("f", "2", "&+IL", "a[c]h", "ach", NULL);
 905     suite->add("m", "3", "&+L", "a[[.ch.]]", "ach", "ach", NULL);
 906     suite->add("f", "4", "&+L", "a[[.ch.]]", "ace", NULL);
 907     suite->add("m", "5", "&+L", "a[c[.ch.]]", "ac", "ac", NULL);
 908     suite->add("m", "6", "&+L", "a[c[.ch.]]", "ace", "ac", NULL);
 909     suite->add("m", "7", "&+L", "a[c[.ch.]]", "ache", "ach", NULL);
 910     suite->add("f", "8", "&+L", "a[^c]e", "ace", NULL);
 911     suite->add("m", "9", "&+L", "a[^c]e", "abe", "abe", NULL);
 912     suite->add("m", "10", "&+L", "a[^c]e", "ache", "ache", NULL);
 913     suite->add("f", "11", "&+L", "a[^[.ch.]]", "ach", NULL);
 914     suite->add("m", "12", "&+L", "a[^[.ch.]]", "ace", "ac", NULL);
 915     suite->add("m", "13", "&+L", "a[^[.ch.]]", "ac", "ac", NULL);
 916     suite->add("m", "14", "&+L", "a[^[.ch.]]", "abe", "ab", NULL);
 917     suite->add("f", "15", "&+L", "a[^c[.ch.]]", "ach", NULL);
 918     suite->add("f", "16", "&+L", "a[^c[.ch.]]", "ace", NULL);
 919     suite->add("f", "17", "&+L", "a[^c[.ch.]]", "ac", NULL);
 920     suite->add("m", "18", "&+L", "a[^c[.ch.]]", "abe", "ab", NULL);
 921     suite->add("m", "19", "&+L", "a[^b]", "ac", "ac", NULL);
 922     suite->add("m", "20", "&+L", "a[^b]", "ace", "ac", NULL);
 923     suite->add("m", "21", "&+L", "a[^b]", "ach", "ach", NULL);
 924     suite->add("f", "22", "&+L", "a[^b]", "abe", NULL);
 925
 926     return suite;
 927 }
 928
 929 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_22, "regex.22");
 930
 931
 932 /*
 933  * 23 lookahead constraints
 934  */
 935
 936 class regextest_23 : public RegExTestSuite
 937 {
 938 public:
 939     regextest_23() : RegExTestSuite("regex.23") { }
 940     static Test *suite();
 941 };
 942
 943 Test *regextest_23::suite()
 944 {
 945     RegExTestSuite *suite = new regextest_23;
 946
 947     suite->add("m", "1", "HP", "a(?=b)b*", "ab", "ab", NULL);
 948     suite->add("f", "2", "HP", "a(?=b)b*", "a", NULL);
 949     suite->add("m", "3", "HP", "a(?=b)b*(?=c)c*", "abc", "abc", NULL);
 950     suite->add("f", "4", "HP", "a(?=b)b*(?=c)c*", "ab", NULL);
 951     suite->add("f", "5", "HP", "a(?!b)b*", "ab", NULL);
 952     suite->add("m", "6", "HP", "a(?!b)b*", "a", "a", NULL);
 953     suite->add("m", "7", "HP", "(?=b)b", "b", "b", NULL);
 954     suite->add("f", "8", "HP", "(?=b)b", "a", NULL);
 955
 956     return suite;
 957 }
 958
 959 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_23, "regex.23");
 960
 961
 962 /*
 963  * 24 non-greedy quantifiers
 964  */
 965
 966 class regextest_24 : public RegExTestSuite
 967 {
 968 public:
 969     regextest_24() : RegExTestSuite("regex.24") { }
 970     static Test *suite();
 971 };
 972
 973 Test *regextest_24::suite()
 974 {
 975     RegExTestSuite *suite = new regextest_24;
 976
 977     suite->add("m", "1", "PT", "ab+?", "abb", "ab", NULL);
 978     suite->add("m", "2", "PT", "ab+?c", "abbc", "abbc", NULL);
 979     suite->add("m", "3", "PT", "ab*?", "abb", "a", NULL);
 980     suite->add("m", "4", "PT", "ab*?c", "abbc", "abbc", NULL);
 981     suite->add("m", "5", "PT", "ab??", "ab", "a", NULL);
 982     suite->add("m", "6", "PT", "ab??c", "abc", "abc", NULL);
 983     suite->add("m", "7", "PQT", "ab{2,4}?", "abbbb", "abb", NULL);
 984     suite->add("m", "8", "PQT", "ab{2,4}?c", "abbbbc", "abbbbc", NULL);
 985     suite->add("m", "9", "-", "3z*", "123zzzz456", "3zzzz", NULL);
 986     suite->add("m", "10", "PT", "3z*?", "123zzzz456", "3", NULL);
 987     suite->add("m", "11", "-", "z*4", "123zzzz456", "zzzz4", NULL);
 988     suite->add("m", "12", "PT", "z*?4", "123zzzz456", "zzzz4", NULL);
 989
 990     return suite;
 991 }
 992
 993 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_24, "regex.24");
 994
 995
 996 /*
 997  * 25 mixed quantifiers
 998  */
 999
1000 class regextest_25 : public RegExTestSuite
1001 {
1002 public:
1003     regextest_25() : RegExTestSuite("regex.25") { }
1004     static Test *suite();
1005 };
1006
1007 Test *regextest_25::suite()
1008 {
1009     RegExTestSuite *suite = new regextest_25;
1010
1011     suite->add("m", "1", "PNT", "^(.*?)(a*)$", "xyza", "xyza", "xyz", "a", NULL);
1012     suite->add("m", "2", "PNT", "^(.*?)(a*)$", "xyzaa", "xyzaa", "xyz", "aa", NULL);
1013     suite->add("m", "3", "PNT", "^(.*?)(a*)$", "xyz", "xyz", "xyz", "", NULL);
1014
1015     return suite;
1016 }
1017
1018 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_25, "regex.25");
1019
1020
1021 /*
1022  * 26 tricky cases
1023  */
1024
1025 class regextest_26 : public RegExTestSuite
1026 {
1027 public:
1028     regextest_26() : RegExTestSuite("regex.26") { }
1029     static Test *suite();
1030 };
1031
1032 Test *regextest_26::suite()
1033 {
1034     RegExTestSuite *suite = new regextest_26;
1035
1036     suite->add("m", "1", "-", "(week|wee)(night|knights)", "weeknights", "weeknights", "wee", "knights", NULL);
1037     suite->add("m", "2", "RP", "a(bc*).*\\1", "abccbccb", "abccbccb", "b", NULL);
1038     suite->add("m", "3", "-", "a(b.[bc]*)+", "abcbd", "abcbd", "bd", NULL);
1039
1040     return suite;
1041 }
1042
1043 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_26, "regex.26");
1044
1045
1046 /*
1047  * 27 implementation misc.
1048  */
1049
1050 class regextest_27 : public RegExTestSuite
1051 {
1052 public:
1053     regextest_27() : RegExTestSuite("regex.27") { }
1054     static Test *suite();
1055 };
1056
1057 Test *regextest_27::suite()
1058 {
1059     RegExTestSuite *suite = new regextest_27;
1060
1061     suite->add("m", "1", "P", "a(?:b|b)c", "abc", "abc", NULL);
1062     suite->add("m", "2", "&", "[ab][ab][ab]", "aba", "aba", NULL);
1063     suite->add("m", "3", "&", "[ab][ab][ab][ab][ab][ab][ab]", "abababa", "abababa", NULL);
1064
1065     return suite;
1066 }
1067
1068 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_27, "regex.27");
1069
1070
1071 /*
1072  * 28 boundary busters etc.
1073  */
1074
1075 class regextest_28 : public RegExTestSuite
1076 {
1077 public:
1078     regextest_28() : RegExTestSuite("regex.28") { }
1079     static Test *suite();
1080 };
1081
1082 Test *regextest_28::suite()
1083 {
1084     RegExTestSuite *suite = new regextest_28;
1085
1086     suite->add("m", "1", "&", "abcdefghijkl", "abcdefghijkl", "abcdefghijkl", NULL);
1087     suite->add("m", "2", "P", "a(?:b|c|d|e|f|g|h|i|j|k|l|m)n", "agn", "agn", NULL);
1088     suite->add("m", "3", "-", "a(((((((((((((b)))))))))))))c", "abc", "abc", "b", "b", "b", "b", "b", "b", "b", "b", "b", "b", "b", "b", "b", NULL);
1089     suite->add("m", "4", "Q", "ab{1,100}c", "abbc", "abbc", NULL);
1090     suite->add("m", "5", "Q", "ab{1,100}c", "abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc", "abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc", NULL);
1091     suite->add("m", "6", "Q", "ab{1,100}c", "abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc", "abbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc", NULL);
1092     suite->add("m", "7", "LP", "\\w+abcdefgh", "xyzabcdefgh", "xyzabcdefgh", NULL);
1093     suite->add("m", "8", "%LP", "\\w+abcdefgh", "xyzabcdefgh", "xyzabcdefgh", NULL);
1094     suite->add("m", "9", "%LP", "\\w+abcdefghijklmnopqrst", "xyzabcdefghijklmnopqrst", "xyzabcdefghijklmnopqrst", NULL);
1095     suite->add("i", "10", "%LP", "\\w+(abcdefgh)?", "xyz", "0 2", "-1 -1", NULL);
1096     suite->add("i", "11", "%LP", "\\w+(abcdefgh)?", "xyzabcdefg", "0 9", "-1 -1", NULL);
1097     suite->add("i", "12", "%LP", "\\w+(abcdefghijklmnopqrst)?", "xyzabcdefghijklmnopqrs", "0 21", "-1 -1", NULL);
1098
1099     return suite;
1100 }
1101
1102 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_28, "regex.28");
1103
1104
1105 /*
1106  * 29 incomplete matches
1107  */
1108
1109 class regextest_29 : public RegExTestSuite
1110 {
1111 public:
1112     regextest_29() : RegExTestSuite("regex.29") { }
1113     static Test *suite();
1114 };
1115
1116 Test *regextest_29::suite()
1117 {
1118     RegExTestSuite *suite = new regextest_29;
1119
1120     suite->add("p", "1", "t", "def", "abc", "3 2", "", NULL);
1121     suite->add("p", "2", "t", "bcd", "abc", "1 2", "", NULL);
1122     suite->add("p", "3", "t", "abc", "abab", "0 3", "", NULL);
1123     suite->add("p", "4", "t", "abc", "abdab", "3 4", "", NULL);
1124     suite->add("i", "5", "t", "abc", "abc", "0 2", "0 2", NULL);
1125     suite->add("i", "6", "t", "abc", "xyabc", "2 4", "2 4", NULL);
1126     suite->add("p", "7", "t", "abc+", "xyab", "2 3", "", NULL);
1127     suite->add("i", "8", "t", "abc+", "xyabc", "2 4", "2 4", NULL);
1128     suite->add("i", "10", "t", "abc+", "xyabcdd", "2 4", "7 6", NULL);
1129     suite->add("p", "11", "tPT", "abc+?", "xyab", "2 3", "", NULL);
1130     suite->add("i", "12", "tPT", "abc+?", "xyabc", "2 4", "5 4", NULL);
1131     suite->add("i", "13", "tPT", "abc+?", "xyabcc", "2 4", "6 5", NULL);
1132     suite->add("i", "14", "tPT", "abc+?", "xyabcd", "2 4", "6 5", NULL);
1133     suite->add("i", "15", "tPT", "abc+?", "xyabcdd", "2 4", "7 6", NULL);
1134     suite->add("i", "16", "t", "abcd|bc", "xyabc", "3 4", "2 4", NULL);
1135     suite->add("p", "17", "tn", ".*k", "xx\nyyy", "3 5", "", NULL);
1136
1137     return suite;
1138 }
1139
1140 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_29, "regex.29");
1141
1142
1143 /*
1144  * 30 misc. oddities and old bugs
1145  */
1146
1147 class regextest_30 : public RegExTestSuite
1148 {
1149 public:
1150     regextest_30() : RegExTestSuite("regex.30") { }
1151     static Test *suite();
1152 };
1153
1154 Test *regextest_30::suite()
1155 {
1156     RegExTestSuite *suite = new regextest_30;
1157
1158     suite->add("e", "1", "&", "***", "BADRPT", NULL);
1159     suite->add("m", "2", "N", "a?b*", "abb", "abb", NULL);
1160     suite->add("m", "3", "N", "a?b*", "bb", "bb", NULL);
1161     suite->add("m", "4", "&", "a*b", "aab", "aab", NULL);
1162     suite->add("m", "5", "&", "^a*b", "aaaab", "aaaab", NULL);
1163     suite->add("m", "6", "&M", "[0-6][1-2][0-3][0-6][1-6][0-6]", "010010", "010010", NULL);
1164     suite->add("m", "7", "s", "abc", "abcd", "abc", NULL);
1165     suite->add("f", "8", "s", "abc", "xabcd", NULL);
1166     suite->add("m", "9", "HLP", "(?n)^(?![t#])\\S+", "tk\n\n#\n#\nit0", "it0", NULL);
1167
1168     return suite;
1169 }
1170
1171 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_30, "regex.30");
1172
1173
1174 /*
1175  * extra_1 checks for bug fixes
1176  */
1177
1178 class regextest_extra_1 : public RegExTestSuite
1179 {
1180 public:
1181     regextest_extra_1() : RegExTestSuite("regex.extra_1") { }
1182     static Test *suite();
1183 };
1184
1185 Test *regextest_extra_1::suite()
1186 {
1187     RegExTestSuite *suite = new regextest_extra_1;
1188
1189     suite->add("m", "Bug 230589", "o", "[ ]*(^|[^%])%V", "*%V2", NULL);
1190     suite->add("m", "Bug 504785", "-", "([^_.]*)([^.]*)\\.(..)(.).*", "bbcos_001_c01.q1la", "bbcos_001_c01.q1la", "bbcos", "_001_c01", "q1", "l", NULL);
1191     suite->add("m", "Bug 505048", "o", "\\A\\s*[^<]*\\s*<([^>]+)>", "a<a>", NULL);
1192     suite->add("m", "Bug 505048", "o", "\\A\\s*([^b]*)b", "ab", NULL);
1193     suite->add("m", "Bug 505048", "o", "\\A\\s*[^b]*(b)", "ab", NULL);
1194     suite->add("m", "Bug 505048", "o", "\\A(\\s*)[^b]*(b)", "ab", NULL);
1195     suite->add("m", "Bug 505048", "o", "\\A\\s*[^b]*b", "ab", NULL);
1196     suite->add("m", "Bug 505048", "-", "\\A\\s*[^b]*b", "ab", "ab", NULL);
1197     suite->add("i", "Bug 505048", "-", "\\A\\s*[^b]*b", "ab", "0 1", NULL);
1198
1199     return suite;
1200 }
1201
1202 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_extra_1, "regex.extra_1");
1203
1204
1205 /*
1206  * wx_1 character classification: ascii
1207  */
1208
1209 class regextest_wx_1 : public RegExTestSuite
1210 {
1211 public:
1212     regextest_wx_1() : RegExTestSuite("regex.wx_1") { }
1213     static Test *suite();
1214 };
1215
1216 Test *regextest_wx_1::suite()
1217 {
1218     RegExTestSuite *suite = new regextest_wx_1;
1219
1220     suite->add("m", "1", "&", "[^[:alnum:]]", "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!", "!", NULL);
1221     suite->add("m", "2", "&", "[[:alnum:]]", "\a\b\t\n\v\f\r !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~X", "X", NULL);
1222     suite->add("m", "3", "&", "[^[:alpha:]]", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!", "!", NULL);
1223     suite->add("m", "4", "&", "[[:alpha:]]", "\a\b\t\n\v\f\r !\"#$%&'()*+,-./0123456789:;<=>?@[\\]^_`{|}~X", "X", NULL);
1224     suite->add("m", "5", "&", "[^[:cntrl:]]", "\a\b\t\n\v\f\r!", "!", NULL);
1225     suite->add("m", "6", "&", "[[:cntrl:]]", " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\n", "\n", NULL);
1226     suite->add("m", "7", "&", "[^[:digit:]]", "0123456789!", "!", NULL);
1227     suite->add("m", "8", "&", "[[:digit:]]", "\a\b\t\n\v\f\r !\"#$%&'()*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 0", "0", NULL);
1228     suite->add("m", "9", "&", "[^[:graph:]]", "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\n", "\n", NULL);
1229     suite->add("m", "10", "&", "[[:graph:]]", "\a\b\t\n\v\f\r !", "!", NULL);
1230     suite->add("m", "11", "&", "[^[:lower:]]", "abcdefghijklmnopqrstuvwxyz!", "!", NULL);
1231     suite->add("m", "12", "&", "[[:lower:]]", "\a\b\t\n\v\f\r !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`{|}~x", "x", NULL);
1232     suite->add("m", "13", "&", "[^[:print:]]", "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n", "\n", NULL);
1233     suite->add("m", "14", "&", "[[:print:]]", "\a\b\n\v\f\rX", "X", NULL);
1234     suite->add("m", "15", "&", "[^[:punct:]]", "!\"#%&'()*,-./:;?@[\\]_{}X", "X", NULL);
1235     suite->add("m", "16", "&", "[[:punct:]]", "\a\b\t\n\v\f\r 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!", "!", NULL);
1236     suite->add("m", "17", "&", "[^[:space:]]", "\t\n\v\f\r X", "X", NULL);
1237     suite->add("m", "18", "&", "[[:space:]]", "\a\b!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\n", "\n", NULL);
1238     suite->add("m", "19", "&", "[^[:upper:]]", "ABCDEFGHIJKLMNOPQRSTUVWXYZ!", "!", NULL);
1239     suite->add("m", "20", "&", "[[:upper:]]", "\a\b\t\n\v\f\r !\"#$%&'()*+,-./0123456789:;<=>?@[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~X", "X", NULL);
1240     suite->add("m", "21", "&", "[^[:xdigit:]]", "0123456789ABCDEFabcdef!", "!", NULL);
1241     suite->add("m", "22", "&", "[[:xdigit:]]", "\a\b\t\n\v\f\r !\"#$%&'()*+,-./:;<=>?@GHIJKLMNOPQRSTUVWXYZ[\\]^_`ghijklmnopqrstuvwxyz{|}~a", "a", NULL);
1242     suite->add("i", "23", "&i", "AbCdEfGhIjKlMnOpQrStUvWxYz", "aBcDeFgHiJkLmNoPqRsTuVwXyZ", "0 25", NULL);
1243
1244     return suite;
1245 }
1246
1247 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_wx_1, "regex.wx_1");
1248
1249
1250 /*
1251  * wx_2 character classification: western european
1252  */
1253
1254 class regextest_wx_2 : public RegExTestSuite
1255 {
1256 public:
1257     regextest_wx_2() : RegExTestSuite("regex.wx_2") { }
1258     static Test *suite();
1259 };
1260
1261 Test *regextest_wx_2::suite()
1262 {
1263     RegExTestSuite *suite = new regextest_wx_2;
1264
1265     suite->add("m", "1", "&*", "[^[:alpha:]]", "\303\200\303\201\303\202\303\203\303\204\303\205\303\206\303\207\303\210\303\211\303\212\303\213\303\214\303\215\303\216\303\217\303\220\303\221\303\222\303\223\303\224\303\225\303\226\303\230\303\231\303\232\303\233\303\234\303\235\303\236\303\237\303\240\303\241\303\242\303\243\303\244\303\245\303\246\303\247\303\250\303\251\303\252\303\253\303\254\303\255\303\256\303\257\303\260\303\261\303\262\303\263\303\264\303\265\303\266\303\270\303\271\303\272\303\273\303\274\303\275\303\276\303\277!", "!", NULL);
1266     suite->add("m", "2", "&*", "[[:alpha:]]", "\302\240\302\241\302\242\302\243\302\244\302\245\302\246\302\247\302\250\302\251\302\253\302\254\302\255\302\256\302\257\302\260\302\261\302\262\302\263\302\264\302\266\302\267\302\270\302\271\302\273\302\274\302\275\302\276\302\277\303\227\303\267X", "X", NULL);
1267     suite->add("m", "3", "&*", "[^[:lower:]]", "\303\237\303\240\303\241\303\242\303\243\303\244\303\245\303\246\303\247\303\250\303\251\303\252\303\253\303\254\303\255\303\256\303\257\303\260\303\261\303\262\303\263\303\264\303\265\303\266\303\270\303\271\303\272\303\273\303\274\303\275\303\276\303\277!", "!", NULL);
1268     suite->add("m", "4", "&*", "[[:lower:]]", "\302\240\302\241\302\242\302\243\302\244\302\245\302\246\302\247\302\250\302\251\302\253\302\254\302\255\302\256\302\257\302\260\302\261\302\262\302\263\302\264\302\266\302\267\302\270\302\271\302\273\302\274\302\275\302\276\302\277\303\200\303\201\303\202\303\203\303\204\303\205\303\206\303\207\303\210\303\211\303\212\303\213\303\214\303\215\303\216\303\217\303\220\303\221\303\222\303\223\303\224\303\225\303\226\303\227\303\230\303\231\303\232\303\233\303\234\303\235\303\236\303\267x", "x", NULL);
1269     suite->add("m", "5", "&*", "[^[:upper:]]", "\303\200\303\201\303\202\303\203\303\204\303\205\303\206\303\207\303\210\303\211\303\212\303\213\303\214\303\215\303\216\303\217\303\220\303\221\303\222\303\223\303\224\303\225\303\226\303\230\303\231\303\232\303\233\303\234\303\235\303\236!", "!", NULL);
1270     suite->add("m", "6", "&*", "[[:upper:]]", "\302\240\302\241\302\242\302\243\302\244\302\245\302\246\302\247\302\250\302\251\302\253\302\254\302\255\302\256\302\257\302\260\302\261\302\262\302\263\302\264\302\266\302\267\302\270\302\271\302\273\302\274\302\275\302\276\302\277\303\227\303\237\303\240\303\241\303\242\303\243\303\244\303\245\303\246\303\247\303\250\303\251\303\252\303\253\303\254\303\255\303\256\303\257\303\260\303\261\303\262\303\263\303\264\303\265\303\266\303\267\303\270\303\271\303\272\303\273\303\274\303\275\303\276\303\277X", "X", NULL);
1271     suite->add("i", "7", "&i*", "\303\200\303\241\303\202\303\243\303\204\303\245\303\206\303\247\303\210\303\251\303\212\303\253\303\214\303\255\303\216\303\257\303\220\303\261\303\222\303\263\303\224\303\265\303\226\303\270\303\231\303\272\303\233\303\274\303\235\303\276", "\303\240\303\201\303\242\303\203\303\244\303\205\303\246\303\207\303\250\303\211\303\252\303\213\303\254\303\215\303\256\303\217\303\260\303\221\303\262\303\223\303\264\303\225\303\266\303\230\303\271\303\232\303\273\303\234\303\275\303\236", "0 29", NULL);
1272
1273     return suite;
1274 }
1275
1276 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_wx_2, "regex.wx_2");
1277
1278
1279 /*
1280  * wx_3 character classification: cyrillic
1281  */
1282
1283 class regextest_wx_3 : public RegExTestSuite
1284 {
1285 public:
1286     regextest_wx_3() : RegExTestSuite("regex.wx_3") { }
1287     static Test *suite();
1288 };
1289
1290 Test *regextest_wx_3::suite()
1291 {
1292     RegExTestSuite *suite = new regextest_wx_3;
1293
1294     suite->add("m", "1", "&*", "[^[:alpha:]]", "\321\221\320\201\321\216\320\260\320\261\321\206\320\264\320\265\321\204\320\263\321\205\320\270\320\271\320\272\320\273\320\274\320\275\320\276\320\277\321\217\321\200\321\201\321\202\321\203\320\266\320\262\321\214\321\213\320\267\321\210\321\215\321\211\321\207\321\212\320\256\320\220\320\221\320\246\320\224\320\225\320\244\320\223\320\245\320\230\320\231\320\232\320\233\320\234\320\235\320\236\320\237\320\257\320\240\320\241\320\242\320\243\320\226\320\222\320\254\320\253\320\227\320\250\320\255\320\251\320\247\320\252!", "!", NULL);
1295     suite->add("m", "2", "&*", "[^[:lower:]]", "\321\221\321\216\320\260\320\261\321\206\320\264\320\265\321\204\320\263\321\205\320\270\320\271\320\272\320\273\320\274\320\275\320\276\320\277\321\217\321\200\321\201\321\202\321\203\320\266\320\262\321\214\321\213\320\267\321\210\321\215\321\211\321\207\321\212!", "!", NULL);
1296     suite->add("m", "3", "&*", "[[:lower:]]", "\320\201\320\256\320\220\320\221\320\246\320\224\320\225\320\244\320\223\320\245\320\230\320\231\320\232\320\233\320\234\320\235\320\236\320\237\320\257\320\240\320\241\320\242\320\243\320\226\320\222\320\254\320\253\320\227\320\250\320\255\320\251\320\247\320\252x", "x", NULL);
1297     suite->add("m", "4", "&*", "[^[:upper:]]", "\320\201\320\256\320\220\320\221\320\246\320\224\320\225\320\244\320\223\320\245\320\230\320\231\320\232\320\233\320\234\320\235\320\236\320\237\320\257\320\240\320\241\320\242\320\243\320\226\320\222\320\254\320\253\320\227\320\250\320\255\320\251\320\247\320\252!", "!", NULL);
1298     suite->add("m", "5", "&*", "[[:upper:]]", "\321\221\321\216\320\260\320\261\321\206\320\264\320\265\321\204\320\263\321\205\320\270\320\271\320\272\320\273\320\274\320\275\320\276\320\277\321\217\321\200\321\201\321\202\321\203\320\266\320\262\321\214\321\213\320\267\321\210\321\215\321\211\321\207\321\212X", "X", NULL);
1299     suite->add("i", "6", "&i*", "\320\201\321\216\320\220\320\261\320\246\320\264\320\225\321\204\320\223\321\205\320\230\320\271\320\232\320\273\320\234\320\275\320\236\320\277\320\257\321\200\320\241\321\202\320\243\320\266\320\222\321\214\320\253\320\267\320\250\321\215\320\251\321\207\320\252", "\321\221\320\256\320\260\320\221\321\206\320\224\320\265\320\244\320\263\320\245\320\270\320\231\320\272\320\233\320\274\320\235\320\276\320\237\321\217\320\240\321\201\320\242\321\203\320\226\320\262\320\254\321\213\320\227\321\210\320\255\321\211\320\247\321\212", "0 32", NULL);
1300
1301     return suite;
1302 }
1303
1304 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest_wx_3, "regex.wx_3");
1305
1306
1307 /*
1308  * A suite containing all the above suites
1309  */
1310
1311 class regextest : public TestSuite
1312 {
1313 public:
1314     regextest() : TestSuite("regex") { }
1315     static Test *suite();
1316 };
1317
1318 Test *regextest::suite()
1319 {
1320     TestSuite *suite = new regextest;
1321
1322     suite->addTest(regextest_1::suite());
1323     suite->addTest(regextest_2::suite());
1324     suite->addTest(regextest_3::suite());
1325     suite->addTest(regextest_4::suite());
1326     suite->addTest(regextest_5::suite());
1327     suite->addTest(regextest_6::suite());
1328     suite->addTest(regextest_7::suite());
1329     suite->addTest(regextest_8::suite());
1330     suite->addTest(regextest_9::suite());
1331     suite->addTest(regextest_10::suite());
1332     suite->addTest(regextest_11::suite());
1333     suite->addTest(regextest_12::suite());
1334     suite->addTest(regextest_13::suite());
1335     suite->addTest(regextest_14::suite());
1336     suite->addTest(regextest_15::suite());
1337     suite->addTest(regextest_16::suite());
1338     suite->addTest(regextest_17::suite());
1339     suite->addTest(regextest_18::suite());
1340     suite->addTest(regextest_19::suite());
1341     suite->addTest(regextest_20::suite());
1342     suite->addTest(regextest_21::suite());
1343     suite->addTest(regextest_22::suite());
1344     suite->addTest(regextest_23::suite());
1345     suite->addTest(regextest_24::suite());
1346     suite->addTest(regextest_25::suite());
1347     suite->addTest(regextest_26::suite());
1348     suite->addTest(regextest_27::suite());
1349     suite->addTest(regextest_28::suite());
1350     suite->addTest(regextest_29::suite());
1351     suite->addTest(regextest_30::suite());
1352     suite->addTest(regextest_extra_1::suite());
1353     suite->addTest(regextest_wx_1::suite());
1354     suite->addTest(regextest_wx_2::suite());
1355     suite->addTest(regextest_wx_3::suite());
1356
1357     return suite;
1358 }
1359
1360 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(regextest, "regex");
1361 CPPUNIT_TEST_SUITE_REGISTRATION(regextest);