Return to patmatch_test.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / lib

Annotation of embedaddon/bird2/lib/patmatch_test.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  *     BIRD Library -- Pattern Matching Tests
                      3:  *
                      4:  *     (c) 2015 CZ.NIC z.s.p.o.
                      5:  *
                      6:  *     Can be freely distributed and used under the terms of the GNU GPL.
                      7:  */
                      8: 
                      9: #include "test/birdtest.h"
                     10: 
                     11: #include "nest/bird.h"
                     12: #include "lib/string.h"
                     13: 
                     14: #define MATCH          (int) { 1 }
                     15: #define NOMATCH                (int) { 0 }
                     16: 
                     17: struct match_pair {
                     18:   byte *pattern;
                     19:   byte *data;
                     20: };
                     21: 
                     22: static int
                     23: test_matching(void *out_, const void *in_, const void *expected_out_)
                     24: {
                     25:   int *out = out_;
                     26:   const struct match_pair *in = in_;
                     27:   const int *expected_out = expected_out_;
                     28: 
                     29:   *out = patmatch(in->pattern, in->data);
                     30: 
                     31:   return *out == *expected_out;
                     32: }
                     33: 
                     34: static void
                     35: fmt_match_pair(char *buf, size_t size, const void *data)
                     36: {
                     37:   const struct match_pair *mp = data;
                     38:   snprintf(buf, size, "pattern: '%s', subject: '%s'", mp->pattern, mp->data);
                     39: }
                     40: 
                     41: static void
                     42: fmt_match_result(char *buf, size_t size, const void *data)
                     43: {
                     44:   const int *result = data;
                     45:   snprintf(buf, size, *result ? "match" : "no-match");
                     46: }
                     47: 
                     48: static int
                     49: t_matching(void)
                     50: {
                     51:   struct bt_pair test_vectors[] = {
                     52:     {
                     53:       .in  = & (struct match_pair) {
                     54:        .pattern = "",
                     55:        .data    = "",
                     56:       },
                     57:       .out = & MATCH,
                     58:     },
                     59:     {
                     60:       .in  = & (struct match_pair) {
                     61:        .pattern = "*",
                     62:        .data    = "",
                     63:       },
                     64:       .out = & MATCH,
                     65:     },
                     66:     {
                     67:       .in  = & (struct match_pair) {
                     68:        .pattern = "\\*",
                     69:        .data    = "*",
                     70:       },
                     71:       .out = & MATCH,
                     72:     },
                     73:     {
                     74:       .in  = & (struct match_pair) {
                     75:        .pattern = "\\*",
                     76:        .data    = "a",
                     77:       },
                     78:       .out = & NOMATCH,
                     79:     },
                     80:     {
                     81:       .in  = & (struct match_pair) {
                     82:        .pattern = "?",
                     83:        .data    = "",
                     84:       },
                     85:       .out = & NOMATCH,
                     86:     },
                     87:     {
                     88:       .in  = & (struct match_pair) {
                     89:        .pattern = "abcdefghijklmnopqrstuvwxyz",
                     90:        .data    = "abcdefghijklmnopqrstuvwxyz",
                     91:       },
                     92:       .out = & MATCH,
                     93:     },
                     94:     {
                     95:       .in  = & (struct match_pair) {
                     96:        .pattern = "??????????????????????????",
                     97:        .data    = "abcdefghijklmnopqrstuvwxyz",
                     98:       },
                     99:       .out = & MATCH,
                    100:     },
                    101:     {
                    102:       .in  = & (struct match_pair) {
                    103:        .pattern = "*abcdefghijklmnopqrstuvwxyz*",
                    104:        .data    =  "abcdefghijklmnopqrstuvwxyz",
                    105:       },
                    106:       .out = & MATCH,
                    107:     },
                    108:     {
                    109:       .in  = & (struct match_pair) {
                    110:        .pattern = "ab?defg*jklmnop*stu*wxy*z",
                    111:        .data    = "abcdefghijklmnopqrstuvwxyz",
                    112:       },
                    113:       .out = & MATCH,
                    114:     },
                    115:     {
                    116:       .in  = & (struct match_pair) {
                    117:        .pattern = "abcdefghijklmnopqrstuvwxyz",
                    118:        .data    = "abcdefghijklmnopqrtuvwxyz",
                    119:       },
                    120:       .out = & NOMATCH,
                    121:     },
                    122:     {
                    123:       .in  = & (struct match_pair) {
                    124:        .pattern = "abcdefghijklmnopqr?uvwxyz",
                    125:        .data    = "abcdefghijklmnopqrstuvwxyz",
                    126:       },
                    127:       .out = & NOMATCH,
                    128:     },
                    129:     {
                    130:       .in  = & (struct match_pair) {
                    131:        .pattern = "aa*aaaaa?aaaaaaaaaaaaaaaaaaa",
                    132:        .data    = "aaaaaaaaaaaaaaaaaaaaaaaaaa",
                    133:       },
                    134:       .out = & NOMATCH,
                    135:     },
                    136:   };
                    137: 
                    138:   return bt_assert_batch(test_vectors, test_matching, fmt_match_pair, fmt_match_result);
                    139: }
                    140: 
                    141: int
                    142: main(int argc, char *argv[])
                    143: {
                    144:   bt_init(argc, argv);
                    145: 
                    146:   bt_test_suite(t_matching, "Pattern matching");
                    147: 
                    148:   return bt_exit_value();
                    149: }