home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1993 #1 / MONSTER.ISO / prog / gen / regex011.taz / regex011 / regex-0.11 / test / psx-generic.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-28  |  11.0 KB  |  337 lines
  1. /* psx-generic.c: test POSIX re's independent of us using basic or
  2.    extended syntax.  */
  3.  
  4. #include "test.h"
  5.  
  6.  
  7. void
  8. test_posix_generic ()
  9. {
  10.   int omit_generic_tests = 0; /* reset in debugger to skip */
  11.  
  12.   if (omit_generic_tests)
  13.     return;
  14.                                 /* Tests somewhat in the order of P1003.2.  */
  15.   
  16.   /* Both posix basic and extended; should match.  */
  17.  
  18.   printf ("\nStarting generic POSIX tests.\n");
  19.   test_grouping ();
  20.   test_intervals ();
  21.  
  22.   test_should_match = true;
  23.                           /* Ordinary characters.  */
  24.   printf ("\nContinuing generic POSIX tests.\n");
  25.  
  26.   MATCH_SELF ("");
  27.   test_fastmap ("", "", 0, 0);
  28.   test_fastmap_search ("", "", "", 0, 0, 2, 0, 0);
  29.   TEST_REGISTERS ("", "", 0, 0, -1, -1, -1, -1);
  30.   TEST_SEARCH ("", "", 0, 0);
  31.   TEST_SEARCH_2 ("", "", "", 0, 1, 0);
  32.   
  33.   MATCH_SELF ("abc");                
  34.   test_fastmap ("abc", "a", 0, 0);                
  35.   TEST_REGISTERS ("abc", "abc", 0, 3, -1, -1, -1, -1);
  36.   TEST_REGISTERS ("abc", "xabcx", 1, 4, -1, -1, -1, -1);
  37.   
  38.   test_match ("\\a","a");
  39.   test_match ("\\0", "0");
  40.  
  41.   TEST_SEARCH ("a", "ab", 0, 2);
  42.   TEST_SEARCH ("b", "ab", 0, 2);
  43.   TEST_SEARCH ("a", "ab", 1, -2);
  44.   TEST_SEARCH_2 ("a", "a", "b", 0, 2, 2);
  45.   TEST_SEARCH_2 ("b", "a", "b", 0, 2, 2);
  46.   TEST_SEARCH_2 ("a", "a", "b", 1, -2, 2);
  47.   
  48.   test_match ("\n", "\n");
  49.   test_match ("a\n", "a\n");
  50.   test_match ("\nb", "\nb");
  51.   test_match ("a\nb", "a\nb");
  52.  
  53.   TEST_SEARCH ("b", "baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 236, -237);
  54.                     /* Valid use of special characters. */
  55.   test_match ("a*", "aa");
  56.   test_fastmap ("a*", "a", 0, 0);
  57.   TEST_REGISTERS ("a*", "aa", 0, 2, -1, -1, -1, -1);
  58.   
  59.   test_match ("a*b", "aab");            
  60.   test_fastmap ("a*b", "ab", 0, 0);
  61.  
  62.   test_match ("a*ab", "aab");
  63.   TEST_REGISTERS ("a*a", "aa", 0, 2, -1, -1, -1, -1);
  64.   TEST_REGISTERS ("a*a", "xaax", 1, 3, -1, -1, -1, -1);
  65.  
  66.   test_match ("\\{", "{");
  67.   test_match ("\\^", "^");
  68.   test_match ("\\.", ".");
  69.   test_match ("\\*", "*");
  70.   test_match ("\\[", "[");
  71.   test_match ("\\$", "$");
  72.   test_match ("\\\\", "\\");
  73.  
  74.   test_match ("ab*", "a");
  75.   test_match ("ab*", "abb");
  76.  
  77.   /* Valid consecutive repetitions.  */
  78.   test_match ("a**", "a");
  79.                                                 /* Valid period.  */
  80.   test_match (".", "a");
  81.   TEST_REGISTERS (".", "a", 0, 1, -1, -1, -1, -1);
  82.   test_match (".", "\004");
  83.   test_match (".", "\n");        
  84.                                               /* Valid bracket expressions.  */
  85.   test_match ("[ab]", "a");        
  86.   test_match ("[ab]", "b");
  87.   test_fastmap ("[ab]", "ab", 0, 0);
  88.   TEST_REGISTERS ("[ab]", "a", 0, 1, -1, -1, -1, -1);
  89.   TEST_REGISTERS ("[ab]", "xax", 1, 2, -1, -1, -1, -1);
  90.  
  91.   test_fastmap ("[^ab]", "ab", 1, 1);
  92.   test_match ("[^ab]", "c");
  93.   test_match ("[^a]", "\n");
  94.  
  95.   test_match ("[a]*a", "aa");        
  96.  
  97.   test_match ("[[]", "[");
  98.   test_match ("[]]", "]");
  99.   test_match ("[.]", ".");
  100.   test_match ("[*]", "*");
  101.   test_match ("[\\]", "\\");
  102.   test_match ("[\\(]", "(");
  103.   test_match ("[\\)]", ")");
  104.   test_match ("[^]]", "a");
  105.   test_match ("[a^]", "^");
  106.   test_match ("[a$]", "$");
  107.   test_match ("[]a]", "]");
  108.   test_match ("[a][]]", "a]");
  109.   test_match ("[\n]", "\n");
  110.   test_match ("[^a]", "\n");
  111.   test_match ("[a-]", "a");
  112.  
  113.   TEST_REGISTERS ("\\`[ \t\n]*", " karl (Karl Berry)", 0, 1, -1, -1, -1, -1);
  114.   TEST_REGISTERS ("[ \t\n]*\\'", " karl (Karl Berry)", 18, 18, -1, -1, -1, -1);
  115.  
  116.                                                 /* Collating, noncollating,
  117.                                                     equivalence classes aren't
  118.                                                   implemented yet.  */  
  119.                     
  120.  
  121.                                                 /* Character classes.  */
  122.   test_match ("[:alpha:]", "p");    
  123.   test_match ("[[:alpha:]]", "a");    
  124.   test_match ("[[:alpha:]]", "z");
  125.   test_match ("[[:alpha:]]", "A");
  126.   test_match ("[[:alpha:]]", "Z");
  127.   test_match ("[[:upper:]]", "A");
  128.   test_match ("[[:upper:]]", "Z");
  129.   test_match ("[[:lower:]]", "a");
  130.   test_match ("[[:lower:]]", "z");
  131.  
  132.   test_match ("[[:digit:]]", "0");
  133.   test_match ("[[:digit:]]", "9");
  134.   test_fastmap ("[[:digit:]]", "0123456789", 0, 0);
  135.  
  136.   test_match ("[[:alnum:]]", "0");
  137.   test_match ("[[:alnum:]]", "9");
  138.   test_match ("[[:alnum:]]", "a");
  139.   test_match ("[[:alnum:]]", "z");
  140.   test_match ("[[:alnum:]]", "A");
  141.   test_match ("[[:alnum:]]", "Z");
  142.   test_match ("[[:xdigit:]]", "0");
  143.   test_match ("[[:xdigit:]]", "9");
  144.   test_match ("[[:xdigit:]]", "A");
  145.   test_match ("[[:xdigit:]]", "F");
  146.   test_match ("[[:xdigit:]]", "a");
  147.   test_match ("[[:xdigit:]]", "f");
  148.   test_match ("[[:space:]]", " ");
  149.   test_match ("[[:print:]]", " ");
  150.   test_match ("[[:print:]]", "~");
  151.   test_match ("[[:punct:]]", ",");
  152.   test_match ("[[:graph:]]", "!");
  153.   test_match ("[[:graph:]]", "~");
  154.   test_match ("[[:cntrl:]]", "\177");
  155.   test_match ("[[:digit:]a]", "a");
  156.   test_match ("[[:digit:]a]", "2");
  157.   test_match ("[a[:digit:]]", "a");
  158.   test_match ("[a[:digit:]]", "2");
  159.   test_match ("[[:]", "[");
  160.   test_match ("[:]", ":");
  161.   test_match ("[[:a]", "[");
  162.   test_match ("[[:alpha:a]", "[");
  163.                           /* Valid ranges.  */
  164.   test_match ("[a-a]", "a");
  165.   test_fastmap ("[a-a]", "a", 0, 0);
  166.   TEST_REGISTERS ("[a-a]", "xax", 1, 2, -1, -1, -1, -1);
  167.  
  168.   test_match ("[a-z]", "z");
  169.   test_fastmap ("[a-z]", "abcdefghijklmnopqrstuvwxyz", 0, 0);
  170.   test_match ("[-a]", "-");        /* First  */
  171.   test_match ("[-a]", "a");
  172.   test_match ("[a-]", "-");        /* Last  */
  173.   test_match ("[a-]", "a");
  174.   test_match ("[--@]", "@");        /* First and starting point.  */
  175.   
  176.   test_match ("[%--a]", "%");        /* Ending point.  */
  177.   test_match ("[%--a]", "-");        /* Ditto.  */
  178.   
  179.   test_match ("[a%--]", "%");        /* Both ending point and last.  */
  180.   test_match ("[a%--]", "-");
  181.   test_match ("[%--a]", "a");        /* Ending point only.  */
  182.   test_match ("[a-c-f]", "e");        /* Piggyback.  */
  183.  
  184.   test_match ("[)-+--/]", "*");
  185.   test_match ("[)-+--/]", ",");
  186.   test_match ("[)-+--/]", "/");
  187.   test_match ("[[:digit:]-]", "-");
  188.                                         /* Concatenation  ????*/
  189.   test_match ("[ab][cd]", "ac");            
  190.   test_fastmap ("[ab][cd]", "ab", 0, 0);
  191.   TEST_REGISTERS ("[ab][cd]", "ad", 0, 2, -1, -1, -1, -1);
  192.   TEST_REGISTERS ("[ab][cd]", "xadx", 1, 3, -1, -1, -1, -1);
  193.     
  194.                                              /* Valid expression anchoring.  */
  195.   test_match ("^a", "a");
  196.   test_fastmap ("^a", "a", 0, 0);
  197.   TEST_REGISTERS ("^a", "ax", 0, 1, -1, -1, -1, -1);
  198.   
  199.   test_match ("^", "");
  200.   TEST_REGISTERS ("^", "", 0, 0, -1, -1, -1, -1);
  201.   test_match ("$", "");
  202.   TEST_REGISTERS ("$", "", 0, 0, -1, -1, -1, -1);
  203.   
  204.   test_match ("a$", "a");
  205.   test_fastmap ("a$", "a", 0, 0);
  206.   TEST_REGISTERS ("a$", "xa", 1, 2, -1, -1, -1, -1);
  207.   
  208.   test_match ("^ab$", "ab");
  209.   test_fastmap ("^ab$", "a", 0, 0);
  210.   TEST_REGISTERS ("^a$", "a", 0, 1, -1, -1, -1, -1);
  211.   
  212.   test_fastmap ("^$", "", 0, 0);
  213.   test_match ("^$", "");
  214.   TEST_REGISTERS ("^$", "", 0, 0, -1, -1, -1, -1);
  215.  
  216.   TEST_SEARCH (PARENS_TO_OPS ("(^a)"), "ab", 0, 2);
  217.   TEST_SEARCH (PARENS_TO_OPS ("(a$)"), "ba", 0, 2);
  218.   TEST_SEARCH (PARENS_TO_OPS ("^(^a)"), "ab", 0, 2);
  219.   TEST_SEARCH (PARENS_TO_OPS ("(a$)$"), "ba", 0, 2);
  220.  
  221.                                                 /* Two strings.  */
  222.   test_match_2 ("ab", "a", "b");
  223.   TEST_REGISTERS_2 ("ab", "a", "b", 0, 2, -1, -1, -1, -1);
  224.   
  225.   test_match_2 ("a", "", "a");
  226.   test_match_2 ("a", "a", "");
  227.   test_match_2 ("ab", "a", "b");
  228.                         /* (start)pos.  */
  229.   TEST_POSITIONED_MATCH ("b", "ab", 1);
  230.                           /* mstop.  */
  231.   TEST_TRUNCATED_MATCH ("a", "ab", 1);
  232.  
  233.  
  234.   /* Both basic and extended, continued; should not match.  */
  235.  
  236.   test_should_match = false;
  237.                                           /* Ordinary characters.  */
  238.   test_match ("abc", "ab");            
  239.   
  240.   TEST_SEARCH ("c", "ab", 0, 2);
  241.   TEST_SEARCH ("c", "ab", 0, 2);
  242.   TEST_SEARCH ("c", "ab", 1, -2);
  243.   TEST_SEARCH ("c", "ab", 0, 10);
  244.   TEST_SEARCH ("c", "ab", 1, -10);
  245.   TEST_SEARCH_2 ("c", "a", "b", 0, 2, 2);
  246.   TEST_SEARCH_2 ("c", "a", "b", 0, 2, 2);
  247.   TEST_SEARCH_2 ("c", "a", "b", 0, 2, 2);
  248.   TEST_SEARCH_2 ("c", "a", "b", 1, -2, 2);
  249.   TEST_SEARCH_2 ("c", "a", "b", 1, -2, 2);
  250.  
  251.   TEST_SEARCH ("c", "baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 236, -237);
  252.  
  253.                 /* Invalid use of special characters.  */
  254.   invalid_pattern (REG_EESCAPE, "\\");
  255.   invalid_pattern (REG_EESCAPE, "a\\");
  256.   invalid_pattern (REG_EESCAPE, "a*\\");
  257.                           /* Invalid period.  */
  258.   test_match (".", "");
  259.                       /* Invalid bracket expressions.  */
  260.   test_match ("[ab]", "c");            
  261.   test_match ("[^b]", "b");            
  262.   test_match ("[^]]", "]");
  263.  
  264.   invalid_pattern (REG_EBRACK, "[");
  265.   invalid_pattern (REG_EBRACK, "[^");
  266.   invalid_pattern (REG_EBRACK, "[a");
  267.   invalid_pattern (REG_EBRACK, "[]");
  268.   invalid_pattern (REG_EBRACK, "[]a");
  269.   invalid_pattern (REG_EBRACK, "a[]a");
  270.   
  271.  
  272.   test_match ("[:alpha:]", "q");           /* Character classes.  */
  273.   test_match ("[[:alpha:]]", "2");
  274.   test_match ("[[:upper:]]", "a");
  275.   test_match ("[[:lower:]]", "A");
  276.   test_match ("[[:digit:]]", "a");
  277.   test_match ("[[:alnum:]]", ":");
  278.   test_match ("[[:xdigit:]]", "g");
  279.   test_match ("[[:space:]]", "a");
  280.   test_match ("[[:print:]]", "\177");
  281.   test_match ("[[:punct:]]", "a");
  282.   test_match ("[[:graph:]]", " ");
  283.   test_match ("[[:cntrl:]]", "a");
  284.   invalid_pattern (REG_EBRACK, "[[:");
  285.   invalid_pattern (REG_EBRACK, "[[:alpha:");
  286.   invalid_pattern (REG_EBRACK, "[[:alpha:]");
  287.   invalid_pattern (REG_ECTYPE, "[[::]]");
  288.   invalid_pattern (REG_ECTYPE, "[[:a:]]");
  289.   invalid_pattern (REG_ECTYPE, "[[:alpo:]]");
  290.   invalid_pattern (REG_ECTYPE, "[[:a:]");
  291.   
  292.   test_match ("[a-z]", "2");            /* Invalid ranges.  */
  293.   test_match ("[^-a]", "-");        
  294.   test_match ("[^a-]", "-");        
  295.   test_match ("[)-+--/]", ".");
  296.   invalid_pattern (REG_ERANGE, "[z-a]");        /* Empty  */
  297.   invalid_pattern (REG_ERANGE, "[a--]");        /* Empty  */
  298.   invalid_pattern (REG_ERANGE, "[[:digit:]-9]");
  299.   invalid_pattern (REG_ERANGE, "[a-[:alpha:]]");
  300.   invalid_pattern (REG_ERANGE, "[a-");
  301.   invalid_pattern (REG_EBRACK, "[a-z");
  302.  
  303.   test_match ("[ab][cd]", "ae");        /* Concatenation.  */
  304.   test_match ("b*c", "b");            /* Star.  */
  305.  
  306.                                             /* Invalid anchoring.  */
  307.   test_match ("^", "a");
  308.   test_match ("^a", "ba");
  309.   test_match ("$", "b");
  310.   test_match ("a$", "ab");
  311.   test_match ("^$", "a");
  312.   test_match ("^ab$", "a");
  313.  
  314.   TEST_SEARCH ("^a", "b\na", 0, 3);
  315.   TEST_SEARCH ("b$", "b\na", 0, 3);
  316.  
  317.   test_match_2 ("^a", "\n", "a");
  318.   test_match_2 ("a$", "a", "\n");
  319.  
  320.   TEST_SEARCH (PARENS_TO_OPS ("(^a)"), "ba", 0, 2);
  321.   TEST_SEARCH (PARENS_TO_OPS ("(a$)"), "ab", 0, 2);
  322.   TEST_SEARCH (PARENS_TO_OPS ("^(^a)"), "ba", 0, 2);
  323.   TEST_SEARCH (PARENS_TO_OPS ("(a$)$"), "ab", 0, 2);
  324.  
  325.   printf ("\nFinished generic POSIX tests.\n");
  326. }
  327.  
  328.  
  329.  
  330. /*
  331. Local variables:
  332. make-backup-files: t
  333. version-control: t
  334. trim-versions-without-asking: nil
  335. End:
  336. */
  337.