Changeset 8bce750 for tester.c


Ignore:
Timestamp:
Aug 17, 2009, 9:52:16 PM (12 years ago)
Author:
Nelson Elhage <nelhage@mit.edu>
Branches:
master, release-1.4, release-1.5, release-1.6, release-1.7, release-1.8, release-1.9
Children:
e30ed92
Parents:
a2b3289
git-author:
Nelson Elhage <nelhage@mit.edu> (08/17/09 21:51:29)
git-committer:
Nelson Elhage <nelhage@mit.edu> (08/17/09 21:52:16)
Message:
Move all regression tests into tester.c.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • tester.c

    ra2b3289 r8bce750  
    66
    77int numtests;
     8
     9int owl_util_regtest(void);
     10int owl_dict_regtest(void);
     11int owl_variable_regtest(void);
     12int owl_filter_regtest(void);
     13int owl_obarray_regtest(void);
    814
    915int main(int argc, char **argv, char **env)
     
    2935  return(numfailures);
    3036}
     37
     38#define FAIL_UNLESS(desc,pred) do { int __pred = (pred);                \
     39    numtests++;                                                         \
     40    printf("%s %s", (__pred)?"ok":(numfailed++,"not ok"), desc);        \
     41    if(!(__pred)) printf("\t(%s:%d)", __FILE__, __LINE__); printf("%c", '\n'); } while(0)
     42
     43
     44int owl_util_regtest(void)
     45{
     46  int numfailed=0;
     47
     48  printf("# BEGIN testing owl_util\n");
     49
     50  FAIL_UNLESS("owl_util_substitute 1",
     51              !strcmp("foo", owl_text_substitute("foo", "", "Y")));
     52  FAIL_UNLESS("owl_text_substitute 2",
     53              !strcmp("fYZYZ", owl_text_substitute("foo", "o", "YZ")));
     54  FAIL_UNLESS("owl_text_substitute 3",
     55              !strcmp("foo", owl_text_substitute("fYZYZ", "YZ", "o")));
     56  FAIL_UNLESS("owl_text_substitute 4",
     57              !strcmp("/u/foo/meep", owl_text_substitute("~/meep", "~", "/u/foo")));
     58
     59  FAIL_UNLESS("skiptokens 1",
     60              !strcmp("bar quux", skiptokens("foo bar quux", 1)));
     61  FAIL_UNLESS("skiptokens 2",
     62              !strcmp("meep", skiptokens("foo 'bar quux' meep", 2)));
     63
     64  FAIL_UNLESS("expand_tabs 1",
     65              !strcmp("        hi", owl_text_expand_tabs("\thi")));
     66
     67  FAIL_UNLESS("expand_tabs 2",
     68              !strcmp("        hi\nword    tab", owl_text_expand_tabs("\thi\nword\ttab")));
     69
     70  FAIL_UNLESS("expand_tabs 3",
     71              !strcmp("                2 tabs", owl_text_expand_tabs("\t\t2 tabs")));
     72
     73  /* if (numfailed) printf("*** WARNING: failures encountered with owl_util\n"); */
     74  printf("# END testing owl_util (%d failures)\n", numfailed);
     75  return(numfailed);
     76}
     77
     78int owl_dict_regtest(void) {
     79  owl_dict d;
     80  owl_list l;
     81  int numfailed=0;
     82  char *av="aval", *bv="bval", *cv="cval", *dv="dval";
     83
     84  printf("# BEGIN testing owl_dict\n");
     85  FAIL_UNLESS("create", 0==owl_dict_create(&d));
     86  FAIL_UNLESS("insert b", 0==owl_dict_insert_element(&d, "b", bv, owl_dict_noop_free));
     87  FAIL_UNLESS("insert d", 0==owl_dict_insert_element(&d, "d", dv, owl_dict_noop_free));
     88  FAIL_UNLESS("insert a", 0==owl_dict_insert_element(&d, "a", av, owl_dict_noop_free));
     89  FAIL_UNLESS("insert c", 0==owl_dict_insert_element(&d, "c", cv, owl_dict_noop_free));
     90  FAIL_UNLESS("reinsert d (no replace)", -2==owl_dict_insert_element(&d, "d", dv, 0));
     91  FAIL_UNLESS("find a", av==owl_dict_find_element(&d, "a"));
     92  FAIL_UNLESS("find b", bv==owl_dict_find_element(&d, "b"));
     93  FAIL_UNLESS("find c", cv==owl_dict_find_element(&d, "c"));
     94  FAIL_UNLESS("find d", dv==owl_dict_find_element(&d, "d"));
     95  FAIL_UNLESS("find e (non-existent)", NULL==owl_dict_find_element(&d, "e"));
     96  FAIL_UNLESS("remove d", dv==owl_dict_remove_element(&d, "d"));
     97  FAIL_UNLESS("find d (post-removal)", NULL==owl_dict_find_element(&d, "d"));
     98
     99  FAIL_UNLESS("get_size", 3==owl_dict_get_size(&d));
     100  FAIL_UNLESS("get_keys", 0==owl_dict_get_keys(&d, &l));
     101  FAIL_UNLESS("get_keys result size", 3==owl_list_get_size(&l));
     102 
     103  /* these assume the returned keys are sorted */
     104  FAIL_UNLESS("get_keys result val",0==strcmp("a",owl_list_get_element(&l,0)));
     105  FAIL_UNLESS("get_keys result val",0==strcmp("b",owl_list_get_element(&l,1)));
     106  FAIL_UNLESS("get_keys result val",0==strcmp("c",owl_list_get_element(&l,2)));
     107
     108  owl_list_free_all(&l, owl_free);
     109  owl_dict_free_all(&d, NULL);
     110
     111  /*  if (numfailed) printf("*** WARNING: failures encountered with owl_dict\n"); */
     112  printf("# END testing owl_dict (%d failures)\n", numfailed);
     113  return(numfailed);
     114}
     115
     116int owl_variable_regtest(void) {
     117  owl_vardict vd;
     118  int numfailed=0;
     119  char buf[1024];
     120  const void *v;
     121
     122  printf("# BEGIN testing owl_variable\n");
     123  FAIL_UNLESS("setup", 0==owl_variable_dict_setup(&vd));
     124
     125  FAIL_UNLESS("get bool", 0==owl_variable_get_bool(&vd,"rxping"));
     126  FAIL_UNLESS("get bool (no such)", -1==owl_variable_get_bool(&vd,"mumble"));
     127  FAIL_UNLESS("get bool as string 1", 0==owl_variable_get_tostring(&vd,"rxping", buf, 1024));
     128  FAIL_UNLESS("get bool as string 2", 0==strcmp(buf,"off"));
     129  FAIL_UNLESS("set bool 1", 0==owl_variable_set_bool_on(&vd,"rxping"));
     130  FAIL_UNLESS("get bool 2", 1==owl_variable_get_bool(&vd,"rxping"));
     131  FAIL_UNLESS("set bool 3", 0==owl_variable_set_fromstring(&vd,"rxping","off",0,0));
     132  FAIL_UNLESS("get bool 4", 0==owl_variable_get_bool(&vd,"rxping"));
     133  FAIL_UNLESS("set bool 5", -1==owl_variable_set_fromstring(&vd,"rxping","xxx",0,0));
     134  FAIL_UNLESS("get bool 6", 0==owl_variable_get_bool(&vd,"rxping"));
     135
     136
     137  FAIL_UNLESS("get string", 0==strcmp("~/zlog/people", owl_variable_get_string(&vd,"logpath")));
     138  FAIL_UNLESS("set string 7", 0==owl_variable_set_string(&vd,"logpath","whee"));
     139  FAIL_UNLESS("get string", 0==strcmp("whee", owl_variable_get_string(&vd,"logpath")));
     140
     141  FAIL_UNLESS("get int", 8==owl_variable_get_int(&vd,"typewinsize"));
     142  FAIL_UNLESS("get int (no such)", -1==owl_variable_get_int(&vd,"mmble"));
     143  FAIL_UNLESS("get int as string 1", 0==owl_variable_get_tostring(&vd,"typewinsize", buf, 1024));
     144  FAIL_UNLESS("get int as string 2", 0==strcmp(buf,"8"));
     145  FAIL_UNLESS("set int 1", 0==owl_variable_set_int(&vd,"typewinsize",12));
     146  FAIL_UNLESS("get int 2", 12==owl_variable_get_int(&vd,"typewinsize"));
     147  FAIL_UNLESS("set int 1b", -1==owl_variable_set_int(&vd,"typewinsize",-3));
     148  FAIL_UNLESS("get int 2b", 12==owl_variable_get_int(&vd,"typewinsize"));
     149  FAIL_UNLESS("set int 3", 0==owl_variable_set_fromstring(&vd,"typewinsize","9",0,0));
     150  FAIL_UNLESS("get int 4", 9==owl_variable_get_int(&vd,"typewinsize"));
     151  FAIL_UNLESS("set int 5", -1==owl_variable_set_fromstring(&vd,"typewinsize","xxx",0,0));
     152  FAIL_UNLESS("set int 6", -1==owl_variable_set_fromstring(&vd,"typewinsize","",0,0));
     153  FAIL_UNLESS("get int 7", 9==owl_variable_get_int(&vd,"typewinsize"));
     154
     155  owl_variable_dict_newvar_string(&vd, "stringvar", "", "", "testval");
     156  FAIL_UNLESS("get new string var", NULL != (v = owl_variable_get(&vd, "stringvar", OWL_VARIABLE_STRING)));
     157  FAIL_UNLESS("get new string val", !strcmp("testval", owl_variable_get_string(&vd, "stringvar")));
     158  owl_variable_set_string(&vd, "stringvar", "new val");
     159  FAIL_UNLESS("update string val", !strcmp("new val", owl_variable_get_string(&vd, "stringvar")));
     160
     161  owl_variable_dict_newvar_int(&vd, "intvar", "", "", 47);
     162  FAIL_UNLESS("get new int var", NULL != (v = owl_variable_get(&vd, "intvar", OWL_VARIABLE_INT)));
     163  FAIL_UNLESS("get new int val", 47 == owl_variable_get_int(&vd, "intvar"));
     164  owl_variable_set_int(&vd, "intvar", 17);
     165  FAIL_UNLESS("update bool val", 17 == owl_variable_get_int(&vd, "intvar"));
     166
     167  owl_variable_dict_newvar_bool(&vd, "boolvar", "", "", 1);
     168  FAIL_UNLESS("get new bool var", NULL != (v = owl_variable_get(&vd, "boolvar", OWL_VARIABLE_BOOL)));
     169  FAIL_UNLESS("get new bool val", owl_variable_get_bool(&vd, "boolvar"));
     170  owl_variable_set_bool_off(&vd, "boolvar");
     171  FAIL_UNLESS("update string val", !owl_variable_get_bool(&vd, "boolvar"));
     172
     173  owl_variable_dict_free(&vd);
     174
     175  /* if (numfailed) printf("*** WARNING: failures encountered with owl_variable\n"); */
     176  printf("# END testing owl_variable (%d failures)\n", numfailed);
     177  return(numfailed);
     178}
     179
     180int owl_filter_test_string(const char * filt, const owl_message *m, int shouldmatch) /* noproto */ {
     181  owl_filter f;
     182  int ok;
     183  int failed = 0;
     184  if(owl_filter_init_fromstring(&f, "test-filter", filt)) {
     185    printf("not ok can't parse %s\n", filt);
     186    failed = 1;
     187    goto out;
     188  }
     189  ok = owl_filter_message_match(&f, m);
     190  if((shouldmatch && !ok) || (!shouldmatch && ok)) {
     191    printf("not ok match %s (got %d, expected %d)\n", filt, ok, shouldmatch);
     192    failed = 1;
     193  }
     194 out:
     195  owl_filter_free(&f);
     196  if(!failed) {
     197    printf("ok %s %s\n", shouldmatch ? "matches" : "doesn't match", filt);
     198  }
     199  return failed;
     200}
     201
     202int owl_filter_regtest(void) {
     203  int numfailed=0;
     204  owl_message m;
     205  owl_filter f1, f2, f3, f4, f5;
     206
     207  owl_list_create(&(g.filterlist));
     208  owl_message_init(&m);
     209  owl_message_set_type_zephyr(&m);
     210  owl_message_set_direction_in(&m);
     211  owl_message_set_class(&m, "owl");
     212  owl_message_set_instance(&m, "tester");
     213  owl_message_set_sender(&m, "owl-user");
     214  owl_message_set_recipient(&m, "joe");
     215  owl_message_set_attribute(&m, "foo", "bar");
     216
     217#define TEST_FILTER(f, e) do {                          \
     218    numtests++;                                         \
     219    numfailed += owl_filter_test_string(f, &m, e);      \
     220      } while(0)
     221
     222  TEST_FILTER("true", 1);
     223  TEST_FILTER("false", 0);
     224  TEST_FILTER("( true )", 1);
     225  TEST_FILTER("not false", 1);
     226  TEST_FILTER("( true ) or ( false )", 1);
     227  TEST_FILTER("true and false", 0);
     228  TEST_FILTER("( true or true ) or ( ( false ) )", 1);
     229
     230  TEST_FILTER("class owl", 1);
     231  TEST_FILTER("class ^owl$", 1);
     232  TEST_FILTER("instance test", 1);
     233  TEST_FILTER("instance ^test$", 0);
     234  TEST_FILTER("instance ^tester$", 1);
     235
     236  TEST_FILTER("foo bar", 1);
     237  TEST_FILTER("class owl and instance tester", 1);
     238  TEST_FILTER("type ^zephyr$ and direction ^in$ and ( class ^owl$ or instance ^owl$ )", 1);
     239
     240  /* Order of operations and precedence */
     241  TEST_FILTER("not true or false", 0);
     242  TEST_FILTER("true or true and false", 0);
     243  TEST_FILTER("true and true and false or true", 1);
     244  TEST_FILTER("false and false or true", 1);
     245  TEST_FILTER("true and false or false", 0);
     246
     247  owl_filter_init_fromstring(&f1, "f1", "class owl");
     248  owl_global_add_filter(&g, &f1);
     249  TEST_FILTER("filter f1", 1);
     250
     251  /* Test recursion prevention */
     252  FAIL_UNLESS("self reference", owl_filter_init_fromstring(&f2, "test", "filter test"));
     253
     254  /* mutual recursion */
     255  owl_filter_init_fromstring(&f3, "f3", "filter f4");
     256  owl_global_add_filter(&g, &f3);
     257  FAIL_UNLESS("mutual recursion",   owl_filter_init_fromstring(&f4, "f4", "filter f3"));
     258
     259  /* support referencing a filter several times */
     260  FAIL_UNLESS("DAG", !owl_filter_init_fromstring(&f5, "dag", "filter f1 or filter f1"));
     261
     262  return 0;
     263}
     264
     265
     266int owl_obarray_regtest(void) {
     267  int numfailed = 0;
     268  const char *p,*p2;
     269
     270  owl_obarray oa;
     271  owl_obarray_init(&oa);
     272
     273  printf("# BEGIN testing owl_obarray\n");
     274
     275  p = owl_obarray_insert(&oa, "test");
     276  FAIL_UNLESS("returned string is equal", p && !strcmp(p, "test"));
     277  p2 = owl_obarray_insert(&oa, "test");
     278  FAIL_UNLESS("returned string is equal", p2 && !strcmp(p2, "test"));
     279  FAIL_UNLESS("returned the same string", p2 && p == p2);
     280
     281  p = owl_obarray_insert(&oa, "test2");
     282  FAIL_UNLESS("returned string is equal", p && !strcmp(p, "test2"));
     283  p2 = owl_obarray_find(&oa, "test2");
     284  FAIL_UNLESS("returned the same string", p2 && !strcmp(p2, "test2"));
     285
     286  p = owl_obarray_find(&oa, "nothere");
     287  FAIL_UNLESS("Didn't find a string that isn't there", p == NULL);
     288
     289  printf("# END testing owl_obarray (%d failures)\n", numfailed);
     290
     291  return numfailed;
     292}
Note: See TracChangeset for help on using the changeset viewer.