test/api/testlib.c

   1 /* $Id: testlib.c,v 1.35 2006-08-14 10:40:22 adam Exp $
   2    Copyright (C) 1995-2006
   3    Index Data ApS
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20
  21 */
  22
  23 /** testlib - utilities for the api tests */
  24
  25 #if HAVE_SYS_TIME_H
  26 #include <sys/time.h>
  27 #endif
  28 #if HAVE_SYS_RESOURCE_H
  29 #include <sys/resource.h>
  30 #endif
  31 #if HAVE_UNISTD_H
  32 #include <unistd.h>
  33 #endif
  34
  35 #include <assert.h>
  36 #include <yaz/log.h>
  37 #include <yaz/pquery.h>
  38 #include <idzebra/api.h>
  39 #include "testlib.h"
  40
  41 /** start_log: open a log file */
  42 /*    FIXME - parse command line arguments to set log levels etc */
  43 int log_level=0; /* not static, t*.c may use it */
  44
  45 void tl_start_log(int argc, char **argv)
  46 {
  47     int cmd_level = 0;
  48     char logname[2048];
  49     if (!argv)
  50         return;
  51     if (!argv[0])
  52         return;
  53     sprintf(logname, "%s.log", argv[0]);
  54 #if HAVE_UNISTD_H
  55     unlink(logname);
  56 #endif
  57     yaz_log_init_file(logname);
  58     if (argc >= 2)
  59         log_level = yaz_log_mask_str_x(argv[1], 0);
  60     if (argc >= 3)
  61         yaz_log_time_format(argv[2]);
  62     yaz_log_init_level(YLOG_DEFAULT_LEVEL | log_level | cmd_level);
  63     yaz_log(log_level, "starting %s", argv[0]);
  64 }
  65
  66 /**
  67  * tl_start_up : do common start things, and a zebra_start
  68  *    - nmem_init
  69  *    - build the name of logfile from argv[0], and open it
  70  *      if no argv passed, do not open a log
  71  *    - read zebra.cfg from env var srcdir if it exists; otherwise current dir
  72  *      default to zebra.cfg, if no name is given
  73  */
  74 ZebraService tl_start_up(char *cfgname, int argc, char **argv)
  75 {
  76 #if HAVE_SYS_RESOURCE_H
  77 #if HAVE_SYS_TIME_H
  78     struct rlimit rlim;
  79     rlim.rlim_cur = 60;
  80     rlim.rlim_max = 60;
  81     setrlimit(RLIMIT_CPU, &rlim);
  82 #endif
  83 #endif
  84     nmem_init();
  85     tl_start_log(argc, argv);
  86     return tl_zebra_start(cfgname);
  87 }
  88
  89 /**
  90  * get_srcdir: return env srcdir or . (if does does not exist)
  91  */
  92 const char *tl_get_srcdir()
  93 {
  94     const char *srcdir = getenv("srcdir");
  95     if (!srcdir || ! *srcdir)
  96         srcdir = ".";
  97     return srcdir;
  98
  99 }
 100 /** tl_zebra_start - do a zebra_start with a decent config name */
 101 ZebraService tl_zebra_start(const char *cfgname)
 102 {
 103     char cfg[256];
 104     const char *srcdir = tl_get_srcdir();
 105     if (!cfgname || ! *cfgname )
 106         cfgname="zebra.cfg";
 107
 108     sprintf(cfg, "%.200s/%.50s", srcdir, cfgname);
 109     return  zebra_start(cfg);
 110 }
 111
 112 /** tl_close_down closes down the zebra, logfile, nmem, xmalloc etc. logs an OK */
 113 int tl_close_down(ZebraHandle zh, ZebraService zs)
 114 {
 115     if (zh)
 116         zebra_close(zh);
 117     if (zs)
 118         zebra_stop(zs);
 119
 120     nmem_exit();
 121     xmalloc_trav("x");
 122     return 1;
 123 }
 124
 125 /** inits the database and inserts test data */
 126
 127 int tl_init_data(ZebraHandle zh, const char **recs)
 128 {
 129     ZEBRA_RES res;
 130
 131     if (!zh)
 132         return 0;
 133
 134     if (zebra_select_database(zh, "Default") != ZEBRA_OK)
 135         return 0;
 136
 137     yaz_log(log_level, "going to call init");
 138     res = zebra_init(zh);
 139     if (res == ZEBRA_FAIL)
 140     {
 141         yaz_log(log_level, "init_data: zebra_init failed with %d", res);
 142         printf("init_data failed with %d\n", res);
 143         return 0;
 144     }
 145     if (recs)
 146     {
 147         int i;
 148         if (zebra_begin_trans (zh, 1) != ZEBRA_OK)
 149             return 0;
 150         for (i = 0; recs[i]; i++)
 151             zebra_add_record(zh, recs[i], strlen(recs[i]));
 152         if (zebra_end_trans(zh) != ZEBRA_OK)
 153             return 0;
 154         zebra_commit(zh);
 155     }
 156     return 1;
 157 }
 158
 159 int tl_query_x(ZebraHandle zh, const char *query, zint exphits, int experror)
 160 {
 161     ODR odr;
 162     YAZ_PQF_Parser parser;
 163     Z_RPNQuery *rpn;
 164     const char *setname="rsetname";
 165     zint hits;
 166     ZEBRA_RES rc;
 167
 168     yaz_log(log_level, "======================================");
 169     yaz_log(log_level, "query: %s", query);
 170     odr = odr_createmem (ODR_DECODE);
 171     if (!odr)
 172         return 0;
 173
 174     parser = yaz_pqf_create();
 175     rpn = yaz_pqf_parse(parser, odr, query);
 176     yaz_pqf_destroy(parser);
 177     if (!rpn)
 178     {
 179         yaz_log(log_level, "could not parse pqf query %s\n", query);
 180         printf("could not parse pqf query %s\n", query);
 181         odr_destroy(odr);
 182         return 0;
 183     }
 184
 185     rc = zebra_search_RPN(zh, odr, rpn, setname, &hits);
 186     if (experror)
 187     {
 188         int code;
 189         if (rc != ZEBRA_FAIL)
 190         {
 191             yaz_log(log_level, "search returned %d (OK), but error was "
 192                     "expected", rc);
 193             printf("Error: search returned %d (OK), but error was expected\n"
 194                    "%s\n",  rc, query);
 195             return 0;
 196         }
 197         code = zebra_errCode(zh);
 198         if (code != experror)
 199         {
 200             yaz_log(log_level, "search returned error code %d, but error %d "
 201                     "was expected", code, experror);
 202             printf("Error: search returned error code %d, but error %d was "
 203                    "expected\n%s\n",
 204                    code, experror, query);
 205             return 0;
 206         }
 207     }
 208     else
 209     {
 210         if (rc == ZEBRA_FAIL) {
 211             int code = zebra_errCode(zh);
 212             yaz_log(log_level, "search returned %d. Code %d", rc, code);
 213
 214             printf("Error: search returned %d. Code %d\n%s\n", rc,
 215                    code, query);
 216             return 0;
 217         }
 218         if (exphits != -1 && hits != exphits)
 219         {
 220             yaz_log(log_level, "search returned " ZINT_FORMAT
 221                    " hits instead of " ZINT_FORMAT, hits, exphits);
 222             printf("Error: search returned " ZINT_FORMAT
 223                    " hits instead of " ZINT_FORMAT "\n%s\n",
 224                    hits, exphits, query);
 225             return 0;
 226         }
 227     }
 228     odr_destroy(odr);
 229     return 1;
 230 }
 231
 232
 233 int tl_query(ZebraHandle zh, const char *query, zint exphits)
 234 {
 235     return tl_query_x(zh, query, exphits, 0);
 236 }
 237
 238 int tl_scan(ZebraHandle zh, const char *query,
 239             int pos, int num,
 240             int exp_pos, int exp_num, int exp_partial,
 241             const char **exp_entries)
 242 {
 243     ODR odr = odr_createmem(ODR_ENCODE);
 244     ZebraScanEntry *entries = 0;
 245     int partial = -123;
 246     ZEBRA_RES res;
 247
 248     yaz_log(log_level, "======================================");
 249     yaz_log(log_level, "scan: pos=%d num=%d %s", pos, num, query);
 250
 251     res = zebra_scan_PQF(zh, odr, query, &pos, &num, &entries, &partial,
 252                          0 /* setname */);
 253     if (res != ZEBRA_OK)
 254     {
 255         printf("Error: scan returned %d (FAIL), but no error was expected\n"
 256                "%s\n",  res, query);
 257         return 0;
 258     }
 259     else
 260     {
 261         int fails = 0;
 262         if (partial == -123)
 263         {
 264             printf("Error: scan returned OK, but partial was not set\n"
 265                    "%s\n", query);
 266             fails++;
 267         }
 268         if (partial != exp_partial)
 269         {
 270             printf("Error: scan returned OK, with partial/expected %d/%d\n"
 271                    "%s\n", partial, exp_partial, query);
 272             fails++;
 273         }
 274         if (num != exp_num)
 275         {
 276             printf("Error: scan returned OK, with num/expected %d/%d\n"
 277                    "%s\n", num, exp_num, query);
 278             fails++;
 279         }
 280         if (pos != exp_pos)
 281         {
 282             printf("Error: scan returned OK, with pos/expected %d/%d\n"
 283                    "%s\n", pos, exp_pos, query);
 284             fails++;
 285         }
 286         if (fails)
 287             return 0;
 288         fails = 0;
 289         if (exp_entries)
 290         {
 291             int i;
 292             for (i = 0; i<num; i++)
 293             {
 294                 if (strcmp(exp_entries[i], entries[i].term))
 295                 {
 296                     printf("Error: scan OK, but entry %d term/exp %s/%s\n"
 297                            "%s\n",
 298                            i, entries[i].term, exp_entries[i], query);
 299                     fails++;
 300                 }
 301             }
 302         }
 303         if (fails)
 304             return 0;
 305     }
 306     odr_destroy(odr);
 307     return 1;
 308 }
 309
 310 /**
 311  * makes a query, checks number of hits, and for the first hit, that
 312  * it contains the given string, and that it gets the right score
 313  */
 314 int tl_ranking_query(ZebraHandle zh, char *query,
 315                      int exphits, char *firstrec, int firstscore)
 316 {
 317     ZebraRetrievalRecord retrievalRecord[10];
 318     ODR odr_output = odr_createmem (ODR_ENCODE);
 319     const char *setname="rsetname";
 320     int rc;
 321     int i;
 322
 323     if (!tl_query(zh, query, exphits))
 324         return 0;
 325
 326     for (i = 0; i<10; i++)
 327         retrievalRecord[i].position = i+1;
 328
 329     rc = zebra_records_retrieve (zh, odr_output, setname, 0,
 330                                  VAL_TEXT_XML, exphits, retrievalRecord);
 331     if (rc != ZEBRA_OK)
 332         return 0;
 333
 334     if (!strstr(retrievalRecord[0].buf, firstrec))
 335     {
 336         printf("Error: Got the wrong record first\n");
 337         printf("Expected '%s' but got\n", firstrec);
 338         printf("%.*s\n", retrievalRecord[0].len, retrievalRecord[0].buf);
 339         return 0;
 340     }
 341
 342     if (retrievalRecord[0].score != firstscore)
 343     {
 344         printf("Error: first rec got score %d instead of %d\n",
 345                retrievalRecord[0].score, firstscore);
 346         return 0;
 347     }
 348     odr_destroy (odr_output);
 349     return 1;
 350 }
 351
 352 int tl_meta_query(ZebraHandle zh, char *query, int exphits,
 353                   zint *ids)
 354 {
 355     ZebraMetaRecord *meta;
 356     ODR odr_output = odr_createmem (ODR_ENCODE);
 357     const char *setname="rsetname";
 358     zint *positions = (zint *) malloc(1 + (exphits * sizeof(zint)));
 359     int i;
 360
 361     if (!tl_query(zh, query, exphits))
 362         return 0;
 363
 364     for (i = 0; i<exphits; i++)
 365         positions[i] = i+1;
 366
 367     meta = zebra_meta_records_create (zh, setname,  exphits, positions);
 368
 369     if (!meta)
 370     {
 371         printf("Error: retrieve returned error\n%s\n", query);
 372         return 0;
 373     }
 374
 375     for (i = 0; i<exphits; i++)
 376     {
 377         if (meta[i].sysno != ids[i])
 378         {
 379             printf("Expected id=" ZINT_FORMAT " but got id=" ZINT_FORMAT "\n",
 380                    ids[i], meta[i].sysno);
 381             return 0;
 382         }
 383     }
 384     zebra_meta_records_destroy(zh, meta, exphits);
 385     odr_destroy (odr_output);
 386     free(positions);
 387     return 1;
 388 }
 389
 390 int tl_sort(ZebraHandle zh, const char *query, zint hits, zint *exp)
 391 {
 392     ZebraMetaRecord *recs;
 393     zint i;
 394     int errs = 0;
 395     zint min_val_recs = 0;
 396     zint min_val_exp = 0;
 397
 398     assert(query);
 399     if (!tl_query(zh, query, hits))
 400         return 0;
 401
 402     recs = zebra_meta_records_create_range (zh, "rsetname", 1, 4);
 403     if (!recs)
 404         return 0;
 405
 406     /* find min for each sequence to get proper base offset */
 407     for (i = 0; i<hits; i++)
 408     {
 409         if (min_val_recs == 0 || recs[i].sysno < min_val_recs)
 410             min_val_recs = recs[i].sysno;
 411         if (min_val_exp == 0 || exp[i] < min_val_exp)
 412             min_val_exp = exp[i];
 413     }
 414
 415     /* compare sequences using base offset */
 416     for (i = 0; i<hits; i++)
 417         if ((recs[i].sysno-min_val_recs) != (exp[i]-min_val_exp))
 418             errs++;
 419     if (errs)
 420     {
 421         printf("Sequence not in right order for query\n%s\ngot exp\n",
 422                query);
 423         for (i = 0; i<hits; i++)
 424             printf(" " ZINT_FORMAT "   " ZINT_FORMAT "\n",
 425                    recs[i].sysno, exp[i]);
 426     }
 427     zebra_meta_records_destroy (zh, recs, 4);
 428
 429     if (errs)
 430         return 0;
 431     return 1;
 432 }
 433
 434
 435 struct finfo {
 436     const char *name;
 437     int occurred;
 438 };
 439
 440 static void filter_cb(void *cd, const char *name)
 441 {
 442     struct finfo *f = (struct finfo*) cd;
 443     if (!strcmp(f->name, name))
 444         f->occurred = 1;
 445 }
 446
 447 void tl_check_filter(ZebraService zs, const char *name)
 448 {
 449     struct finfo f;
 450
 451     f.name = name;
 452     f.occurred = 0;
 453     zebra_filter_info(zs, &f, filter_cb);
 454     if (!f.occurred)
 455     {
 456         yaz_log(YLOG_WARN, "Filter %s does not exist.", name);
 457         exit(0);
 458     }
 459 }
 460
 461
 462
 463
 464 /*
 465  * Local variables:
 466  * c-basic-offset: 4
 467  * indent-tabs-mode: nil
 468  * End:
 469  * vim: shiftwidth=4 tabstop=8 expandtab
 470  */
 471