tests/lib/uwildmat-t.c

   1 /*  $Id: uwildmat-t.c 7262 2005-06-06 04:45:48Z eagle $
   2 **
   3 **  wildmat test suite.
   4 **
   5 **  As of March 11, 2001, this test suite achieves 100% coverage of the
   6 **  wildmat source code at that time.
   7 */
   8
   9 #include "clibrary.h"
  10 #include "libinn.h"
  11
  12 static void
  13 test_r(int n, const char *text, const char *pattern, bool matches)
  14 {
  15     bool matched;
  16
  17     matched = uwildmat(text, pattern);
  18     printf("%sok %d\n", matched == matches ? "" : "not ", n);
  19     if (matched != matches)
  20         printf("  %s\n  %s\n  expected %d\n", text, pattern, matches);
  21 }
  22
  23 static void
  24 test_p(int n, const char *text, const char *pattern, enum uwildmat matches)
  25 {
  26     enum uwildmat matched;
  27
  28     matched = uwildmat_poison(text, pattern);
  29     printf("%sok %d\n", matched == matches ? "" : "not ", n);
  30     if (matched != matches)
  31         printf("  %s\n  %s\n  expected %d got %d\n", text, pattern,
  32                (int) matches, (int) matched);
  33 }
  34
  35 static void
  36 test_s(int n, const char *text, const char *pattern, bool matches)
  37 {
  38     bool matched;
  39
  40     matched = uwildmat_simple(text, pattern);
  41     printf("%sok %d\n", matched == matches ? "" : "not ", n);
  42     if (matched != matches)
  43         printf("  %s\n  %s\n  expected %d\n", text, pattern, matches);
  44 }
  45
  46 int
  47 main(void)
  48 {
  49     puts("166");
  50
  51     /* Basic wildmat features. */
  52     test_r(  1, "foo",            "foo",               true);
  53     test_r(  2, "foo",            "bar",               false);
  54     test_r(  3, "",               "",                  true);
  55     test_r(  4, "foo",            "???",               true);
  56     test_r(  5, "foo",            "??",                false);
  57     test_r(  6, "foo",            "*",                 true);
  58     test_r(  7, "foo",            "f*",                true);
  59     test_r(  8, "foo",            "*f",                false);
  60     test_r(  9, "foo",            "*foo*",             true);
  61     test_r( 10, "foobar",         "*ob*a*r*",          true);
  62     test_r( 11, "aaaaaaabababab", "*ab",               true);
  63     test_r( 12, "foo*",           "foo\\*",            true);
  64     test_r( 13, "foobar",         "foo\\*bar",         false);
  65     test_r( 14, "\\",             "\\\\",              true);
  66     test_r( 15, "ball",           "*[al]?",            true);
  67     test_r( 16, "ten",            "[ten]",             false);
  68     test_r( 17, "ten",            "**[^te]",           true);
  69     test_r( 18, "ten",            "**[^ten]",          false);
  70     test_r( 19, "ten",            "t[a-g]n",           true);
  71     test_r( 20, "ten",            "t[^a-g]n",          false);
  72     test_r( 21, "ton",            "t[^a-g]n",          true);
  73     test_r( 22, "]",              "]",                 true);
  74     test_r( 23, "a]b",            "a[]]b",             true);
  75     test_r( 24, "a-b",            "a[]-]b",            true);
  76     test_r( 25, "a]b",            "a[]-]b",            true);
  77     test_r( 26, "aab",            "a[]-]b",            false);
  78     test_r( 27, "aab",            "a[]a-]b",           true);
  79
  80     /* Multiple and negation. */
  81     test_r( 28, "foo",            "!foo",              false);
  82     test_r( 29, "foo",            "!bar",              false);
  83     test_r( 30, "foo",            "*,!foo",            false);
  84     test_r( 31, "foo",            "*,!bar",            true);
  85     test_r( 32, "foo",            "foo,bar",           true);
  86     test_r( 33, "bar",            "foo,bar",           true);
  87     test_r( 34, "baz",            "foo,bar",           false);
  88     test_r( 35, "baz",            "foo,ba?",           true);
  89     test_r( 36, "",               "!",                 false);
  90     test_r( 37, "foo",            "!",                 false);
  91     test_r( 38, "a",              "a,!b,c",            true);
  92     test_r( 39, "b",              "a,!b,c",            false);
  93     test_r( 40, "c",              "a,!b,c",            true);
  94     test_r( 41, "ab",             "a*,!ab",            false);
  95     test_r( 42, "abc",            "a*,!ab",            true);
  96     test_r( 43, "dabc",           "a*,!ab",            false);
  97     test_r( 44, "abc",            "a*,!ab*,abc",       true);
  98     test_r( 45, "",               ",",                 true);
  99     test_r( 46, "a",              ",a",                true);
 100     test_r( 47, "a",              "a,,,",              true);
 101     test_r( 48, "b",              ",a",                false);
 102     test_r( 49, "b",              "a,,,",              false);
 103     test_r( 50, "a,b",            "a\\,b",             true);
 104     test_r( 51, "a,b",            "a\\\\,b",           false);
 105     test_r( 52, "a\\",            "a\\\\,b",           true);
 106     test_r( 53, "a\\,b",          "a\\\\,b",           false);
 107     test_r( 54, "a\\,b",          "a\\\\\\,b",         true);
 108     test_r( 55, ",",              "\\,",               true);
 109     test_r( 56, ",\\",            "\\,",               false);
 110     test_r( 57, ",\\",            "\\,\\\\,",          true);
 111     test_r( 58, "",               "\\,\\\\,",          true);
 112     test_r( 59, "",               "\\,,!",             false);
 113     test_r( 60, "",               "\\,!,",             true);
 114
 115     /* Various additional tests. */
 116     test_r( 61, "acrt",           "a[c-c]st",          false);
 117     test_r( 62, "]",              "[^]-]",             false);
 118     test_r( 63, "a",              "[^]-]",             true);
 119     test_r( 64, "",               "\\",                false);
 120     test_r( 65, "\\",             "\\",                false);
 121     test_r( 66, "foo",            "*,@foo",            true);
 122     test_r( 67, "@foo",           "@foo",              true);
 123     test_r( 68, "foo",            "@foo",              false);
 124     test_r( 69, "[ab]",           "\\[ab]",            true);
 125     test_r( 70, "?a?b",           "\\??\\?b",          true);
 126     test_r( 71, "abc",            "\\a\\b\\c",         true);
 127
 128     /* Poison negation. */
 129     test_p( 72, "abc",            "*",                 UWILDMAT_MATCH);
 130     test_p( 73, "abc",            "def",               UWILDMAT_FAIL);
 131     test_p( 74, "abc",            "*,!abc",            UWILDMAT_FAIL);
 132     test_p( 75, "a",              "*,@a",              UWILDMAT_POISON);
 133     test_p( 76, "ab",             "*,@a*,ab",          UWILDMAT_MATCH);
 134     test_p( 77, "ab",             "*,@a**,!ab",        UWILDMAT_FAIL);
 135     test_p( 78, "@ab",            "\\@ab",             UWILDMAT_MATCH);
 136     test_p( 79, "@ab",            "@\\@ab",            UWILDMAT_POISON);
 137
 138     /* UTF-8 characters. */
 139     test_r( 80, "S\303\256ne",    "S\303\256ne",       true);
 140     test_r( 81, "S\303\256ne",    "S\303\257ne",       false);
 141     test_r( 82, "S\303\256ne",    "S?ne",              true);
 142     test_r( 83, "S\303\256ne",    "S*e",               true);
 143     test_r( 84, "S\303\256ne",    "S[a-\330\200]ne",   true);
 144     test_r( 85, "S\303\256ne",    "S[a-\300\256]ne",   false);
 145     test_r( 86, "S\303\256ne",    "S[^\1-\177]ne",     true);
 146     test_r( 87, "S\303\256ne",    "S[0\303\256$]ne",   true);
 147     test_r( 88, "\2",             "[\1-\3]",           true);
 148     test_r( 89, "\330\277",     "[\330\276-\331\200]", true);
 149     test_r( 90, "\337\277", "[\337\276-\350\200\200]", true);
 150     test_r( 91, "\357\277\277", "[\357\277\276-\364\200\200\200]", true);
 151     test_r( 92, "\357\276\277", "[\357\277\276-\364\200\200\200]", false);
 152     test_r( 93, "\367\277\277\277",
 153                     "[\310\231-\372\200\200\200\200]", true);
 154     test_r( 94, "\373\277\277\277\277",
 155                       "[\1-\375\200\200\200\200\200]", true);
 156     test_r( 95, "\375\200\200\200\200\200",
 157                       "[\5-\375\200\200\200\200\200]", true);
 158     test_r( 96, "\375\277\277\277\277\276",
 159            "[\375\277\277\277\277\275-\375\277\277\277\277\277]", true);
 160     test_r( 97, "b\357\277\277a", "b?a",               true);
 161     test_r( 98, "b\367\277\277\277a", "b?a",           true);
 162     test_r( 99, "b\373\277\277\277\277a", "b?a",       true);
 163     test_r(100, "b\375\277\277\277\277\276a", "b?a",   true);
 164     test_r(101, "\357\240\275S\313\212\375\206\203\245\260\211",
 165                                                "????", true);
 166     test_r(102, "S\303\256ne",    "S\\\303\256ne",     true);
 167     test_r(103, "s", "[^\330\277-\375\277\277\277\277\277]", true);
 168     test_r(104, "\367\277\277\277",
 169                "[^\330\277-\375\277\277\277\277\277]", false);
 170
 171     /* Malformed UTF-8. */
 172     test_r(105, "S\303\256ne",    "S?\256ne",          false);
 173     test_r(106, "\303\303",       "?",                 false);
 174     test_r(107, "\303\303",       "??",                true);
 175     test_r(108, "\200",           "[\177-\201]",       true);
 176     test_r(109, "abc\206d",       "*\206d",            true);
 177     test_r(110, "\303\206",       "*\206",             false);
 178     test_r(111, "\40",            "\240",              false);
 179     test_r(112, "\323",           "[a-\377]",          true);
 180     test_r(113, "\376\277\277\277\277\277", "?",       false);
 181     test_r(114, "\376\277\277\277\277\277", "??????",  true);
 182     test_r(115, "\377\277\277\277\277\277", "?",       false);
 183     test_r(116, "\377\277\277\277\277\277", "??????",  true);
 184     test_r(117, "\303\323\206",   "??",                true);
 185     test_r(118, "\206",           "[\341\206f]",       true);
 186     test_r(119, "f",              "[\341\206f]",       true);
 187     test_r(120, "\207",           "[\341\206-\277]",   true);
 188     test_r(121, "\207",           "[\341\206\206-\277]", false);
 189     test_r(122, "\300",           "[\277-\341\206]",   true);
 190     test_r(123, "\206",           "[\277-\341\206]",   true);
 191     test_r(124, "\341\206",       "[\341\206-\277]?",  true);
 192
 193     /* Additional tests, including some malformed wildmats. */
 194     test_r(125, "ab",             "a[]b",              false);
 195     test_r(126, "a[]b",           "a[]b",              false);
 196     test_r(127, "ab[",            "ab[",               false);
 197     test_r(128, "ab",             "[^",                false);
 198     test_r(129, "ab",             "[-",                false);
 199     test_r(130, "-",              "[-]",               true);
 200     test_r(131, "-",              "[a-",               false);
 201     test_r(132, "-",              "[^a-",              false);
 202     test_r(133, "-",              "[--A]",             true);
 203     test_r(134, "5",              "[--A]",             true);
 204     test_r(135, "\303\206",       "[--A]",             false);
 205     test_r(136, " ",              "[ --]",             true);
 206     test_r(137, "$",              "[ --]",             true);
 207     test_r(138, "-",              "[ --]",             true);
 208     test_r(139, "0",              "[ --]",             false);
 209     test_r(140, "-",              "[---]",             true);
 210     test_r(141, "-",              "[------]",          true);
 211     test_r(142, "j",              "[a-e-n]",           false);
 212     test_r(143, "a",              "[^------]",         true);
 213     test_r(144, "[",              "[]-a]",             false);
 214     test_r(145, "^",              "[]-a]",             true);
 215     test_r(146, "^",              "[^]-a]",            false);
 216     test_r(147, "[",              "[^]-a]",            true);
 217     test_r(148, "^",              "[a^bc]",            true);
 218     test_r(149, "-b]",            "[a-]b]",            true);
 219     test_r(150, "\\]",            "[\\]]",             true);
 220     test_r(151, "]",              "[\\-^]",            true);
 221     test_r(152, "[",              "[\\-^]",            false);
 222     test_r(153, "G",              "[A-\\]",            true);
 223     test_r(154, "aaabbb",         "b*a",               false);
 224     test_r(155, "aabcaa",         "*ba*",              false);
 225     test_r(156, ",",              "[,]",               true);
 226     test_r(157, ",",              "[\\,]",             true);
 227     test_r(158, "\\",             "[\\,]",             true);
 228     test_r(159, "-",              "[,-.]",             true);
 229     test_r(160, "+",              "[,-.]",             false);
 230     test_r(161, "-.]",            "[,-.]",             false);
 231
 232     /* Tests for the wildmat_simple interface. */
 233     test_s(162, "ab,cd",          "ab,cd",             true);
 234     test_s(163, "ab",             "ab,cd",             false);
 235     test_s(164, "!aaabbb",        "!a*b*",             true);
 236     test_s(165, "ccc",            "*,!a*",             false);
 237     test_s(166, "foo",            "*",                 true);
 238
 239     return 0;
 240 }