test/api/testlib.c

   1 /* $Id: testlib.c,v 1.31 2006-04-04 00:02:34 adam Exp $
   2    Copyright (C) 1995-2005
   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 Zebra; see the file LICENSE.zebra.  If not, write to the
  19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  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 = 20;
  80     rlim.rlim_max = 20;
  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         odr_destroy(odr);
 180         return 0;
 181     }
 182
 183     rc = zebra_search_RPN(zh, odr, rpn, setname, &hits);
 184     if (experror)
 185     {
 186         int code;
 187         if (rc != ZEBRA_FAIL)
 188         {
 189             yaz_log(log_level, "search returned %d (OK), but error was "
 190                     "expected", rc);
 191             printf("Error: search returned %d (OK), but error was expected\n"
 192                    "%s\n",  rc, query);
 193             return 0;
 194         }
 195         code = zebra_errCode(zh);
 196         if (code != experror)
 197         {
 198             yaz_log(log_level, "search returned error code %d, but error %d "
 199                     "was expected", code, experror);
 200             printf("Error: search returned error code %d, but error %d was "
 201                    "expected\n%s\n",
 202                    code, experror, query);
 203             return 0;
 204         }
 205     }
 206     else
 207     {
 208         if (rc == ZEBRA_FAIL) {
 209             int code = zebra_errCode(zh);
 210             yaz_log(log_level, "search returned %d. Code %d", rc, code);
 211
 212             printf("Error: search returned %d. Code %d\n%s\n", rc,
 213                    code, query);
 214             return 0;
 215         }
 216         if (exphits != -1 && hits != exphits)
 217         {
 218             yaz_log(log_level, "search returned " ZINT_FORMAT
 219                    " hits instead of " ZINT_FORMAT, hits, exphits);
 220             printf("Error: search returned " ZINT_FORMAT
 221                    " hits instead of " ZINT_FORMAT "\n%s\n",
 222                    hits, exphits, query);
 223             return 0;
 224         }
 225     }
 226     odr_destroy(odr);
 227     return 1;
 228 }
 229
 230
 231 int tl_query(ZebraHandle zh, const char *query, zint exphits)
 232 {
 233     return tl_query_x(zh, query, exphits, 0);
 234 }
 235
 236 int tl_scan(ZebraHandle zh, const char *query,
 237             int pos, int num,
 238             int exp_pos, int exp_num, int exp_partial,
 239             const char **exp_entries)
 240 {
 241     ODR odr = odr_createmem(ODR_ENCODE);
 242     ZebraScanEntry *entries = 0;
 243     int partial = -123;
 244     ZEBRA_RES res;
 245
 246     yaz_log(log_level, "======================================");
 247     yaz_log(log_level, "scan: pos=%d num=%d %s", pos, num, query);
 248
 249     res = zebra_scan_PQF(zh, odr, query, &pos, &num, &entries, &partial,
 250                          0 /* setname */);
 251     if (res != ZEBRA_OK)
 252     {
 253         printf("Error: scan returned %d (FAIL), but no error was expected\n"
 254                "%s\n",  res, query);
 255         return 0;
 256     }
 257     else
 258     {
 259         int fails = 0;
 260         if (partial == -123)
 261         {
 262             printf("Error: scan returned OK, but partial was not set\n"
 263                    "%s\n", query);
 264             fails++;
 265         }
 266         if (partial != exp_partial)
 267         {
 268             printf("Error: scan returned OK, with partial/expected %d/%d\n"
 269                    "%s\n", partial, exp_partial, query);
 270             fails++;
 271         }
 272         if (num != exp_num)
 273         {
 274             printf("Error: scan returned OK, with num/expected %d/%d\n"
 275                    "%s\n", num, exp_num, query);
 276             fails++;
 277         }
 278         if (pos != exp_pos)
 279         {
 280             printf("Error: scan returned OK, with pos/expected %d/%d\n"
 281                    "%s\n", pos, exp_pos, query);
 282             fails++;
 283         }
 284         if (fails)
 285             return 0;
 286         fails = 0;
 287         if (exp_entries)
 288         {
 289             int i;
 290             for (i = 0; i<num; i++)
 291             {
 292                 if (strcmp(exp_entries[i], entries[i].term))
 293                 {
 294                     printf("Error: scan OK, but entry %d term/exp %s/%s\n"
 295                            "%s\n",
 296                            i, entries[i].term, exp_entries[i], query);
 297                     fails++;
 298                 }
 299             }
 300         }
 301         if (fails)
 302             return 0;
 303     }
 304     odr_destroy(odr);
 305     return 1;
 306 }
 307
 308 /**
 309  * makes a query, checks number of hits, and for the first hit, that
 310  * it contains the given string, and that it gets the right score
 311  */
 312 int tl_ranking_query(ZebraHandle zh, char *query,
 313                      int exphits, char *firstrec, int firstscore)
 314 {
 315     ZebraRetrievalRecord retrievalRecord[10];
 316     ODR odr_output = odr_createmem (ODR_ENCODE);
 317     const char *setname="rsetname";
 318     int rc;
 319     int i;
 320
 321     if (!tl_query(zh, query, exphits))
 322         return 0;
 323
 324     for (i = 0; i<10; i++)
 325         retrievalRecord[i].position = i+1;
 326
 327     rc = zebra_records_retrieve (zh, odr_output, setname, 0,
 328                                  VAL_TEXT_XML, exphits, retrievalRecord);
 329     if (rc != ZEBRA_OK)
 330         return 0;
 331
 332     if (!strstr(retrievalRecord[0].buf, firstrec))
 333     {
 334         printf("Error: Got the wrong record first\n");
 335         printf("Expected '%s' but got\n", firstrec);
 336         printf("%.*s\n", retrievalRecord[0].len, retrievalRecord[0].buf);
 337         return 0;
 338     }
 339
 340     if (retrievalRecord[0].score != firstscore)
 341     {
 342         printf("Error: first rec got score %d instead of %d\n",
 343                retrievalRecord[0].score, firstscore);
 344         return 0;
 345     }
 346     odr_destroy (odr_output);
 347     return 1;
 348 }
 349
 350 int tl_meta_query(ZebraHandle zh, char *query, int exphits,
 351                   zint *ids)
 352 {
 353     ZebraMetaRecord *meta;
 354     ODR odr_output = odr_createmem (ODR_ENCODE);
 355     const char *setname="rsetname";
 356     zint *positions = (zint *) malloc(1 + (exphits * sizeof(zint)));
 357     int i;
 358
 359     if (!tl_query(zh, query, exphits))
 360         return 0;
 361
 362     for (i = 0; i<exphits; i++)
 363         positions[i] = i+1;
 364
 365     meta = zebra_meta_records_create (zh, setname,  exphits, positions);
 366
 367     if (!meta)
 368     {
 369         printf("Error: retrieve returned error\n%s\n", query);
 370         return 0;
 371     }
 372
 373     for (i = 0; i<exphits; i++)
 374     {
 375         if (meta[i].sysno != ids[i])
 376         {
 377             printf("Expected id=" ZINT_FORMAT " but got id=" ZINT_FORMAT "\n",
 378                    ids[i], meta[i].sysno);
 379             return 0;
 380         }
 381     }
 382     zebra_meta_records_destroy(zh, meta, exphits);
 383     odr_destroy (odr_output);
 384     free(positions);
 385     return 1;
 386 }
 387
 388 int tl_sort(ZebraHandle zh, const char *query, zint hits, zint *exp)
 389 {
 390     ZebraMetaRecord *recs;
 391     zint i;
 392     int errs = 0;
 393     zint min_val_recs = 0;
 394     zint min_val_exp = 0;
 395
 396     assert(query);
 397     if (!tl_query(zh, query, hits))
 398         return 0;
 399
 400     recs = zebra_meta_records_create_range (zh, "rsetname", 1, 4);
 401     if (!recs)
 402         return 0;
 403
 404     /* find min for each sequence to get proper base offset */
 405     for (i = 0; i<hits; i++)
 406     {
 407         if (min_val_recs == 0 || recs[i].sysno < min_val_recs)
 408             min_val_recs = recs[i].sysno;
 409         if (min_val_exp == 0 || exp[i] < min_val_exp)
 410             min_val_exp = exp[i];
 411     }
 412
 413     /* compare sequences using base offset */
 414     for (i = 0; i<hits; i++)
 415         if ((recs[i].sysno-min_val_recs) != (exp[i]-min_val_exp))
 416             errs++;
 417     if (errs)
 418     {
 419         printf("Sequence not in right order for query\n%s\ngot exp\n",
 420                query);
 421         for (i = 0; i<hits; i++)
 422             printf(" " ZINT_FORMAT "   " ZINT_FORMAT "\n",
 423                    recs[i].sysno, exp[i]);
 424     }
 425     zebra_meta_records_destroy (zh, recs, 4);
 426
 427     if (errs)
 428         return 0;
 429     return 1;
 430 }
 431
 432
 433 struct finfo {
 434     const char *name;
 435     int occurred;
 436 };
 437
 438 static void filter_cb(void *cd, const char *name)
 439 {
 440     struct finfo *f = (struct finfo*) cd;
 441     if (!strcmp(f->name, name))
 442         f->occurred = 1;
 443 }
 444
 445 void tl_check_filter(ZebraService zs, const char *name)
 446 {
 447     struct finfo f;
 448
 449     f.name = name;
 450     f.occurred = 0;
 451     zebra_filter_info(zs, &f, filter_cb);
 452     if (!f.occurred)
 453     {
 454         yaz_log(YLOG_WARN, "Filter %s does not exist.", name);
 455         exit(0);
 456     }
 457 }
 458
 459
 460
 461