gnu/lib/libregex/test/test.c

   1 /* test.c: testing routines for regex.c.  */
   2
   3 #include <assert.h>
   4
   5 #ifdef STDC_HEADERS
   6 #include <stdlib.h>
   7 #else
   8 char *malloc ();
   9 char *realloc ();
  10 #endif
  11
  12 /* Just to be complete, we make both the system V/ANSI and the BSD
  13    versions of the string functions available.  */
  14 #if USG || STDC_HEADERS
  15 #include <string.h>
  16 #define index strchr
  17 #define rindex strrchr
  18 #define bcmp(s1, s2, len) memcmp ((s1), (s2), (len))
  19 #define bcopy(from, to, len) memcpy ((to), (from), (len))
  20 #define bzero(s, len) memset ((s), 0, (len))
  21 #else
  22 #include <strings.h>
  23 #define strchr index
  24 #define strrchr rindex
  25 #ifndef NEED_MEMORY_H
  26 #define memcmp(s1, s2, n) bcmp ((s1), (s2), (n))
  27 #define memcpy(to, from, len) bcopy ((from), (to), (len))
  28 #endif
  29 extern char *strtok ();
  30 extern char *strstr ();
  31 #endif /* not USG or STDC_HEADERS */
  32
  33 /* SunOS 4.1 declares memchr in <memory.h>, not <string.h>.  I don't
  34    understand why.  */
  35 #if NEED_MEMORY_H
  36 #include <memory.h>
  37 #endif
  38
  39 #include "test.h"
  40
  41 #define BYTEWIDTH 8
  42
  43 extern void print_partial_compiled_pattern ();
  44 extern void print_compiled_pattern ();
  45 extern void print_double_string ();
  46
  47 /* If nonzero, the results of every test are displayed.  */
  48 boolean verbose = false;
  49
  50 /* If nonzero, don't do register testing.  */
  51 boolean omit_register_tests = true;
  52
  53 /* Says whether the current test should match or fail to match.  */
  54 boolean test_should_match;
  55
  56
  57 static void
  58 set_all_registers (start0, end0, start1, end1,
  59                    start2, end2, start3, end3,
  60                    start4, end4, start5, end5,
  61                    start6, end6, start7, end7,
  62                    start8, end8, start9, end9, regs)
  63
  64   int start0; int end0; int start1; int end1;
  65   int start2; int end2; int start3; int end3;
  66   int start4; int end4; int start5; int end5;
  67   int start6; int end6; int start7; int end7;
  68   int start8; int end8; int start9; int end9;
  69   struct re_registers *regs;
  70
  71   {
  72     unsigned r;
  73
  74     regs->start[0] = start0;   regs->end[0] = end0;
  75     regs->start[1] = start1;   regs->end[1] = end1;
  76     regs->start[2] = start2;   regs->end[2] = end2;
  77     regs->start[3] = start3;   regs->end[3] = end3;
  78     regs->start[4] = start4;   regs->end[4] = end4;
  79     regs->start[5] = start5;   regs->end[5] = end5;
  80     regs->start[6] = start6;   regs->end[6] = end6;
  81     regs->start[7] = start7;   regs->end[7] = end7;
  82     regs->start[8] = start8;   regs->end[8] = end8;
  83     regs->start[9] = start9;   regs->end[9] = end9;
  84     for (r = 10; r < regs->num_regs; r++)
  85       {
  86         regs->start[r] = -1;
  87         regs->end[r] = -1;
  88       }
  89   }
  90
  91
  92
  93 /* Return the concatenation of S1 and S2.  This would be a prime place
  94    to use varargs.  */
  95
  96 char *
  97 concat (s1, s2)
  98     char *s1;
  99     char *s2;
 100 {
 101   char *answer = xmalloc (strlen (s1) + strlen (s2) + 1);
 102
 103   strcpy (answer, s1);
 104   strcat (answer, s2);
 105
 106   return answer;
 107 }
 108
 109
 110 #define OK_TO_SEARCH  (nonconst_buf.fastmap_accurate && (str1 || str2))
 111
 112 /* We ignore the `can_be_null' argument.  Should just be removed.  */
 113
 114 void
 115 general_test (pattern_should_be_valid, match_whole_string,
 116               pat, str1, str2, start, range, end, correct_fastmap,
 117               correct_regs, can_be_null)
 118     unsigned pattern_should_be_valid;
 119     unsigned match_whole_string;
 120     const char *pat;
 121     char *str1, *str2;
 122     int start, range, end;
 123     char *correct_fastmap;
 124     struct re_registers *correct_regs;
 125     int can_be_null;
 126 {
 127   struct re_pattern_buffer nonconst_buf;
 128   struct re_pattern_buffer old_buf;
 129   struct re_registers regs;
 130   const char *r;
 131   char fastmap[1 << BYTEWIDTH];
 132   unsigned *regs_correct = NULL;
 133   unsigned all_regs_correct = 1;
 134   boolean fastmap_internal_error = false;
 135   unsigned match = 0;
 136   unsigned match_1 = 0;
 137   unsigned match_2 = 0;
 138   unsigned invalid_pattern = 0;
 139   boolean internal_error_1 = false;
 140   boolean internal_error_2 = false;
 141
 142
 143   nonconst_buf.allocated = 8;
 144   nonconst_buf.buffer = xmalloc (nonconst_buf.allocated);
 145   nonconst_buf.fastmap = fastmap;
 146   nonconst_buf.translate = 0;
 147
 148   assert (pat != NULL);
 149   r = re_compile_pattern (pat, strlen (pat), &nonconst_buf);
 150
 151   /* Kludge: if we are doing POSIX testing, we really should have
 152      called regcomp, not re_compile_pattern.  As it happens, the only
 153      way in which it matters is that re_compile_pattern sets the
 154      newline/anchor field for matching (part of what happens when
 155      REG_NEWLINE is given to regcomp).  We have to undo that for POSIX
 156      matching.  */
 157   if (t == posix_basic_test || t == posix_extended_test)
 158     nonconst_buf.newline_anchor = 0;
 159
 160   invalid_pattern = r != NULL;
 161
 162   if (!r)
 163     {
 164       int r;
 165
 166       if (!pattern_should_be_valid)
 167         printf ("\nShould have been an invalid pattern but wasn't:\n");
 168       else
 169         {
 170           fastmap_internal_error = (re_compile_fastmap (&nonconst_buf) == -2);
 171
 172           if (correct_fastmap)
 173             nonconst_buf.fastmap_accurate =
 174               memcmp (nonconst_buf.fastmap, correct_fastmap, 1 << BYTEWIDTH)
 175               == 0;
 176
 177           if (OK_TO_SEARCH)
 178            {
 179               old_buf = nonconst_buf;
 180               old_buf.buffer = (unsigned char *) xmalloc (nonconst_buf.used);
 181               memcpy (old_buf.buffer, nonconst_buf.buffer, nonconst_buf.used);
 182
 183               /* If only one string is null, call re_match or re_search,
 184                 which is what the user would probably do.  */
 185               if (str1 == NULL && str2 != NULL
 186                   || str2 == NULL && str1 != NULL)
 187                 {
 188                   char *the_str = str1 == NULL ? str2 : str1;
 189
 190                   match_1
 191                     = match_whole_string
 192                       ? (r = re_match (&nonconst_buf, the_str,
 193                                        strlen (the_str), start, &regs))
 194                         == strlen (the_str)
 195                       : (r = re_search (&nonconst_buf,
 196                                         the_str, strlen (the_str),
 197                                         start, range, &regs))
 198                         >= 0;
 199
 200                   if (r == -2)
 201                    internal_error_1 = true;
 202                  }
 203               else
 204                 match_1 = 1;
 205
 206               /* Also call with re_match_2 or re_search_2, as they might
 207                  do this.  (Also can check calling with either string1
 208                  or string2 or both null.)  */
 209               if (match_whole_string)
 210                 {
 211                   r = re_match_2 (&nonconst_buf,
 212                                   str1, SAFE_STRLEN (str1),
 213                                   str2, SAFE_STRLEN (str2),
 214                                   start, &regs, end);
 215                   match_2 = r == SAFE_STRLEN (str1) + SAFE_STRLEN (str2);
 216                 }
 217               else
 218                 {
 219                   r = re_search_2 (&nonconst_buf,
 220                                    str1, SAFE_STRLEN (str1),
 221                                    str2, SAFE_STRLEN (str2),
 222                                    start, range, &regs, end);
 223                   match_2 = r >= 0;
 224                 }
 225
 226               if (r == -2)
 227                internal_error_2 = true;
 228
 229               match = match_1 & match_2;
 230
 231               if (correct_regs)
 232                 {
 233                   unsigned reg;
 234                   if (regs_correct != NULL)
 235                     free (regs_correct);
 236
 237                   regs_correct
 238                     = (unsigned *) xmalloc (regs.num_regs * sizeof (unsigned));
 239
 240                   for (reg = 0;
 241                        reg < regs.num_regs && reg < correct_regs->num_regs;
 242                        reg++)
 243                     {
 244                       regs_correct[reg]
 245                         = (regs.start[reg] == correct_regs->start[reg]
 246                            && regs.end[reg] == correct_regs->end[reg])
 247 #ifdef EMPTY_REGS_CONFUSED
 248                           /* There is confusion in the standard about
 249                              the registers in some patterns which can
 250                              match either the empty string or not match.
 251                              For example, in `((a*))*' against the empty
 252                              string, the two registers can either match
 253                              the empty string (be 0/0), or not match
 254                              (because of the outer *) (be -1/-1).  (Or
 255                              one can do one and one can do the other.)  */
 256                           || (regs.start[reg] == -1 && regs.end[reg] == -1
 257                               && correct_regs->start[reg]
 258                                  == correct_regs->end[reg])
 259 #endif
 260                           ;
 261
 262                       all_regs_correct &= regs_correct[reg];
 263                     }
 264                 }
 265            } /* OK_TO_SEARCH  */
 266         }
 267     }
 268
 269   if (fastmap_internal_error)
 270     printf ("\n\nInternal error in re_compile_fastmap:");
 271
 272   if (internal_error_1)
 273     {
 274       if (!fastmap_internal_error)
 275         printf ("\n");
 276
 277       printf ("\nInternal error in re_match or re_search:");
 278     }
 279
 280   if (internal_error_2)
 281     {
 282       if (!internal_error_1)
 283         printf ("\n");
 284
 285       printf ("\nInternal error in re_match_2 or re_search_2:");
 286     }
 287
 288   if ((OK_TO_SEARCH && ((match && !test_should_match)
 289                        || (!match && test_should_match))
 290                        || (correct_regs && !all_regs_correct))
 291       || !nonconst_buf.fastmap_accurate
 292       || invalid_pattern
 293       || !pattern_should_be_valid
 294       || internal_error_1 || internal_error_2
 295       || verbose)
 296     {
 297       if (OK_TO_SEARCH && match && !test_should_match)
 298         {
 299           printf ("\n\nMatched but shouldn't have:\n");
 300           if (match_1)
 301             printf ("The single match/search succeeded.\n");
 302
 303           if (match_2)
 304             printf ("The double match/search succeeded.\n");
 305         }
 306       else if (OK_TO_SEARCH && !match && test_should_match)
 307         {
 308           printf ("\n\nDidn't match but should have:\n");
 309           if (!match_1)
 310             printf ("The single match/search failed.\n");
 311
 312           if (!match_2)
 313             printf ("The double match/search failed.\n");
 314         }
 315       else if (invalid_pattern && pattern_should_be_valid)
 316         printf ("\n\nInvalid pattern (%s):\n", r);
 317       else if (!nonconst_buf.fastmap_accurate && pattern_should_be_valid)
 318         printf ("\n\nIncorrect fastmap:\n");
 319       else if (OK_TO_SEARCH && correct_regs && !all_regs_correct)
 320         printf ("\n\nNot all registers were correct:\n");
 321       else if (verbose)
 322         printf ("\n\nTest was OK:\n");
 323
 324
 325       if ((!(invalid_pattern && !pattern_should_be_valid)) || verbose)
 326         printf ("  Pattern:  `%s'.\n", pat);
 327
 328       if (pattern_should_be_valid || verbose
 329           || internal_error_1 || internal_error_2)
 330         {
 331           printf("  Strings: ");
 332           printf ("`%s' and ", str1 == NULL ? "NULL" : str1);
 333           printf ("`%s'.\n", str2  == NULL ? "NULL" : str2);
 334
 335           if ((OK_TO_SEARCH || verbose || internal_error_1 || internal_error_2)
 336               && !invalid_pattern)
 337             {
 338               if (memcmp (old_buf.buffer, nonconst_buf.buffer,
 339                           nonconst_buf.used) != 0
 340                   && !invalid_pattern)
 341                 {
 342                   printf("  (%s)\n", r ? r : "Valid regular expression");
 343                   printf ("\n  Compiled pattern before matching: ");
 344                   print_compiled_pattern (&old_buf);
 345                   printf ("\n  Compiled pattern after matching:  ");
 346                 }
 347               else
 348                 printf ("\n  Compiled pattern:   ");
 349
 350               print_compiled_pattern (&nonconst_buf);
 351             }
 352
 353           if (correct_fastmap && (!nonconst_buf.fastmap_accurate || verbose))
 354             {
 355               printf ("\n  The fastmap should have been: ");
 356               print_fastmap (correct_fastmap);
 357
 358               printf ("\n  Fastmap: ");
 359               print_fastmap (fastmap);
 360
 361               printf ("\n  Compiled pattern before matching: ");
 362               print_compiled_pattern (&nonconst_buf);
 363             }
 364
 365           if ((!all_regs_correct || verbose) && correct_regs)
 366             {
 367               unsigned this_reg;
 368               printf ("\n  Incorrect registers:");
 369
 370               for (this_reg = 0; this_reg < regs.num_regs; this_reg++)
 371                 {
 372                   if (!regs_correct[this_reg])
 373                     {
 374                       printf ("\n    Register %d's start was %2d.  ", this_reg,
 375                                                 regs.start[this_reg]);
 376                       printf ("\tIt should have been %d.\n",
 377                                                 correct_regs->start[this_reg]);
 378                       printf ("    Register %d's end was   %2d.  ", this_reg,
 379                                                 regs.end[this_reg]);
 380                       printf ("\tIt should have been %d.\n",
 381                                                 correct_regs->end[this_reg]);
 382                     }
 383                 }
 384             }
 385         }
 386     }
 387
 388   if (nonconst_buf.buffer != NULL)
 389     free (nonconst_buf.buffer);
 390
 391   if (OK_TO_SEARCH)
 392     {
 393       free (old_buf.buffer);
 394
 395       if (correct_regs)
 396         free (regs_correct);
 397
 398     }
 399
 400   nonconst_buf.buffer = old_buf.buffer = NULL;
 401   regs_correct = NULL;
 402   regs.start = regs.end = NULL;
 403
 404 } /* general_test */
 405
 406
 407 void
 408 test_search_return (match_start_wanted, pattern, string)
 409     int match_start_wanted;
 410     const char *pattern;
 411     char *string;
 412 {
 413   struct re_pattern_buffer buf;
 414   char fastmap[1 << BYTEWIDTH];
 415   const char *compile_return;
 416   int match_start;
 417   static num_times_called = 0;
 418
 419   num_times_called++;
 420   buf.allocated = 1;
 421   buf.buffer = xmalloc (buf.allocated);
 422
 423   assert (pattern != NULL);
 424   buf.translate = 0;
 425   compile_return = re_compile_pattern (pattern, strlen (pattern), &buf);
 426
 427   if (compile_return)
 428     {
 429       printf ("\n\nInvalid pattern in test_match_start:\n");
 430       printf ("%s\n", compile_return);
 431     }
 432   else
 433     {
 434       buf.fastmap = fastmap;
 435       match_start = re_search (&buf, string, strlen (string),
 436                                0, strlen (string), 0);
 437
 438       if (match_start != match_start_wanted)
 439         printf ("\nWanted search to start at %d but started at %d.\n",
 440                  match_start, match_start_wanted);
 441     }
 442   free (buf.buffer);
 443   buf.buffer = NULL;
 444 }
 445
 446
 447 #define SET_FASTMAP()                                                   \
 448   {                                                                     \
 449     unsigned this_char;                                                 \
 450                                                                         \
 451     memset (correct_fastmap, invert, (1 << BYTEWIDTH));                 \
 452                                                                         \
 453     for (this_char = 0; this_char < strlen (fastmap_string); this_char++)\
 454       correct_fastmap[fastmap_string[this_char]] = !invert;             \
 455     correct_fastmap['\n'] = match_newline;                              \
 456   }
 457
 458
 459 void
 460 test_fastmap (pat, fastmap_string, invert, match_newline)
 461     const char *pat;
 462     char *fastmap_string;
 463     unsigned invert;
 464     unsigned match_newline;
 465 {
 466   char correct_fastmap[(1 << BYTEWIDTH)];
 467
 468   SET_FASTMAP ();
 469   general_test (1, 0, pat, NULL, NULL, -1, 0, -1, correct_fastmap, 0, -1);
 470 }
 471
 472
 473 void
 474 test_fastmap_search (pat, str, fastmap_string, invert, match_newline,
 475                      can_be_null, start0, end0)
 476     const char *pat;
 477     char *str;
 478     char *fastmap_string;
 479     unsigned invert;
 480     unsigned match_newline;
 481     int can_be_null;
 482     int start0;
 483     int end0;
 484 {
 485   char correct_fastmap[(1 << BYTEWIDTH)];
 486   struct re_registers correct_regs;
 487
 488   correct_regs.num_regs = RE_NREGS;
 489   correct_regs.start = (int *) xmalloc (RE_NREGS * sizeof (int));
 490   correct_regs.end = (int *) xmalloc (RE_NREGS * sizeof (int));
 491
 492   set_all_registers (start0, end0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 493                      -1, -1, -1, -1, -1, -1, -1, -1, &correct_regs);
 494   SET_FASTMAP ();
 495   general_test (1, 0, pat, str, NULL, 0, SAFE_STRLEN (str), SAFE_STRLEN (str),
 496                 correct_fastmap, &correct_regs, can_be_null);
 497
 498   free (correct_regs.start);
 499   free (correct_regs.end);
 500 }
 501
 502
 503
 504
 505 void
 506 test_all_registers (pat, str1, str2,
 507                     start0, end0, start1, end1,
 508                     start2, end2, start3, end3,
 509                     start4, end4, start5, end5,
 510                     start6, end6, start7, end7,
 511                     start8, end8, start9, end9)
 512   char *pat; char *str1; char *str2;
 513   int start0; int end0; int start1; int end1;
 514   int start2; int end2; int start3; int end3;
 515   int start4; int end4; int start5; int end5;
 516   int start6; int end6; int start7; int end7;
 517   int start8; int end8; int start9; int end9;
 518 {
 519   struct re_registers correct_regs;
 520
 521   if (omit_register_tests) return;
 522
 523   correct_regs.num_regs = RE_NREGS;
 524   correct_regs.start = (int *) xmalloc (RE_NREGS * sizeof (int));
 525   correct_regs.end = (int *) xmalloc (RE_NREGS * sizeof (int));
 526
 527   set_all_registers (start0, end0, start1, end1, start2, end2, start3, end3,
 528                      start4, end4, start5, end5, start6, end6, start7, end7,
 529                      start8, end8, start9, end9, &correct_regs);
 530
 531   general_test (1, 0, pat, str1, str2, 0,
 532                 SAFE_STRLEN (str1) + SAFE_STRLEN (str2),
 533                 SAFE_STRLEN (str1) + SAFE_STRLEN (str2),
 534                 NULL, &correct_regs, -1);
 535
 536   free (correct_regs.start);
 537   free (correct_regs.end);
 538 }
 539
 540
 541 void
 542 invalid_pattern (error_code_expected, pattern)
 543   int error_code_expected;
 544   char *pattern;
 545 {
 546   regex_t pattern_buffer;
 547   int cflags
 548     = re_syntax_options == RE_SYNTAX_POSIX_EXTENDED
 549       || re_syntax_options == RE_SYNTAX_POSIX_MINIMAL_EXTENDED
 550       ? REG_EXTENDED : 0;
 551
 552   test_compile (0, error_code_expected, pattern, &pattern_buffer, cflags);
 553 }
 554
 555
 556 void
 557 valid_pattern (pattern)
 558   char *pattern;
 559 {
 560   regex_t pattern_buffer;
 561   int cflags
 562     = re_syntax_options == RE_SYNTAX_POSIX_EXTENDED
 563       || re_syntax_options == RE_SYNTAX_POSIX_MINIMAL_EXTENDED
 564       ? REG_EXTENDED : 0;
 565
 566   test_compile (1, 0, pattern, &pattern_buffer, cflags);
 567 }
 568
 569
 570 char *
 571 delimiters_to_ops (source, left_delimiter, right_delimiter)
 572   char *source;
 573   char left_delimiter;
 574   char right_delimiter;
 575 {
 576   static char *answer = NULL;
 577   char *tmp = NULL;
 578   boolean double_size = false;
 579   unsigned source_char;
 580   unsigned answer_char = 0;
 581
 582   assert (source != NULL);
 583
 584   switch (left_delimiter)
 585     {
 586       case '(': if (!(re_syntax_options & RE_NO_BK_PARENS))
 587                   double_size = true;
 588                 break;
 589       case '{': if (!(re_syntax_options & RE_NO_BK_BRACES))
 590                   double_size = true;
 591                 break;
 592       default: printf ("Found strange delimiter %c in delimiter_to_ops.\n",
 593                         left_delimiter);
 594                printf ("The source was `%s'\n", source);
 595                exit (0);
 596     }
 597
 598   if (answer == source)
 599     {
 600       tmp = (char *) xmalloc (strlen (source) + 1);
 601       strcpy (tmp, source);
 602       source = tmp;
 603     }
 604
 605   if (answer)
 606     {
 607       free (answer);
 608       answer = NULL;
 609     }
 610
 611   answer = (char *) xmalloc ((double_size
 612                              ? strlen (source) << 1
 613                              : strlen (source))
 614                             + 1);
 615   if (!double_size)
 616     strcpy (answer, source);
 617   else
 618     {
 619       for (source_char = 0; source_char < strlen (source); source_char++)
 620         {
 621           if (source[source_char] == left_delimiter
 622               || source[source_char] == right_delimiter)
 623             answer[answer_char++] = '\\';
 624
 625           answer[answer_char++] = source[source_char];
 626         }
 627       answer[answer_char] = 0;
 628     }
 629
 630   return answer;
 631 }
 632
 633
 634 void
 635 print_pattern_info (pattern, pattern_buffer_ptr)
 636   const char *pattern;
 637   regex_t *pattern_buffer_ptr;
 638 {
 639   printf ("  Pattern:  `%s'.\n", pattern);
 640   printf ("  Compiled pattern:  ");
 641   print_compiled_pattern (pattern_buffer_ptr);
 642 }
 643
 644
 645 void
 646 valid_nonposix_pattern (pattern)
 647   char *pattern;
 648 {
 649   struct re_pattern_buffer nonconst_buf;
 650
 651   nonconst_buf.allocated = 0;
 652   nonconst_buf.buffer = NULL;
 653   nonconst_buf.translate = NULL;
 654
 655   assert (pattern != NULL);
 656
 657   if (re_compile_pattern (pattern, strlen (pattern), &nonconst_buf))
 658     {
 659       printf ("Couldn't compile the pattern.\n");
 660       print_pattern_info (pattern, &nonconst_buf);
 661     }
 662 }
 663
 664
 665 void
 666 compile_and_print_pattern (pattern)
 667   char *pattern;
 668 {
 669   struct re_pattern_buffer nonconst_buf;
 670
 671   nonconst_buf.allocated = 0;
 672   nonconst_buf.buffer = NULL;
 673
 674   if (re_compile_pattern (pattern, strlen (pattern), &nonconst_buf))
 675     printf ("Couldn't compile the pattern.\n");
 676
 677   print_pattern_info (pattern, &nonconst_buf);
 678 }
 679
 680
 681 void
 682 test_case_fold (pattern, string)
 683   const char *pattern;
 684   char* string;
 685 {
 686   struct re_pattern_buffer nonconst_buf;
 687   const char *ret;
 688
 689   init_pattern_buffer (&nonconst_buf);
 690   nonconst_buf.translate = upcase;
 691
 692   assert (pattern != NULL);
 693   ret = re_compile_pattern (pattern, strlen (pattern), &nonconst_buf);
 694
 695   if (ret)
 696     {
 697       printf ("\nShould have been a valid pattern but wasn't.\n");
 698       print_pattern_info (pattern, &nonconst_buf);
 699     }
 700   else
 701     {
 702       if (test_should_match
 703           && re_match (&nonconst_buf, string, strlen (string), 0, 0)
 704              != strlen (string))
 705        {
 706          printf ("Match failed for case fold.\n");
 707          printf ("  Pattern:  `%s'.\n", pattern);
 708          printf ("  String: `%s'.\n", string == NULL ? "NULL" : string);
 709        }
 710     }
 711 }
 712
 713
 714 void
 715 test_match_n_times (n, pattern, string)
 716   unsigned n;
 717   char* pattern;
 718   char* string;
 719 {
 720   struct re_pattern_buffer buf;
 721   const char *r;
 722   unsigned match = 0;
 723   unsigned this_match;
 724
 725   buf.allocated = 0;
 726   buf.buffer = NULL;
 727   buf.translate = 0;
 728
 729   assert (pattern != NULL);
 730
 731   r = re_compile_pattern (pattern, strlen (pattern), &buf);
 732   if (r)
 733     {
 734       printf ("Didn't compile.\n");
 735       printf ("  Pattern: %s.\n", pattern);
 736     }
 737   else
 738     {
 739       for (this_match = 1; this_match <= n; this_match++)
 740         match = (re_match (&buf, string, strlen (string),
 741                            0, 0)
 742                  == strlen (string));
 743
 744       if (match && !test_should_match)
 745           printf ("\n\nMatched but shouldn't have:\n");
 746       else if (!match && test_should_match)
 747           printf ("\n\nDidn't match but should have:\n");
 748
 749       if ((match && !test_should_match) || (!match && test_should_match))
 750         {
 751           printf("  The string to match was:  ");
 752           if (string)
 753             printf ("`%s' and ", string);
 754           else
 755             printf ("`'");
 756
 757           printf ("  Pattern: %s.\n", pattern);
 758           printf ("  Compiled pattern: %s.\n", pattern);
 759           print_compiled_pattern (&buf);
 760         }
 761     }
 762 }
 763
 764
 765 void
 766 test_match_2 (pat, str1, str2)
 767   const char *pat;
 768   char *str1;
 769   char *str2;
 770 {
 771   general_test (1, 1, pat, str1, str2, 0, 1,
 772                   SAFE_STRLEN (str1) + SAFE_STRLEN (str2), NULL, 0, -1);
 773 }
 774
 775 void
 776 test_match (pat, str)
 777   const char *pat;
 778   char *str;
 779 {
 780   test_match_2 (pat, str, NULL);
 781   test_match_2 (pat, NULL, str);
 782 }