[unix-history] / gnu / lib / libregex / test / other.c

/* other.c: test (not exhaustively) non-POSIX regular expressions.  */

#include "test.h"

void
test_others ()
{
  struct re_registers regs;
  
  printf ("\nStarting non-POSIX tests.\n");
  t = other_test;

  test_should_match = true;

  /* The big question: does the group participate in the match, or match
     the empty string?  */
  re_set_syntax (RE_NO_BK_PARENS);
  test_match ("(a*)*ab", "ab");
  TEST_REGISTERS ("(a*)*ab", "ab", 0, 2, 0, 0, -1, -1);
  test_match ("(a*)*", "");
  TEST_REGISTERS ("(a*)*ab", "ab", 0, 0, 0, 0, -1, -1);
  
  /* This tests finding the highest and lowest active registers.  */
  test_match ("(a(b)c(d(e)f)g)h(i(j)k(l(m)n)o)\\1\\2\\3\\4\\5\\6\\7\\8",
              "abcdefghijklmnoabcdefgbdefeijklmnojlmnm");

  /* Test that \< and \> match at the beginning and end of the string.  */
  test_match ("\\<abc\\>", "abc");
  
  /* May as well test \` and \' while we're at it.  */
  test_match ("\\`abc\\'", "abc");
  
#if 0
  /* Test backreferencing and the fastmap -- which doesn't work.  */
  test_fastmap ("(a)*\\1", "a", 0, 0);
#endif

  /* But at least we shouldn't search improperly.  */
  test_search_return (-1, "(a)\\1", "");
  
  re_set_syntax (RE_SYNTAX_EMACS);
  
  MATCH_SELF("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
  MATCH_SELF ("a^");
  MATCH_SELF ("a^b");
  MATCH_SELF ("$a");
  MATCH_SELF ("a$b");

  re_set_syntax (RE_BACKSLASH_ESCAPE_IN_LISTS);
  test_match ("[\\^a]", "a");
  test_match ("[\\^a]", "^");

  /* These op characters should be ordinary if RE_CONTEXT_INVALID_OPS
     isn't set.  */
  re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_BRACES | RE_INTERVALS
                 | RE_NO_BK_PARENS);
  MATCH_SELF ("*");
  test_match ("a|*", "*");
  test_match ("(*)", "*");

  MATCH_SELF ("+");
  test_match ("a|+", "+");
  test_match ("(+)", "+");

  MATCH_SELF ("?");
  test_match ("a|?", "?");
  test_match ("(?)", "?");

  MATCH_SELF ("{1}");
  test_match ("a|{1}", "a");
  test_match ("a|{1}", "{1}");
  test_match ("({1})", "{1}");
  
  test_match ("\\{", "{");


  re_set_syntax (RE_LIMITED_OPS);
  MATCH_SELF ("|");
  MATCH_SELF ("a|");
  MATCH_SELF ("a|");
  MATCH_SELF ("a||");
  MATCH_SELF ("a||");
  MATCH_SELF ("(|)");

  re_set_syntax (RE_SYNTAX_EMACS);
  TEST_SEARCH ("^a", "b\na", 0, 3);
  TEST_SEARCH ("b$", "b\na", 0, 3);

#if 0
  /* Newline is no longer special for anchors (16 Sep 92).  --karl  */
  test_match_2 ("a\n^b", "a", "\nb");
  test_match_2 ("a$\nb", "a\n", "b");
#endif

  /* Test grouping.  */
  re_set_syntax (RE_NO_BK_PARENS);
  
  test_match ("()", "");
  test_fastmap ("()", "", 0, 0);
  TEST_REGISTERS ("()", "", 0, 0, 0, 0, -1, -1);

  test_match ("((((((((()))))))))", "");
  test_fastmap ("((((((((()))))))))", "", 0, 0);
  test_match ("a()b", "ab");
  TEST_REGISTERS ("a()b", "ab", 0, 2, 1, 1, -1, -1);

  test_match ("(((((((((())))))))))", "");
  test_fastmap ("(((((((((())))))))))", "", 0, 0);
  
  test_match ("()*", "");
  TEST_REGISTERS ("()*", "", 0, 0, 0, 0, -1, -1);  /* empty string */
  test_match ("(())*", "");

  re_set_syntax (RE_CONTEXT_INDEP_OPS);
  test_match ("*", "");
  
  re_set_syntax (RE_INTERVALS | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES);
  test_match ("{1}", "");		/* Should remain an interval.  */
  MATCH_SELF ("{1");			/* Not a valid interval.  */
  
  re_set_syntax (RE_NEWLINE_ALT);
  test_match ("a\nb", "a");
  test_match ("a\nb", "b");
  
  re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
  test_match ("^a", "a");
  test_match ("(^a)", "a");
  test_match ("(a|^b)", "b");
  test_match ("a$", "a");
  test_match ("(a$)", "a");
  test_match ("a$|b", "a");
  
  /* You should be able to have empty alternatives if RE_NO_EMPTY_ALTS
     isn't set.  */
  re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
  
  test_match ("|", "");
  test_match ("^|a", "");
  test_match ("^|a", "a");
  test_match ("a|", "");
  test_match ("a|", "a");
  test_match ("a|$", "");
  test_match ("a|$", "a");
  test_match ("a||b", "a");
  test_match ("a||b", "");
  test_match ("a||b", "b");
  test_match ("(|a)", "");
  test_match ("(|a)", "a");
  test_match ("(a|)", "");
  test_match ("(a|)", "a");

  TEST_SEARCH ("a|$", "xa", 0, 2);
  TEST_SEARCH ("a|$", "x", 0, 1);
  TEST_SEARCH ("$|b", "x", 0, 1);
  TEST_SEARCH ("$|b", "xb", 0, 2);
  TEST_SEARCH ("c(a|$)", "xca", 0, 3);
  TEST_SEARCH ("c(a|$)", "xc", 0, 2);
  TEST_SEARCH ("c($|b)", "xcb", 0, 3);
  TEST_SEARCH ("c($|b)", "xc", 0, 2);
  TEST_SEARCH ("c($|b$)", "xcb", 0, 3);
  TEST_SEARCH ("c($|b$)", "xc", 0, 2);
  TEST_SEARCH ("c(a$|$)", "xca", 0, 3);
  TEST_SEARCH ("c(a$|$)", "xc", 0, 2);
  TEST_SEARCH ("(a$|b$)|$", "x", 0, 1);
  TEST_SEARCH ("(a$|b$)|$", "xa", 0, 2);
  TEST_SEARCH ("(a$|b$)|$", "xb", 0, 2);
  TEST_SEARCH ("(a$|$)|c$", "x", 0, 1);
  TEST_SEARCH ("(a$|$)|c$", "xa", 0, 2);
  TEST_SEARCH ("(a$|$)|c$", "xc", 0, 2);
  TEST_SEARCH ("($|b$)|c$", "x", 0, 1);
  TEST_SEARCH ("($|b$)|c$", "xb", 0, 2);
  TEST_SEARCH ("($|b$)|c$", "xc", 0, 2);
  TEST_SEARCH ("c$|(a$|$)", "x", 0, 1);
  TEST_SEARCH ("c$|(a$|$)", "xa", 0, 2);
  TEST_SEARCH ("c$|(a$|$)", "xc", 0, 2);
  TEST_SEARCH ("c$|($|b$)", "x", 0, 1);
  TEST_SEARCH ("c$|($|b$)", "xb", 0, 2);
  TEST_SEARCH ("c$|($|b$)", "xc", 0, 2);
  TEST_SEARCH ("$|(a$|b$)", "x", 0, 1);
  TEST_SEARCH ("$|(a$|b$)", "xa", 0, 2);
  TEST_SEARCH ("$|(a$|b$)", "xb", 0, 2);
  TEST_SEARCH ("c(a$|b$)|$", "x", 0, 1);
  TEST_SEARCH ("c(a$|b$)|$", "xca", 0, 3);
  TEST_SEARCH ("c(a$|b$)|$", "xcb", 0, 3);
  TEST_SEARCH ("c(a$|$)|d$", "xc", 0, 2);
  TEST_SEARCH ("c(a$|$)|d$", "xca", 0, 3);
  TEST_SEARCH ("c(a$|$)|d$", "xd", 0, 2);
  TEST_SEARCH ("c($|b$)|d$", "xc", 0, 2);
  TEST_SEARCH ("c($|b$)|d$", "xcb", 0, 3);
  TEST_SEARCH ("c($|b$)|d$", "xd", 0, 2);
  TEST_SEARCH ("d(c$|e((a$|$)))", "xdc", 0, 3);
  TEST_SEARCH ("d(c$|e((a$|$)))", "xde", 0, 3);
  TEST_SEARCH ("d(c$|e((a$|$)))", "xdea", 0, 4);
  TEST_SEARCH ("d(c$|e(($|b$)))", "xdc", 0, 3);
  TEST_SEARCH ("d(c$|e(($|b$)))", "xde", 0, 3);
  TEST_SEARCH ("d(c$|e(($|b$)))", "xdeb", 0, 4);
  TEST_SEARCH ("d($|e((a$|b$)))", "xd", 0, 2);
  TEST_SEARCH ("d($|e((a$|b$)))", "xdea", 0, 4);
  TEST_SEARCH ("d($|e((a$|b$)))", "xdeb", 0, 4);
  TEST_SEARCH ("a(b$|c$)|$", "x", 0, 1);
  TEST_SEARCH ("a(b$|c$)|$", "xab", 0, 3);
  TEST_SEARCH ("a(b$|c$)|$", "xac", 0, 3);
  TEST_SEARCH ("a(b$|$)|d$", "xa", 0, 2);
  TEST_SEARCH ("a(b$|$)|d$", "xab", 0, 3);
  TEST_SEARCH ("a(b$|$)|d$", "xd", 0, 2);
  TEST_SEARCH ("a($|c$)|d$", "xa", 0, 2);
  TEST_SEARCH ("a($|c$)|d$", "xac", 0, 3);
  TEST_SEARCH ("a($|c$)|d$", "xd", 0, 2);
  TEST_SEARCH ("d$|a(b$|$)", "xd", 0, 2);
  TEST_SEARCH ("d$|a(b$|$)", "xa", 0, 2);
  TEST_SEARCH ("d$|a(b$|$)", "xab", 0, 3);
  TEST_SEARCH ("d$|a($|c$)", "xd", 0, 2);
  TEST_SEARCH ("d$|a($|c$)", "xa", 0, 2);
  TEST_SEARCH ("d$|a($|c$)", "xac", 0, 3);
  TEST_SEARCH ("$|a(b$|c$)", "x", 0, 1);
  TEST_SEARCH ("$|a(b$|c$)", "xab", 0, 3);
  TEST_SEARCH ("$|a(b$|c$)", "xac", 0, 3);
  TEST_SEARCH ("(a)(b$|c$)|d$", "xab", 0, 3);
  TEST_SEARCH ("(a)(b$|c$)|d$", "xac", 0, 3);
  TEST_SEARCH ("(a)(b$|c$)|d$", "xd", 0, 2);
  TEST_SEARCH ("(a)(b$|$)|d$", "xa", 0, 2);
  TEST_SEARCH ("(a)(b$|$)|d$", "xab", 0, 3);
  TEST_SEARCH ("(a)(b$|$)|d$", "xd", 0, 2);
  TEST_SEARCH ("(a)($|c$)|d$", "xa", 0, 2);
  TEST_SEARCH ("(a)($|c$)|d$", "xac", 0, 3);
  TEST_SEARCH ("(a)($|c$)|d$", "xd", 0, 2);
  TEST_SEARCH ("d$|(a)(b$|$)", "xd", 0, 2);
  TEST_SEARCH ("d$|(a)(b$|$)", "xa", 0, 2);
  TEST_SEARCH ("d$|(a)(b$|$)", "xab", 0, 3);
  TEST_SEARCH ("d$|(a)($|c$)", "xd", 0, 2);
  TEST_SEARCH ("d$|(a)($|c$)", "xa", 0, 2);
  TEST_SEARCH ("d$|(a)($|c$)", "xac", 0, 3);
  TEST_SEARCH ("$|(a)(b$|c$)", "x", 0, 1);
  TEST_SEARCH ("$|(a)(b$|c$)", "xab", 0, 3);
  TEST_SEARCH ("$|(a)(b$|c$)", "xac", 0, 3);
  TEST_SEARCH ("d$|(c$|(a$|$))", "x", 0, 1);
  TEST_SEARCH ("d$|(c$|(a$|$))", "xd", 0, 2);
  TEST_SEARCH ("d$|(c$|(a$|$))", "xc", 0, 2);
  TEST_SEARCH ("d$|(c$|(a$|$))", "xa", 0, 2);
  TEST_SEARCH ("d$|(c$|($|b$))", "x", 0, 1);
  TEST_SEARCH ("d$|(c$|($|b$))", "xd", 0, 2);
  TEST_SEARCH ("d$|(c$|($|b$))", "xc", 0, 2);
  TEST_SEARCH ("d$|(c$|($|b$))", "xb", 0, 2);
  TEST_SEARCH ("d$|($|(a$|b$))", "x", 0, 1);
  TEST_SEARCH ("d$|($|(a$|b$))", "xd", 0, 2);
  TEST_SEARCH ("d$|($|(a$|b$))", "xa", 0, 2);
  TEST_SEARCH ("d$|($|(a$|b$))", "xb", 0, 2);
  TEST_SEARCH ("$|(c$|(a$|b$))", "x", 0, 1);
  TEST_SEARCH ("$|(c$|(a$|b$))", "xc", 0, 2);
  TEST_SEARCH ("$|(c$|(a$|b$))", "xa", 0, 2);
  TEST_SEARCH ("$|(c$|(a$|b$))", "xb", 0, 2);
  TEST_SEARCH ("d$|c(a$|$)", "xd", 0, 2);
  TEST_SEARCH ("d$|c(a$|$)", "xc", 0, 2);
  TEST_SEARCH ("d$|c(a$|$)", "xca", 0, 3);
  TEST_SEARCH ("d$|c($|b$)", "xd", 0, 2);
  TEST_SEARCH ("d$|c($|b$)", "xc", 0, 2);
  TEST_SEARCH ("d$|c($|b$)", "xcb", 0, 3);
  TEST_SEARCH ("$|c(a$|b$)", "x", 0, 1);
  TEST_SEARCH ("$|c(a$|b$)", "xca", 0, 3);
  TEST_SEARCH ("$|c(a$|b$)", "xcb", 0, 3);
  TEST_SEARCH ("e(d$|c((a$|$)))", "xed", 0, 3);
  TEST_SEARCH ("e(d$|c((a$|$)))", "xec", 0, 3);
  TEST_SEARCH ("e(d$|c((a$|$)))", "xeca", 0, 3);
  TEST_SEARCH ("e(d$|c(($|b$)))", "xed", 0, 3);
  TEST_SEARCH ("e(d$|c(($|b$)))", "xec", 0, 3);
  TEST_SEARCH ("e(d$|c(($|b$)))", "xecb", 0, 4);
  TEST_SEARCH ("e($|c((a$|b$)))", "xe", 0, 2);
  TEST_SEARCH ("e($|c((a$|b$)))", "xeca", 0, 4);
  TEST_SEARCH ("e($|c((a$|b$)))", "xecb", 0, 4);
  TEST_SEARCH ("ed$|(c((a$|$)))", "xed", 0, 3);
  TEST_SEARCH ("ed$|(c((a$|$)))", "xc", 0, 2);
  TEST_SEARCH ("ed$|(c((a$|$)))", "xca", 0, 3);
  TEST_SEARCH ("ed$|(c(($|b$)))", "xed", 0, 3);
  TEST_SEARCH ("ed$|(c(($|b$)))", "xc", 0, 2);
  TEST_SEARCH ("ed$|(c(($|b$)))", "xcb", 0, 3);
  TEST_SEARCH ("$|(c((a$|b$)))", "x", 0, 1);
  TEST_SEARCH ("$|(c((a$|b$)))", "xca", 0, 3);
  TEST_SEARCH ("$|(c((a$|b$)))", "xcb", 0, 3);
  TEST_SEARCH ("d$|($|(a|b)$)", "x", 0, 1);
  TEST_SEARCH ("d$|($|(a|b)$)", "xa", 0, 2);
  TEST_SEARCH ("d$|($|(a|b)$)", "xb", 0, 2);
  TEST_SEARCH ("$|(c$|(a|b)$)", "x", 0, 1);
  TEST_SEARCH ("$|(c$|(a|b)$)", "xc", 0, 2);
  TEST_SEARCH ("$|(c$|(a|b)$)", "xa", 0, 2);
  TEST_SEARCH ("$|(c$|(a|b)$)", "xb", 0, 2);

  re_set_syntax (0);
  test_match ("[^\n]", "a");
  test_match ("[^a]", "\n");

  TEST_SEARCH ("^a", "b\na", 0, 3);
  TEST_SEARCH ("b$", "b\na", 0, 3);

  test_case_fold ("[!-`]", "A");
  test_case_fold ("[!-`]", "a");
  
  re_set_syntax (RE_CONTEXT_INDEP_OPS | RE_NO_BK_VBAR | RE_NO_BK_PARENS 
                 | RE_NO_BK_BRACES | RE_INTERVALS);
  valid_nonposix_pattern ("()^a");
  valid_nonposix_pattern ("()\\1^a");

  /* Per Cederqvist (cedar@lysator.liu.se) bug.  */

  re_set_syntax (RE_SYNTAX_EMACS);

  /* One `a' before the \n and 638 a's after it.  */
  test_search_return (0, "\\(.*\\)\n\\(\\(.\\|\n\\)*\\)$", "a\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

  /* No a's before the \n and 639 a's after it.  */
  test_search_return (0, "\\(.*\\)\n\\(\\(.\\|\n\\)*\\)$", "\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

  /* One `a' before the \n and 639 a's after it.  */
  test_search_return (0, "\\(.*\\)\n\\(\\(.\\|\n\\)*\\)$", "a\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

  /* No a's before the \n and 640 a's after it.  */
  test_search_return (0, "\\(.*\\)\n\\(\\(.\\|\n\\)*\\)$", "\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

  re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
  TEST_SEARCH ("^(^a)", "ab", 0, 2);
  TEST_SEARCH ("(a$)$", "ba", 0, 2);
  test_match ("a|$b", "$b");
  
  /* Mike's curiosity item.  */
  re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
  test_all_registers ("(foo|foobar)(foo|bar)*\\1(foo|bar)*",
  		      "foobarfoobar", "",
    0, 12,  0, 3,  3, 6,  9, 12,  -1, -1,   -1, -1,   -1, -1,   -1, -1,  
    -1, -1,   -1, -1);

  /* Another one from Mike.  */
  test_match ("(foo|foobarfoo)(bar)*", "foobarfoo");
  
  /* And another.  */
  test_match("(foo|foobar)(bar|barfoo)?\\1", "foobarfoobar");
  
  re_set_syntax (RE_NO_BK_PARENS | RE_INTERVALS | RE_NO_BK_VBAR
                 | RE_NO_BK_BRACES);  /* xx get new ones from ext.*/
  test_match ("((a{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)*", "bb");
  test_all_registers ("((a{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)*", "", "bb", 
    0, 2, 1, 2, -1, -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1);

  test_match ("((a+?*{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)", "b");
  test_all_registers ("((a+?*{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)", "", "b",
    0, 1, 0, 1, -1, -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1);

						/* Valid anchoring.  */
          /* See generic_test.c and extended_test.c for more search
             tests. xx Not sure all these tests are represented in the
             search tests.  */
          
  re_set_syntax (RE_NO_BK_PARENS | RE_NO_BK_VBAR);
  valid_nonposix_pattern 
    ("(((((((((((((((((((((((((((((((((^a)))))))))))))))))))))))))))))))))");
  valid_nonposix_pattern 
    ("(((((((((((((((((((((((((((((((((a$)))))))))))))))))))))))))))))))))");
  valid_nonposix_pattern ("\\b\\B\\<\\>\\`\\'^a");
  valid_nonposix_pattern ("a$\\b\\B\\<\\>\\`\\'");
  valid_nonposix_pattern ("(^a)");
  valid_nonposix_pattern ("(a$)");
  valid_nonposix_pattern ("(^a)b");
  valid_nonposix_pattern ("b(a$)");
  valid_nonposix_pattern ("(^a|^b)c");
  valid_nonposix_pattern ("c(a$|b$)");
  valid_nonposix_pattern ("(^a|^b)|^c");
  valid_nonposix_pattern ("(a$|b$)|c$");
  valid_nonposix_pattern ("^c|(^a|^b)");
  valid_nonposix_pattern ("c$|(a$|b$)");
  valid_nonposix_pattern ("(^a|^b)c|^d");
  valid_nonposix_pattern ("c(a$|b$)|d$");
  valid_nonposix_pattern ("(((^a|^b))c|^d)e");
  valid_nonposix_pattern ("(c((a|b))|d)e$");
  valid_nonposix_pattern ("^d(c|e((a|b)))");
  valid_nonposix_pattern ("d(c$|e((a$|b$)))");
  valid_nonposix_pattern ("(((^a|^b))c)|^de");
  valid_nonposix_pattern ("(((a|b))c$)|de$");

  valid_nonposix_pattern ("((a$)$)$");
  valid_nonposix_pattern ("^(^(^a))");

  valid_nonposix_pattern ("^de|^(c((a|b)))");
  valid_nonposix_pattern ("^de|(^c((a|b)))");
  valid_nonposix_pattern ("de$|(c((a|b)$))");
  valid_nonposix_pattern ("de$|(c((a|b))$)");
  valid_nonposix_pattern ("de$|(c((a|b)))$");

  valid_nonposix_pattern ("^a(b|c)|^d");
  valid_nonposix_pattern ("a(b$|c$)|d$");
  valid_nonposix_pattern ("^d|^a(b|c)");
  valid_nonposix_pattern ("d$|a(b$|c$)");
  valid_nonposix_pattern ("^d|^(b|c)a");
  valid_nonposix_pattern ("d$|(b|c)a$");
  valid_nonposix_pattern ("^(a)(b|c)|^d");
  valid_nonposix_pattern ("(a)(b|c)$|d$");
  valid_nonposix_pattern ("(^a)(b|c)|^d");
  valid_nonposix_pattern ("(a)(b$|c$)|d$");
  valid_nonposix_pattern ("^d|^(b|c)(a)");
  valid_nonposix_pattern ("d$|(b|c)(a)$");
  valid_nonposix_pattern ("^d|(^b|^c)(a)");
  valid_nonposix_pattern ("d$|(b|c)(a$)");
  valid_nonposix_pattern ("^d|^(a)(b|c)");
  valid_nonposix_pattern ("^d|(^a)(b|c)");
  valid_nonposix_pattern ("d$|(a)(b$|c$)");
  valid_nonposix_pattern ("((^a|^b)|^c)|^d");
  valid_nonposix_pattern ("d$|(c$|(a$|b$))");


  /* Tests shouldn't match.  */
  test_should_match = false;

  /* Test that RE_CONTEXT_INVALID_OPS has precedence over
     RE_CONTEXT_INDEP_OPS.  */

  re_set_syntax (RE_CONTEXT_INDEP_OPS | RE_CONTEXT_INVALID_OPS
                 | RE_NO_BK_VBAR | RE_NO_BK_PARENS 
                 | RE_NO_BK_BRACES | RE_INTERVALS);
  INVALID_PATTERN ("*");
  INVALID_PATTERN ("^*");
  INVALID_PATTERN ("a|*");
  INVALID_PATTERN ("(*)");

  INVALID_PATTERN ("^+");
  INVALID_PATTERN ("+");
  INVALID_PATTERN ("a|+");
  INVALID_PATTERN ("(+)");

  INVALID_PATTERN ("^?");
  INVALID_PATTERN ("?");
  INVALID_PATTERN ("a|?");
  INVALID_PATTERN ("(?)");

  INVALID_PATTERN ("^{1}");
  INVALID_PATTERN ("{1}");
  INVALID_PATTERN ("a|{1}");
  INVALID_PATTERN ("({1})");

#if 0
  /* No longer have this syntax option -- POSIX says empty alternatives
     are undefined as of draft 11.2.  */

  /* You can't have empty alternatives if RE_NO_EMPTY_ALTS is set.  */
  
  re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS | RE_NO_EMPTY_ALTS);
  
  INVALID_PATTERN ("|");
  INVALID_PATTERN ("^|a");
  INVALID_PATTERN ("a|");
  INVALID_PATTERN ("a||");
  INVALID_PATTERN ("a||b");
  INVALID_PATTERN ("(|a)");
  INVALID_PATTERN ("(a|)");
  INVALID_PATTERN ("(a|)");


  /* Test above with `\(' and `\)'.  */
  re_set_syntax (RE_NO_BK_VBAR | RE_NO_EMPTY_ALTS);
  INVALID_PATTERN ("\\(|a\\)");
  INVALID_PATTERN ("\\(a|\\)");

  re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS | RE_NO_EMPTY_ALTS);
  INVALID_PATTERN ("(|)()$|d$");
#endif

  /* Test grouping.  */
  test_match ("()", "a");			

  /* Test backslashed intervals that are CONTEXTly invalid if have
     nothing on which to operate.  */

  re_set_syntax (RE_INTERVALS | RE_CONTEXT_INVALID_OPS);
  INVALID_PATTERN ("\\{1\\}");

  re_set_syntax (0);
  test_match ("z-a", "a");

  re_set_syntax (RE_BK_PLUS_QM);
  INVALID_PATTERN ("a*\\");
  
  re_set_syntax (0);
  INVALID_PATTERN ("a*\\");
  
  re_set_syntax (RE_BACKSLASH_ESCAPE_IN_LISTS);
  INVALID_PATTERN ("[\\");
  
#if 0
  /* Empty groups are always ok now.  (13 Sep 92)  */
  re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS | RE_NO_EMPTY_GROUPS);
  INVALID_PATTERN ("(|)()$|d$");
#endif

  printf ("\nFinished non-POSIX tests.\n");
}


\f
/*
Local variables:
make-backup-files: t
version-control: t
trim-versions-without-asking: nil
End:
*/
Commit	Line	Data
78ed81a3	1	/* other.c: test (not exhaustively) non-POSIX regular expressions. */
	2
	3	#include "test.h"
	4
	5	void
	6	test_others ()
	7	{
	8	struct re_registers regs;
	9
	10	printf ("\nStarting non-POSIX tests.\n");
	11	t = other_test;
	12
	13	test_should_match = true;
	14
	15	/* The big question: does the group participate in the match, or match
	16	the empty string? */
	17	re_set_syntax (RE_NO_BK_PARENS);
	18	test_match ("(a)ab", "ab");
	19	TEST_REGISTERS ("(a)ab", "ab", 0, 2, 0, 0, -1, -1);
	20	test_match ("(a)", "");
	21	TEST_REGISTERS ("(a)ab", "ab", 0, 0, 0, 0, -1, -1);
	22
	23	/* This tests finding the highest and lowest active registers. */
	24	test_match ("(a(b)c(d(e)f)g)h(i(j)k(l(m)n)o)\\1\\2\\3\\4\\5\\6\\7\\8",
	25	"abcdefghijklmnoabcdefgbdefeijklmnojlmnm");
	26
	27	/* Test that \< and \> match at the beginning and end of the string. */
	28	test_match ("\\<abc\\>", "abc");
	29
	30	/* May as well test \` and \' while we're at it. */
	31	test_match ("\\`abc\\'", "abc");
	32
	33	#if 0
	34	/* Test backreferencing and the fastmap -- which doesn't work. */
	35	test_fastmap ("(a)*\\1", "a", 0, 0);
	36	#endif
	37
	38	/* But at least we shouldn't search improperly. */
	39	test_search_return (-1, "(a)\\1", "");
	40
	41	re_set_syntax (RE_SYNTAX_EMACS);
	42
	43	MATCH_SELF("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
	44	MATCH_SELF ("a^");
	45	MATCH_SELF ("a^b");
	46	MATCH_SELF ("$a");
	47	MATCH_SELF ("a$b");
	48
	49	re_set_syntax (RE_BACKSLASH_ESCAPE_IN_LISTS);
	50	test_match ("[\\^a]", "a");
	51	test_match ("[\\^a]", "^");
	52
	53	/* These op characters should be ordinary if RE_CONTEXT_INVALID_OPS
	54	isn't set. */
	55	re_set_syntax (RE_NO_BK_VBAR \| RE_NO_BK_BRACES \| RE_INTERVALS
	56	\| RE_NO_BK_PARENS);
	57	MATCH_SELF ("*");
	58	test_match ("a\|", "");
	59	test_match ("()", "");
	60
	61	MATCH_SELF ("+");
	62	test_match ("a\|+", "+");
	63	test_match ("(+)", "+");
	64
65	MATCH_SELF ("?");
66	test_match ("a\|?", "?");
67	test_match ("(?)", "?");
68
69	MATCH_SELF ("{1}");
70	test_match ("a\|{1}", "a");
71	test_match ("a\|{1}", "{1}");
72	test_match ("({1})", "{1}");
73
74	test_match ("\\{", "{");
75
76
77	re_set_syntax (RE_LIMITED_OPS);
78	MATCH_SELF ("\|");
79	MATCH_SELF ("a\|");
80	MATCH_SELF ("a\|");
81	MATCH_SELF ("a\|\|");
82	MATCH_SELF ("a\|\|");
83	MATCH_SELF ("(\|)");
84
85	re_set_syntax (RE_SYNTAX_EMACS);
86	TEST_SEARCH ("^a", "b\na", 0, 3);
87	TEST_SEARCH ("b$", "b\na", 0, 3);
88
89	#if 0
90	/* Newline is no longer special for anchors (16 Sep 92). --karl */
91	test_match_2 ("a\n^b", "a", "\nb");
92	test_match_2 ("a$\nb", "a\n", "b");
93	#endif
94
95	/* Test grouping. */
96	re_set_syntax (RE_NO_BK_PARENS);
97
98	test_match ("()", "");
99	test_fastmap ("()", "", 0, 0);
100	TEST_REGISTERS ("()", "", 0, 0, 0, 0, -1, -1);
101
102	test_match ("((((((((()))))))))", "");
103	test_fastmap ("((((((((()))))))))", "", 0, 0);
104	test_match ("a()b", "ab");
105	TEST_REGISTERS ("a()b", "ab", 0, 2, 1, 1, -1, -1);
106
107	test_match ("(((((((((())))))))))", "");
108	test_fastmap ("(((((((((())))))))))", "", 0, 0);
109
110	test_match ("()*", "");
111	TEST_REGISTERS ("()", "", 0, 0, 0, 0, -1, -1); / empty string */
112	test_match ("(())*", "");
113
114	re_set_syntax (RE_CONTEXT_INDEP_OPS);
115	test_match ("*", "");
116
117	re_set_syntax (RE_INTERVALS \| RE_CONTEXT_INDEP_OPS \| RE_NO_BK_BRACES);
118	test_match ("{1}", ""); /* Should remain an interval. */
119	MATCH_SELF ("{1"); /* Not a valid interval. */
120
121	re_set_syntax (RE_NEWLINE_ALT);
122	test_match ("a\nb", "a");
123	test_match ("a\nb", "b");
124
125	re_set_syntax (RE_NO_BK_VBAR \| RE_NO_BK_PARENS);
126	test_match ("^a", "a");
127	test_match ("(^a)", "a");
128	test_match ("(a\|^b)", "b");
129	test_match ("a$", "a");
130	test_match ("(a$)", "a");
131	test_match ("a$\|b", "a");
132
133	/* You should be able to have empty alternatives if RE_NO_EMPTY_ALTS
134	isn't set. */
135	re_set_syntax (RE_NO_BK_VBAR \| RE_NO_BK_PARENS);
136
137	test_match ("\|", "");
138	test_match ("^\|a", "");
139	test_match ("^\|a", "a");
140	test_match ("a\|", "");
141	test_match ("a\|", "a");
142	test_match ("a\|$", "");
143	test_match ("a\|$", "a");
144	test_match ("a\|\|b", "a");
145	test_match ("a\|\|b", "");
146	test_match ("a\|\|b", "b");
147	test_match ("(\|a)", "");
148	test_match ("(\|a)", "a");
149	test_match ("(a\|)", "");
150	test_match ("(a\|)", "a");
151
152	TEST_SEARCH ("a\|$", "xa", 0, 2);
153	TEST_SEARCH ("a\|$", "x", 0, 1);
154	TEST_SEARCH ("$\|b", "x", 0, 1);
155	TEST_SEARCH ("$\|b", "xb", 0, 2);
156	TEST_SEARCH ("c(a\|$)", "xca", 0, 3);
157	TEST_SEARCH ("c(a\|$)", "xc", 0, 2);
158	TEST_SEARCH ("c($\|b)", "xcb", 0, 3);
159	TEST_SEARCH ("c($\|b)", "xc", 0, 2);
160	TEST_SEARCH ("c($\|b$)", "xcb", 0, 3);
161	TEST_SEARCH ("c($\|b$)", "xc", 0, 2);
162	TEST_SEARCH ("c(a$\|$)", "xca", 0, 3);
163	TEST_SEARCH ("c(a$\|$)", "xc", 0, 2);
164	TEST_SEARCH ("(a$\|b$)\|$", "x", 0, 1);
165	TEST_SEARCH ("(a$\|b$)\|$", "xa", 0, 2);
166	TEST_SEARCH ("(a$\|b$)\|$", "xb", 0, 2);
167	TEST_SEARCH ("(a$\|$)\|c$", "x", 0, 1);
168	TEST_SEARCH ("(a$\|$)\|c$", "xa", 0, 2);
169	TEST_SEARCH ("(a$\|$)\|c$", "xc", 0, 2);
170	TEST_SEARCH ("($\|b$)\|c$", "x", 0, 1);
171	TEST_SEARCH ("($\|b$)\|c$", "xb", 0, 2);
172	TEST_SEARCH ("($\|b$)\|c$", "xc", 0, 2);
173	TEST_SEARCH ("c$\|(a$\|$)", "x", 0, 1);
174	TEST_SEARCH ("c$\|(a$\|$)", "xa", 0, 2);
175	TEST_SEARCH ("c$\|(a$\|$)", "xc", 0, 2);
176	TEST_SEARCH ("c$\|($\|b$)", "x", 0, 1);
177	TEST_SEARCH ("c$\|($\|b$)", "xb", 0, 2);
178	TEST_SEARCH ("c$\|($\|b$)", "xc", 0, 2);
179	TEST_SEARCH ("$\|(a$\|b$)", "x", 0, 1);
180	TEST_SEARCH ("$\|(a$\|b$)", "xa", 0, 2);
181	TEST_SEARCH ("$\|(a$\|b$)", "xb", 0, 2);
182	TEST_SEARCH ("c(a$\|b$)\|$", "x", 0, 1);
183	TEST_SEARCH ("c(a$\|b$)\|$", "xca", 0, 3);
184	TEST_SEARCH ("c(a$\|b$)\|$", "xcb", 0, 3);
185	TEST_SEARCH ("c(a$\|$)\|d$", "xc", 0, 2);
186	TEST_SEARCH ("c(a$\|$)\|d$", "xca", 0, 3);
187	TEST_SEARCH ("c(a$\|$)\|d$", "xd", 0, 2);
188	TEST_SEARCH ("c($\|b$)\|d$", "xc", 0, 2);
189	TEST_SEARCH ("c($\|b$)\|d$", "xcb", 0, 3);
190	TEST_SEARCH ("c($\|b$)\|d$", "xd", 0, 2);
191	TEST_SEARCH ("d(c$\|e((a$\|$)))", "xdc", 0, 3);
192	TEST_SEARCH ("d(c$\|e((a$\|$)))", "xde", 0, 3);
193	TEST_SEARCH ("d(c$\|e((a$\|$)))", "xdea", 0, 4);
194	TEST_SEARCH ("d(c$\|e(($\|b$)))", "xdc", 0, 3);
195	TEST_SEARCH ("d(c$\|e(($\|b$)))", "xde", 0, 3);
196	TEST_SEARCH ("d(c$\|e(($\|b$)))", "xdeb", 0, 4);
197	TEST_SEARCH ("d($\|e((a$\|b$)))", "xd", 0, 2);
198	TEST_SEARCH ("d($\|e((a$\|b$)))", "xdea", 0, 4);
199	TEST_SEARCH ("d($\|e((a$\|b$)))", "xdeb", 0, 4);
200	TEST_SEARCH ("a(b$\|c$)\|$", "x", 0, 1);
201	TEST_SEARCH ("a(b$\|c$)\|$", "xab", 0, 3);
202	TEST_SEARCH ("a(b$\|c$)\|$", "xac", 0, 3);
203	TEST_SEARCH ("a(b$\|$)\|d$", "xa", 0, 2);
204	TEST_SEARCH ("a(b$\|$)\|d$", "xab", 0, 3);
205	TEST_SEARCH ("a(b$\|$)\|d$", "xd", 0, 2);
206	TEST_SEARCH ("a($\|c$)\|d$", "xa", 0, 2);
207	TEST_SEARCH ("a($\|c$)\|d$", "xac", 0, 3);
208	TEST_SEARCH ("a($\|c$)\|d$", "xd", 0, 2);
209	TEST_SEARCH ("d$\|a(b$\|$)", "xd", 0, 2);
210	TEST_SEARCH ("d$\|a(b$\|$)", "xa", 0, 2);
211	TEST_SEARCH ("d$\|a(b$\|$)", "xab", 0, 3);
212	TEST_SEARCH ("d$\|a($\|c$)", "xd", 0, 2);
213	TEST_SEARCH ("d$\|a($\|c$)", "xa", 0, 2);
214	TEST_SEARCH ("d$\|a($\|c$)", "xac", 0, 3);
215	TEST_SEARCH ("$\|a(b$\|c$)", "x", 0, 1);
216	TEST_SEARCH ("$\|a(b$\|c$)", "xab", 0, 3);
217	TEST_SEARCH ("$\|a(b$\|c$)", "xac", 0, 3);
218	TEST_SEARCH ("(a)(b$\|c$)\|d$", "xab", 0, 3);
219	TEST_SEARCH ("(a)(b$\|c$)\|d$", "xac", 0, 3);
220	TEST_SEARCH ("(a)(b$\|c$)\|d$", "xd", 0, 2);
221	TEST_SEARCH ("(a)(b$\|$)\|d$", "xa", 0, 2);
222	TEST_SEARCH ("(a)(b$\|$)\|d$", "xab", 0, 3);
223	TEST_SEARCH ("(a)(b$\|$)\|d$", "xd", 0, 2);
224	TEST_SEARCH ("(a)($\|c$)\|d$", "xa", 0, 2);
225	TEST_SEARCH ("(a)($\|c$)\|d$", "xac", 0, 3);
226	TEST_SEARCH ("(a)($\|c$)\|d$", "xd", 0, 2);
227	TEST_SEARCH ("d$\|(a)(b$\|$)", "xd", 0, 2);
228	TEST_SEARCH ("d$\|(a)(b$\|$)", "xa", 0, 2);
229	TEST_SEARCH ("d$\|(a)(b$\|$)", "xab", 0, 3);
230	TEST_SEARCH ("d$\|(a)($\|c$)", "xd", 0, 2);
231	TEST_SEARCH ("d$\|(a)($\|c$)", "xa", 0, 2);
232	TEST_SEARCH ("d$\|(a)($\|c$)", "xac", 0, 3);
233	TEST_SEARCH ("$\|(a)(b$\|c$)", "x", 0, 1);
234	TEST_SEARCH ("$\|(a)(b$\|c$)", "xab", 0, 3);
235	TEST_SEARCH ("$\|(a)(b$\|c$)", "xac", 0, 3);
236	TEST_SEARCH ("d$\|(c$\|(a$\|$))", "x", 0, 1);
237	TEST_SEARCH ("d$\|(c$\|(a$\|$))", "xd", 0, 2);
238	TEST_SEARCH ("d$\|(c$\|(a$\|$))", "xc", 0, 2);
239	TEST_SEARCH ("d$\|(c$\|(a$\|$))", "xa", 0, 2);
240	TEST_SEARCH ("d$\|(c$\|($\|b$))", "x", 0, 1);
241	TEST_SEARCH ("d$\|(c$\|($\|b$))", "xd", 0, 2);
242	TEST_SEARCH ("d$\|(c$\|($\|b$))", "xc", 0, 2);
243	TEST_SEARCH ("d$\|(c$\|($\|b$))", "xb", 0, 2);
244	TEST_SEARCH ("d$\|($\|(a$\|b$))", "x", 0, 1);
245	TEST_SEARCH ("d$\|($\|(a$\|b$))", "xd", 0, 2);
246	TEST_SEARCH ("d$\|($\|(a$\|b$))", "xa", 0, 2);
247	TEST_SEARCH ("d$\|($\|(a$\|b$))", "xb", 0, 2);
248	TEST_SEARCH ("$\|(c$\|(a$\|b$))", "x", 0, 1);
249	TEST_SEARCH ("$\|(c$\|(a$\|b$))", "xc", 0, 2);
250	TEST_SEARCH ("$\|(c$\|(a$\|b$))", "xa", 0, 2);
251	TEST_SEARCH ("$\|(c$\|(a$\|b$))", "xb", 0, 2);
252	TEST_SEARCH ("d$\|c(a$\|$)", "xd", 0, 2);
253	TEST_SEARCH ("d$\|c(a$\|$)", "xc", 0, 2);
254	TEST_SEARCH ("d$\|c(a$\|$)", "xca", 0, 3);
255	TEST_SEARCH ("d$\|c($\|b$)", "xd", 0, 2);
256	TEST_SEARCH ("d$\|c($\|b$)", "xc", 0, 2);
257	TEST_SEARCH ("d$\|c($\|b$)", "xcb", 0, 3);
258	TEST_SEARCH ("$\|c(a$\|b$)", "x", 0, 1);
259	TEST_SEARCH ("$\|c(a$\|b$)", "xca", 0, 3);
260	TEST_SEARCH ("$\|c(a$\|b$)", "xcb", 0, 3);
261	TEST_SEARCH ("e(d$\|c((a$\|$)))", "xed", 0, 3);
262	TEST_SEARCH ("e(d$\|c((a$\|$)))", "xec", 0, 3);
263	TEST_SEARCH ("e(d$\|c((a$\|$)))", "xeca", 0, 3);
264	TEST_SEARCH ("e(d$\|c(($\|b$)))", "xed", 0, 3);
265	TEST_SEARCH ("e(d$\|c(($\|b$)))", "xec", 0, 3);
266	TEST_SEARCH ("e(d$\|c(($\|b$)))", "xecb", 0, 4);
267	TEST_SEARCH ("e($\|c((a$\|b$)))", "xe", 0, 2);
268	TEST_SEARCH ("e($\|c((a$\|b$)))", "xeca", 0, 4);
269	TEST_SEARCH ("e($\|c((a$\|b$)))", "xecb", 0, 4);
270	TEST_SEARCH ("ed$\|(c((a$\|$)))", "xed", 0, 3);
271	TEST_SEARCH ("ed$\|(c((a$\|$)))", "xc", 0, 2);
272	TEST_SEARCH ("ed$\|(c((a$\|$)))", "xca", 0, 3);
273	TEST_SEARCH ("ed$\|(c(($\|b$)))", "xed", 0, 3);
274	TEST_SEARCH ("ed$\|(c(($\|b$)))", "xc", 0, 2);
275	TEST_SEARCH ("ed$\|(c(($\|b$)))", "xcb", 0, 3);
276	TEST_SEARCH ("$\|(c((a$\|b$)))", "x", 0, 1);
277	TEST_SEARCH ("$\|(c((a$\|b$)))", "xca", 0, 3);
278	TEST_SEARCH ("$\|(c((a$\|b$)))", "xcb", 0, 3);
279	TEST_SEARCH ("d$\|($\|(a\|b)$)", "x", 0, 1);
280	TEST_SEARCH ("d$\|($\|(a\|b)$)", "xa", 0, 2);
281	TEST_SEARCH ("d$\|($\|(a\|b)$)", "xb", 0, 2);
282	TEST_SEARCH ("$\|(c$\|(a\|b)$)", "x", 0, 1);
283	TEST_SEARCH ("$\|(c$\|(a\|b)$)", "xc", 0, 2);
284	TEST_SEARCH ("$\|(c$\|(a\|b)$)", "xa", 0, 2);
285	TEST_SEARCH ("$\|(c$\|(a\|b)$)", "xb", 0, 2);
286
287	re_set_syntax (0);
288	test_match ("[^\n]", "a");
289	test_match ("[^a]", "\n");
290
291	TEST_SEARCH ("^a", "b\na", 0, 3);
292	TEST_SEARCH ("b$", "b\na", 0, 3);
293
294	test_case_fold ("[!-`]", "A");
295	test_case_fold ("[!-`]", "a");
296
297	re_set_syntax (RE_CONTEXT_INDEP_OPS \| RE_NO_BK_VBAR \| RE_NO_BK_PARENS
298	\| RE_NO_BK_BRACES \| RE_INTERVALS);
299	valid_nonposix_pattern ("()^a");
300	valid_nonposix_pattern ("()\\1^a");
301
302	/* Per Cederqvist (cedar@lysator.liu.se) bug. */
303
304	re_set_syntax (RE_SYNTAX_EMACS);
305
306	/* One `a' before the \n and 638 a's after it. */
307	test_search_return (0, "\\(.\\)\n\\(\\(.\\\|\n\\)\\)$", "a\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
308
309	/* No a's before the \n and 639 a's after it. */
310	test_search_return (0, "\\(.\\)\n\\(\\(.\\\|\n\\)\\)$", "\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
311
312	/* One `a' before the \n and 639 a's after it. */
313	test_search_return (0, "\\(.\\)\n\\(\\(.\\\|\n\\)\\)$", "a\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
314
315	/* No a's before the \n and 640 a's after it. */
316	test_search_return (0, "\\(.\\)\n\\(\\(.\\\|\n\\)\\)$", "\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
317
318	re_set_syntax (RE_NO_BK_VBAR \| RE_NO_BK_PARENS);
319	TEST_SEARCH ("^(^a)", "ab", 0, 2);
320	TEST_SEARCH ("(a$)$", "ba", 0, 2);
321	test_match ("a\|$b", "$b");
322
323	/* Mike's curiosity item. */
324	re_set_syntax (RE_NO_BK_VBAR \| RE_NO_BK_PARENS);
325	test_all_registers ("(foo\|foobar)(foo\|bar)\\1(foo\|bar)",
326	"foobarfoobar", "",
327	0, 12, 0, 3, 3, 6, 9, 12, -1, -1, -1, -1, -1, -1, -1, -1,
328	-1, -1, -1, -1);
329
330	/* Another one from Mike. */
331	test_match ("(foo\|foobarfoo)(bar)*", "foobarfoo");
332
333	/* And another. */
334	test_match("(foo\|foobar)(bar\|barfoo)?\\1", "foobarfoobar");
335
336	re_set_syntax (RE_NO_BK_PARENS \| RE_INTERVALS \| RE_NO_BK_VBAR
337	\| RE_NO_BK_BRACES); /* xx get new ones from ext.*/
338	test_match ("((a{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')\|b)*", "bb");
339	test_all_registers ("((a{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')\|b)*", "", "bb",
340	0, 2, 1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
341	-1, -1);
342
343	test_match ("((a+?*{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')\|b)", "b");
344	test_all_registers ("((a+?*{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')\|b)", "", "b",
345	0, 1, 0, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
346	-1, -1);
347
348	/* Valid anchoring. */
349	/* See generic_test.c and extended_test.c for more search
350	tests. xx Not sure all these tests are represented in the
351	search tests. */
352
353	re_set_syntax (RE_NO_BK_PARENS \| RE_NO_BK_VBAR);
354	valid_nonposix_pattern
355	("(((((((((((((((((((((((((((((((((^a)))))))))))))))))))))))))))))))))");
356	valid_nonposix_pattern
357	("(((((((((((((((((((((((((((((((((a$)))))))))))))))))))))))))))))))))");
358	valid_nonposix_pattern ("\\b\\B\\<\\>\\`\\'^a");
359	valid_nonposix_pattern ("a$\\b\\B\\<\\>\\`\\'");
360	valid_nonposix_pattern ("(^a)");
361	valid_nonposix_pattern ("(a$)");
362	valid_nonposix_pattern ("(^a)b");
363	valid_nonposix_pattern ("b(a$)");
364	valid_nonposix_pattern ("(^a\|^b)c");
365	valid_nonposix_pattern ("c(a$\|b$)");
366	valid_nonposix_pattern ("(^a\|^b)\|^c");
367	valid_nonposix_pattern ("(a$\|b$)\|c$");
368	valid_nonposix_pattern ("^c\|(^a\|^b)");
369	valid_nonposix_pattern ("c$\|(a$\|b$)");
370	valid_nonposix_pattern ("(^a\|^b)c\|^d");
371	valid_nonposix_pattern ("c(a$\|b$)\|d$");
372	valid_nonposix_pattern ("(((^a\|^b))c\|^d)e");
373	valid_nonposix_pattern ("(c((a\|b))\|d)e$");
374	valid_nonposix_pattern ("^d(c\|e((a\|b)))");
375	valid_nonposix_pattern ("d(c$\|e((a$\|b$)))");
376	valid_nonposix_pattern ("(((^a\|^b))c)\|^de");
377	valid_nonposix_pattern ("(((a\|b))c$)\|de$");
378
379	valid_nonposix_pattern ("((a$)$)$");
380	valid_nonposix_pattern ("^(^(^a))");
381
382	valid_nonposix_pattern ("^de\|^(c((a\|b)))");
383	valid_nonposix_pattern ("^de\|(^c((a\|b)))");
384	valid_nonposix_pattern ("de$\|(c((a\|b)$))");
385	valid_nonposix_pattern ("de$\|(c((a\|b))$)");
386	valid_nonposix_pattern ("de$\|(c((a\|b)))$");
387
388	valid_nonposix_pattern ("^a(b\|c)\|^d");
389	valid_nonposix_pattern ("a(b$\|c$)\|d$");
390	valid_nonposix_pattern ("^d\|^a(b\|c)");
391	valid_nonposix_pattern ("d$\|a(b$\|c$)");
392	valid_nonposix_pattern ("^d\|^(b\|c)a");
393	valid_nonposix_pattern ("d$\|(b\|c)a$");
394	valid_nonposix_pattern ("^(a)(b\|c)\|^d");
395	valid_nonposix_pattern ("(a)(b\|c)$\|d$");
396	valid_nonposix_pattern ("(^a)(b\|c)\|^d");
397	valid_nonposix_pattern ("(a)(b$\|c$)\|d$");
398	valid_nonposix_pattern ("^d\|^(b\|c)(a)");
399	valid_nonposix_pattern ("d$\|(b\|c)(a)$");
400	valid_nonposix_pattern ("^d\|(^b\|^c)(a)");
401	valid_nonposix_pattern ("d$\|(b\|c)(a$)");
402	valid_nonposix_pattern ("^d\|^(a)(b\|c)");
403	valid_nonposix_pattern ("^d\|(^a)(b\|c)");
404	valid_nonposix_pattern ("d$\|(a)(b$\|c$)");
405	valid_nonposix_pattern ("((^a\|^b)\|^c)\|^d");
406	valid_nonposix_pattern ("d$\|(c$\|(a$\|b$))");
407
408
409	/* Tests shouldn't match. */
410	test_should_match = false;
411
412	/* Test that RE_CONTEXT_INVALID_OPS has precedence over
413	RE_CONTEXT_INDEP_OPS. */
414
415	re_set_syntax (RE_CONTEXT_INDEP_OPS \| RE_CONTEXT_INVALID_OPS
416	\| RE_NO_BK_VBAR \| RE_NO_BK_PARENS
417	\| RE_NO_BK_BRACES \| RE_INTERVALS);
418	INVALID_PATTERN ("*");
419	INVALID_PATTERN ("^*");
420	INVALID_PATTERN ("a\|*");
421	INVALID_PATTERN ("(*)");
422
423	INVALID_PATTERN ("^+");
424	INVALID_PATTERN ("+");
425	INVALID_PATTERN ("a\|+");
426	INVALID_PATTERN ("(+)");
427
428	INVALID_PATTERN ("^?");
429	INVALID_PATTERN ("?");
430	INVALID_PATTERN ("a\|?");
431	INVALID_PATTERN ("(?)");
432
433	INVALID_PATTERN ("^{1}");
434	INVALID_PATTERN ("{1}");
435	INVALID_PATTERN ("a\|{1}");
436	INVALID_PATTERN ("({1})");
437
438	#if 0
439	/* No longer have this syntax option -- POSIX says empty alternatives
440	are undefined as of draft 11.2. */
441
442	/* You can't have empty alternatives if RE_NO_EMPTY_ALTS is set. */
443
444	re_set_syntax (RE_NO_BK_VBAR \| RE_NO_BK_PARENS \| RE_NO_EMPTY_ALTS);
445
446	INVALID_PATTERN ("\|");
447	INVALID_PATTERN ("^\|a");
448	INVALID_PATTERN ("a\|");
449	INVALID_PATTERN ("a\|\|");
450	INVALID_PATTERN ("a\|\|b");
451	INVALID_PATTERN ("(\|a)");
452	INVALID_PATTERN ("(a\|)");
453	INVALID_PATTERN ("(a\|)");
454
455
456	/* Test above with `\(' and `\)'. */
457	re_set_syntax (RE_NO_BK_VBAR \| RE_NO_EMPTY_ALTS);
458	INVALID_PATTERN ("\\(\|a\\)");
459	INVALID_PATTERN ("\\(a\|\\)");
460
461	re_set_syntax (RE_NO_BK_VBAR \| RE_NO_BK_PARENS \| RE_NO_EMPTY_ALTS);
462	INVALID_PATTERN ("(\|)()$\|d$");
463	#endif
464
465	/* Test grouping. */
466	test_match ("()", "a");
467
468	/* Test backslashed intervals that are CONTEXTly invalid if have
469	nothing on which to operate. */
470
471	re_set_syntax (RE_INTERVALS \| RE_CONTEXT_INVALID_OPS);
472	INVALID_PATTERN ("\\{1\\}");
473
474	re_set_syntax (0);
475	test_match ("z-a", "a");
476
477	re_set_syntax (RE_BK_PLUS_QM);
478	INVALID_PATTERN ("a*\\");
479
480	re_set_syntax (0);
481	INVALID_PATTERN ("a*\\");
482
483	re_set_syntax (RE_BACKSLASH_ESCAPE_IN_LISTS);
484	INVALID_PATTERN ("[\\");
485
486	#if 0
487	/* Empty groups are always ok now. (13 Sep 92) */
488	re_set_syntax (RE_NO_BK_VBAR \| RE_NO_BK_PARENS \| RE_NO_EMPTY_GROUPS);
489	INVALID_PATTERN ("(\|)()$\|d$");
490	#endif
491
492	printf ("\nFinished non-POSIX tests.\n");
493	}
494
495
496	\f
497	/*
498	Local variables:
499	make-backup-files: t
500	version-control: t
501	trim-versions-without-asking: nil
502	End:
503	*/