ext/testcase.c

   1 /*
   2  * Copyright (c) 2012, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <limits.h>
  11 #include <fcntl.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <errno.h>
  16
  17 #include "pool.h"
  18 #include "poolarch.h"
  19 #include "poolvendor.h"
  20 #include "repo.h"
  21 #include "repo_solv.h"
  22 #include "solver.h"
  23 #include "solverdebug.h"
  24 #include "chksum.h"
  25 #include "testcase.h"
  26 #include "selection.h"
  27 #include "solv_xfopen.h"
  28
  29 #define DISABLE_JOIN2
  30 #include "tools_util.h"
  31
  32 static struct job2str {
  33   Id job;
  34   const char *str;
  35 } job2str[] = {
  36   { SOLVER_NOOP,           "noop" },
  37   { SOLVER_INSTALL,        "install" },
  38   { SOLVER_ERASE,          "erase" },
  39   { SOLVER_UPDATE,         "update" },
  40   { SOLVER_WEAKENDEPS,     "weakendeps" },
  41   { SOLVER_MULTIVERSION,   "multiversion" },
  42   { SOLVER_MULTIVERSION,   "noobsoletes" },     /* old name */
  43   { SOLVER_LOCK,           "lock" },
  44   { SOLVER_DISTUPGRADE,    "distupgrade" },
  45   { SOLVER_VERIFY,         "verify" },
  46   { SOLVER_DROP_ORPHANED,  "droporphaned" },
  47   { SOLVER_USERINSTALLED,  "userinstalled" },
  48   { SOLVER_ALLOWUNINSTALL, "allowuninstall" },
  49   { 0, 0 }
  50 };
  51
  52 static struct jobflags2str {
  53   Id flag;
  54   const char *str;
  55 } jobflags2str[] = {
  56   { SOLVER_WEAK,      "weak" },
  57   { SOLVER_ESSENTIAL, "essential" },
  58   { SOLVER_CLEANDEPS, "cleandeps" },
  59   { SOLVER_ORUPDATE,  "orupdate" },
  60   { SOLVER_FORCEBEST, "forcebest" },
  61   { SOLVER_TARGETED,  "targeted" },
  62   { SOLVER_NOTBYUSER, "notbyuser" },
  63   { SOLVER_SETEV,     "setev" },
  64   { SOLVER_SETEVR,    "setevr" },
  65   { SOLVER_SETARCH,   "setarch" },
  66   { SOLVER_SETVENDOR, "setvendor" },
  67   { SOLVER_SETREPO,   "setrepo" },
  68   { SOLVER_NOAUTOSET, "noautoset" },
  69   { 0, 0 }
  70 };
  71
  72 static struct resultflags2str {
  73   Id flag;
  74   const char *str;
  75 } resultflags2str[] = {
  76   { TESTCASE_RESULT_TRANSACTION,        "transaction" },
  77   { TESTCASE_RESULT_PROBLEMS,           "problems" },
  78   { TESTCASE_RESULT_ORPHANED,           "orphaned" },
  79   { TESTCASE_RESULT_RECOMMENDED,        "recommended" },
  80   { TESTCASE_RESULT_UNNEEDED,           "unneeded" },
  81   { TESTCASE_RESULT_ALTERNATIVES,       "alternatives" },
  82   { TESTCASE_RESULT_RULES,              "rules" },
  83   { TESTCASE_RESULT_GENID,              "genid" },
  84   { 0, 0 }
  85 };
  86
  87 static struct solverflags2str {
  88   Id flag;
  89   const char *str;
  90   int def;
  91 } solverflags2str[] = {
  92   { SOLVER_FLAG_ALLOW_DOWNGRADE,            "allowdowngrade", 0 },
  93   { SOLVER_FLAG_ALLOW_NAMECHANGE,           "allownamechange", 1 },
  94   { SOLVER_FLAG_ALLOW_ARCHCHANGE,           "allowarchchange", 0 },
  95   { SOLVER_FLAG_ALLOW_VENDORCHANGE,         "allowvendorchange", 0 },
  96   { SOLVER_FLAG_ALLOW_UNINSTALL,            "allowuninstall", 0 },
  97   { SOLVER_FLAG_NO_UPDATEPROVIDE,           "noupdateprovide", 0 },
  98   { SOLVER_FLAG_SPLITPROVIDES,              "splitprovides", 0 },
  99   { SOLVER_FLAG_IGNORE_RECOMMENDED,         "ignorerecommended", 0 },
 100   { SOLVER_FLAG_ADD_ALREADY_RECOMMENDED,    "addalreadyrecommended", 0 },
 101   { SOLVER_FLAG_NO_INFARCHCHECK,            "noinfarchcheck", 0 },
 102   { SOLVER_FLAG_KEEP_EXPLICIT_OBSOLETES,    "keepexplicitobsoletes", 0 },
 103   { SOLVER_FLAG_BEST_OBEY_POLICY,           "bestobeypolicy", 0 },
 104   { SOLVER_FLAG_NO_AUTOTARGET,              "noautotarget", 0 },
 105   { SOLVER_FLAG_DUP_ALLOW_DOWNGRADE,        "dupallowdowngrade", 1 },
 106   { SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE,       "dupallowarchchange", 1 },
 107   { SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE,     "dupallowvendorchange", 1 },
 108   { SOLVER_FLAG_DUP_ALLOW_NAMECHANGE,       "dupallownamechange", 1 },
 109   { SOLVER_FLAG_KEEP_ORPHANS,               "keeporphans", 0 },
 110   { SOLVER_FLAG_BREAK_ORPHANS,              "breakorphans", 0 },
 111   { SOLVER_FLAG_FOCUS_INSTALLED,            "focusinstalled", 0 },
 112   { SOLVER_FLAG_YUM_OBSOLETES,              "yumobsoletes", 0 },
 113   { SOLVER_FLAG_NEED_UPDATEPROVIDE,         "needupdateprovide", 0 },
 114   { 0, 0, 0 }
 115 };
 116
 117 static struct poolflags2str {
 118   Id flag;
 119   const char *str;
 120   int def;
 121 } poolflags2str[] = {
 122   { POOL_FLAG_PROMOTEEPOCH,                 "promoteepoch", 0 },
 123   { POOL_FLAG_FORBIDSELFCONFLICTS,          "forbidselfconflicts", 0 },
 124   { POOL_FLAG_OBSOLETEUSESPROVIDES,         "obsoleteusesprovides", 0 },
 125   { POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES, "implicitobsoleteusesprovides", 0 },
 126   { POOL_FLAG_OBSOLETEUSESCOLORS,           "obsoleteusescolors", 0 },
 127   { POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS,   "implicitobsoleteusescolors", 0 },
 128   { POOL_FLAG_NOINSTALLEDOBSOLETES,         "noinstalledobsoletes", 0 },
 129   { POOL_FLAG_HAVEDISTEPOCH,                "havedistepoch", 0 },
 130   { POOL_FLAG_NOOBSOLETESMULTIVERSION,      "noobsoletesmultiversion", 0 },
 131   { POOL_FLAG_ADDFILEPROVIDESFILTERED,      "addfileprovidesfiltered", 0 },
 132   { POOL_FLAG_NOWHATPROVIDESAUX,            "nowhatprovidesaux", 0 },
 133   { 0, 0, 0 }
 134 };
 135
 136 static struct disttype2str {
 137   Id type;
 138   const char *str;
 139 } disttype2str[] = {
 140   { DISTTYPE_RPM,  "rpm" },
 141   { DISTTYPE_DEB,  "deb" },
 142   { DISTTYPE_ARCH, "arch" },
 143   { DISTTYPE_HAIKU, "haiku" },
 144   { 0, 0 }
 145 };
 146
 147 static struct selflags2str {
 148   Id flag;
 149   const char *str;
 150 } selflags2str[] = {
 151   { SELECTION_NAME, "name" },
 152   { SELECTION_PROVIDES, "provides" },
 153   { SELECTION_FILELIST, "filelist" },
 154   { SELECTION_CANON, "canon" },
 155   { SELECTION_DOTARCH, "dotarch" },
 156   { SELECTION_REL, "rel" },
 157   { SELECTION_INSTALLED_ONLY, "installedonly" },
 158   { SELECTION_GLOB, "glob" },
 159   { SELECTION_FLAT, "flat" },
 160   { SELECTION_NOCASE, "nocase" },
 161   { SELECTION_SOURCE_ONLY, "sourceonly" },
 162   { SELECTION_WITH_SOURCE, "withsource" },
 163   { 0, 0 }
 164 };
 165
 166 static const char *features[] = {
 167 #ifdef ENABLE_LINKED_PKGS
 168   "linked_packages",
 169 #endif
 170 #ifdef ENABLE_COMPLEX_DEPS
 171   "complex_deps",
 172 #endif
 173   0
 174 };
 175
 176 typedef struct strqueue {
 177   char **str;
 178   int nstr;
 179 } Strqueue;
 180
 181 #define STRQUEUE_BLOCK 63
 182
 183 static void
 184 strqueue_init(Strqueue *q)
 185 {
 186   q->str = 0;
 187   q->nstr = 0;
 188 }
 189
 190 static void
 191 strqueue_free(Strqueue *q)
 192 {
 193   int i;
 194   for (i = 0; i < q->nstr; i++)
 195     solv_free(q->str[i]);
 196   q->str = solv_free(q->str);
 197   q->nstr = 0;
 198 }
 199
 200 static void
 201 strqueue_push(Strqueue *q, const char *s)
 202 {
 203   q->str = solv_extend(q->str, q->nstr, 1, sizeof(*q->str), STRQUEUE_BLOCK);
 204   q->str[q->nstr++] = solv_strdup(s);
 205 }
 206
 207 static void
 208 strqueue_pushjoin(Strqueue *q, const char *s1, const char *s2, const char *s3)
 209 {
 210   q->str = solv_extend(q->str, q->nstr, 1, sizeof(*q->str), STRQUEUE_BLOCK);
 211   q->str[q->nstr++] = solv_dupjoin(s1, s2, s3);
 212 }
 213
 214 static int
 215 strqueue_sort_cmp(const void *ap, const void *bp, void *dp)
 216 {
 217   const char *a = *(const char **)ap;
 218   const char *b = *(const char **)bp;
 219   return strcmp(a ? a : "", b ? b : "");
 220 }
 221
 222 static void
 223 strqueue_sort(Strqueue *q)
 224 {
 225   if (q->nstr > 1)
 226     solv_sort(q->str, q->nstr, sizeof(*q->str), strqueue_sort_cmp, 0);
 227 }
 228
 229 static void
 230 strqueue_sort_u(Strqueue *q)
 231 {
 232   int i, j;
 233   strqueue_sort(q);
 234   for (i = j = 0; i < q->nstr; i++)
 235     if (!j || strqueue_sort_cmp(q->str + i, q->str + j - 1, 0) != 0)
 236       q->str[j++] = q->str[i];
 237   q->nstr = j;
 238 }
 239
 240 static char *
 241 strqueue_join(Strqueue *q)
 242 {
 243   int i, l = 0;
 244   char *r, *rp;
 245   for (i = 0; i < q->nstr; i++)
 246     if (q->str[i])
 247       l += strlen(q->str[i]) + 1;
 248   l++;  /* trailing \0 */
 249   r = solv_malloc(l);
 250   rp = r;
 251   for (i = 0; i < q->nstr; i++)
 252     if (q->str[i])
 253       {
 254         strcpy(rp, q->str[i]);
 255         rp += strlen(rp);
 256         *rp++ = '\n';
 257       }
 258   *rp = 0;
 259   return r;
 260 }
 261
 262 static void
 263 strqueue_split(Strqueue *q, const char *s)
 264 {
 265   const char *p;
 266   if (!s)
 267     return;
 268   while ((p = strchr(s, '\n')) != 0)
 269     {
 270       q->str = solv_extend(q->str, q->nstr, 1, sizeof(*q->str), STRQUEUE_BLOCK);
 271       q->str[q->nstr] = solv_malloc(p - s + 1);
 272       if (p > s)
 273         memcpy(q->str[q->nstr], s, p - s);
 274       q->str[q->nstr][p - s] = 0;
 275       q->nstr++;
 276       s = p + 1;
 277     }
 278   if (*s)
 279     strqueue_push(q, s);
 280 }
 281
 282 static void
 283 strqueue_diff(Strqueue *sq1, Strqueue *sq2, Strqueue *osq)
 284 {
 285   int i = 0, j = 0;
 286   while (i < sq1->nstr && j < sq2->nstr)
 287     {
 288       int r = strqueue_sort_cmp(sq1->str + i, sq2->str + j, 0);
 289       if (!r)
 290         i++, j++;
 291       else if (r < 0)
 292         strqueue_pushjoin(osq, "-", sq1->str[i++], 0);
 293       else
 294         strqueue_pushjoin(osq, "+", sq2->str[j++], 0);
 295     }
 296   while (i < sq1->nstr)
 297     strqueue_pushjoin(osq, "-", sq1->str[i++], 0);
 298   while (j < sq2->nstr)
 299     strqueue_pushjoin(osq, "+", sq2->str[j++], 0);
 300 }
 301
 302
 303 static const char *
 304 testcase_id2str(Pool *pool, Id id, int isname)
 305 {
 306   const char *s = pool_id2str(pool, id);
 307   const char *ss;
 308   char *s2, *s2p;
 309   int bad = 0, paren = 0, parenbad = 0;
 310
 311   if (id == 0)
 312     return "<NULL>";
 313   if (id == 1)
 314     return "\\00";
 315   if (strchr("[(<=>!", *s))
 316     bad++;
 317   if (!strncmp(s, "namespace:", 10))
 318     bad++;
 319   for (ss = s + bad; *ss; ss++)
 320     {
 321       if (*ss == ' ' || *ss == '\\' || *(unsigned char *)ss < 32 || *ss == '(' || *ss == ')')
 322         bad++;
 323       if (*ss == '(')
 324         paren = paren == 0 ? 1 : -1;
 325       else if (*ss == ')')
 326         {
 327           paren = paren == 1 ? 0 : -1;
 328           if (!paren)
 329             parenbad += 2;
 330         }
 331     }
 332   if (isname && ss - s > 4 && !strcmp(ss - 4, ":any"))
 333     bad++;
 334   if (!paren && !(bad - parenbad))
 335     return s;
 336
 337   /* we need escaping! */
 338   s2 = s2p = pool_alloctmpspace(pool, strlen(s) + bad * 2 + 1);
 339   if (!strncmp(s, "namespace:", 10))
 340     {
 341       strcpy(s2p, "namespace\\3a");
 342       s2p += 12;
 343       s += 10;
 344     }
 345   ss = s;
 346   for (; *ss; ss++)
 347     {
 348       *s2p++ = *ss;
 349       if ((ss == s && strchr("[(<=>!", *s)) || *ss == ' ' || *ss == '\\' || *(unsigned char *)ss < 32 || *ss == '(' || *ss == ')')
 350         {
 351           s2p[-1] = '\\';
 352           solv_bin2hex((unsigned char *)ss, 1, s2p);
 353           s2p += 2;
 354         }
 355     }
 356   *s2p = 0;
 357   if (isname && s2p - s2 > 4 && !strcmp(s2p - 4, ":any"))
 358     strcpy(s2p - 4, "\\3aany");
 359   return s2;
 360 }
 361
 362 struct oplist {
 363   Id flags;
 364   const char *opname;
 365 } oplist[] = {
 366   { REL_EQ, "=" },
 367   { REL_GT | REL_LT | REL_EQ, "<=>" },
 368   { REL_LT | REL_EQ, "<=" },
 369   { REL_GT | REL_EQ, ">=" },
 370   { REL_GT, ">" },
 371   { REL_GT | REL_LT, "<>" },
 372   { REL_AND,   "&" },
 373   { REL_OR ,   "|" },
 374   { REL_WITH , "+" },
 375   { REL_NAMESPACE , "<NAMESPACE>" },
 376   { REL_ARCH,       "." },
 377   { REL_MULTIARCH,  "<MULTIARCH>" },
 378   { REL_FILECONFLICT,  "<FILECONFLICT>" },
 379   { REL_COND,  "<IF>" },
 380   { REL_COMPAT,  "compat >=" },
 381   { REL_KIND,  "<KIND>" },
 382   { REL_ELSE, "<ELSE>" },
 383   { REL_LT, "<" },
 384   { 0, 0 }
 385 };
 386
 387 static const char *
 388 testcase_dep2str_complex(Pool *pool, Id id, int addparens)
 389 {
 390   Reldep *rd;
 391   char *s;
 392   const char *s2;
 393   int needparens;
 394   struct oplist *op;
 395
 396   if (!ISRELDEP(id))
 397     return testcase_id2str(pool, id, 1);
 398   rd = GETRELDEP(pool, id);
 399
 400   /* check for special shortcuts */
 401   if (rd->flags == REL_NAMESPACE && !ISRELDEP(rd->name) && !strncmp(pool_id2str(pool, rd->name), "namespace:", 10))
 402     {
 403       const char *ns = pool_id2str(pool, rd->name);
 404       int nslen = strlen(ns);
 405       /* special namespace formatting */
 406       const char *evrs = testcase_dep2str_complex(pool, rd->evr, 0);
 407       s = pool_tmpappend(pool, evrs, ns, "()");
 408       memmove(s + nslen + 1, s, strlen(s) - nslen - 2);
 409       memcpy(s, ns, nslen);
 410       s[nslen] = '(';
 411       return s;
 412     }
 413   if (rd->flags == REL_MULTIARCH && !ISRELDEP(rd->name) && rd->evr == ARCH_ANY)
 414     {
 415       /* special :any suffix */
 416       const char *ns = testcase_id2str(pool, rd->name, 1);
 417       return pool_tmpappend(pool, ns, ":any", 0);
 418     }
 419
 420   needparens = 0;
 421   if (ISRELDEP(rd->name))
 422     {
 423       Reldep *rd2 = GETRELDEP(pool, rd->name);
 424       needparens = 1;
 425       if (rd->flags > 7 && rd->flags != REL_COMPAT && rd2->flags && rd2->flags <= 7)
 426         needparens = 0;
 427     }
 428   s = (char *)testcase_dep2str_complex(pool, rd->name, needparens);
 429
 430   if (addparens)
 431     {
 432       s = pool_tmpappend(pool, s, "(", 0);
 433       memmove(s + 1, s, strlen(s + 1));
 434       s[0] = '(';
 435     }
 436   for (op = oplist; op->flags; op++)
 437     if (rd->flags == op->flags)
 438       break;
 439   if (op->flags)
 440     {
 441       s = pool_tmpappend(pool, s, " ", op->opname);
 442       s = pool_tmpappend(pool, s, " ", 0);
 443     }
 444   else
 445     {
 446       char buf[64];
 447       sprintf(buf, " <%u> ", rd->flags);
 448       s = pool_tmpappend(pool, s, buf, 0);
 449     }
 450
 451   needparens = 0;
 452   if (ISRELDEP(rd->evr))
 453     {
 454       Reldep *rd2 = GETRELDEP(pool, rd->evr);
 455       needparens = 1;
 456       if (rd->flags > 7 && rd2->flags && rd2->flags <= 7)
 457         needparens = 0;
 458       if (rd->flags == REL_AND && rd2->flags == REL_AND)
 459         needparens = 0; /* chain */
 460       if (rd->flags == REL_OR && rd2->flags == REL_OR)
 461         needparens = 0; /* chain */
 462       if (rd->flags > 0 && rd->flags < 8 && rd2->flags == REL_COMPAT)
 463         needparens = 0; /* chain */
 464     }
 465   if (!ISRELDEP(rd->evr))
 466     s2 = testcase_id2str(pool, rd->evr, 0);
 467   else
 468     s2 = testcase_dep2str_complex(pool, rd->evr, needparens);
 469   if (addparens)
 470     s = pool_tmpappend(pool, s, s2, ")");
 471   else
 472     s = pool_tmpappend(pool, s, s2, 0);
 473   pool_freetmpspace(pool, s2);
 474   return s;
 475 }
 476
 477 const char *
 478 testcase_dep2str(Pool *pool, Id id)
 479 {
 480   return testcase_dep2str_complex(pool, id, 0);
 481 }
 482
 483
 484 /* Convert a simple string. Also handle the :any suffix */
 485 static Id
 486 testcase_str2dep_simple(Pool *pool, const char **sp, int isname)
 487 {
 488   int haveesc = 0;
 489   int paren = 0;
 490   int isany = 0;
 491   Id id;
 492   const char *s;
 493   for (s = *sp; *s; s++)
 494     {
 495       if (*s == '\\')
 496         haveesc++;
 497       if (*s == ' ' || *(unsigned char *)s < 32)
 498         break;
 499       if (*s == '(')
 500         paren++;
 501       if (*s == ')' && paren-- <= 0)
 502         break;
 503     }
 504   if (isname && s - *sp > 4 && !strncmp(s - 4, ":any", 4))
 505     {
 506       isany = 1;
 507       s -= 4;
 508     }
 509   if (!haveesc)
 510     {
 511       if (s - *sp == 6 && !strncmp(*sp, "<NULL>", 6))
 512         id = 0;
 513       else
 514         id = pool_strn2id(pool, *sp, s - *sp, 1);
 515     }
 516   else if (s - *sp == 3 && !strncmp(*sp, "\\00", 3))
 517     id = 1;
 518   else
 519     {
 520       char buf[128], *bp, *bp2;
 521       const char *sp2;
 522       bp = s - *sp >= 128 ? solv_malloc(s - *sp + 1) : buf;
 523       for (bp2 = bp, sp2 = *sp; sp2 < s;)
 524         {
 525           *bp2++ = *sp2++;
 526           if (bp2[-1] == '\\')
 527             solv_hex2bin(&sp2, (unsigned char *)bp2 - 1, 1);
 528         }
 529       *bp2 = 0;
 530       id = pool_str2id(pool, bp, 1);
 531       if (bp != buf)
 532         solv_free(bp);
 533     }
 534   if (isany)
 535     {
 536       id = pool_rel2id(pool, id, ARCH_ANY, REL_MULTIARCH, 1);
 537       s += 4;
 538     }
 539   *sp = s;
 540   return id;
 541 }
 542
 543
 544 static Id
 545 testcase_str2dep_complex(Pool *pool, const char **sp, int relop)
 546 {
 547   const char *s = *sp;
 548   Id flags, id, id2, namespaceid = 0;
 549   struct oplist *op;
 550
 551   while (*s == ' ' || *s == '\t')
 552     s++;
 553   if (!strncmp(s, "namespace:", 10))
 554     {
 555       /* special namespace hack */
 556       const char *s2;
 557       for (s2 = s + 10; *s2 && *s2 != '('; s2++)
 558         ;
 559       if (*s2 == '(')
 560         {
 561           namespaceid = pool_strn2id(pool, s, s2 - s, 1);
 562           s = s2;
 563         }
 564     }
 565   if (*s == '(')
 566     {
 567       s++;
 568       id = testcase_str2dep_complex(pool, &s, 0);
 569       if (!s || *s != ')')
 570         {
 571           *sp = 0;
 572           return 0;
 573         }
 574       s++;
 575     }
 576   else
 577     id = testcase_str2dep_simple(pool, &s, relop ? 0 : 1);
 578   if (namespaceid)
 579     id = pool_rel2id(pool, namespaceid, id, REL_NAMESPACE, 1);
 580
 581   for (;;)
 582     {
 583       while (*s == ' ' || *s == '\t')
 584         s++;
 585       if (!*s || *s == ')' || (relop && strncmp(s, "compat >= ", 10) != 0))
 586         {
 587           *sp = s;
 588           return id;
 589         }
 590
 591       /* we have an op! Find the end */
 592       flags = -1;
 593       if (s[0] == '<' && (s[1] >= '0' && s[1] <= '9'))
 594         {
 595           const char *s2;
 596           for (s2 = s + 1; *s2 >= '0' && *s2 <= '9'; s2++)
 597             ;
 598           if (*s2 == '>')
 599             {
 600               flags = strtoul(s + 1, 0, 10);
 601               s = s2 + 1;
 602             }
 603         }
 604       if (flags == -1)
 605         {
 606           for (op = oplist; op->flags; op++)
 607             if (!strncmp(s, op->opname, strlen(op->opname)))
 608               break;
 609           if (!op->flags)
 610             {
 611               *sp = 0;
 612               return 0;
 613             }
 614           flags = op->flags;
 615           s += strlen(op->opname);
 616         }
 617       id2 = testcase_str2dep_complex(pool, &s, flags > 0 && flags < 8);
 618       if (!s)
 619         {
 620           *sp = 0;
 621           return 0;
 622         }
 623       id = pool_rel2id(pool, id, id2, flags, 1);
 624     }
 625 }
 626
 627 Id
 628 testcase_str2dep(Pool *pool, const char *s)
 629 {
 630   Id id = testcase_str2dep_complex(pool, &s, 0);
 631   return s && !*s ? id : 0;
 632 }
 633
 634 /**********************************************************/
 635
 636 const char *
 637 testcase_repoid2str(Pool *pool, Id repoid)
 638 {
 639   Repo *repo = pool_id2repo(pool, repoid);
 640   if (repo->name)
 641     {
 642       char *r = pool_tmpjoin(pool, repo->name, 0, 0);
 643       char *rp;
 644       for (rp = r; *rp; rp++)
 645         if (*rp == ' ' || *rp == '\t')
 646           *rp = '_';
 647       return r;
 648     }
 649   else
 650     {
 651       char buf[20];
 652       sprintf(buf, "#%d", repoid);
 653       return pool_tmpjoin(pool, buf, 0, 0);
 654     }
 655 }
 656
 657 const char *
 658 testcase_solvid2str(Pool *pool, Id p)
 659 {
 660   Solvable *s = pool->solvables + p;
 661   const char *n, *e, *a;
 662   char *str, buf[20];
 663
 664   if (p == SYSTEMSOLVABLE)
 665     return "@SYSTEM";
 666   n = pool_id2str(pool, s->name);
 667   e = pool_id2str(pool, s->evr);
 668   a = pool_id2str(pool, s->arch);
 669   str = pool_alloctmpspace(pool, strlen(n) + strlen(e) + strlen(a) + 3);
 670   sprintf(str, "%s-%s.%s", n, e, a);
 671   if (!s->repo)
 672     return pool_tmpappend(pool, str, "@", 0);
 673   if (s->repo->name)
 674     {
 675       int l = strlen(str);
 676       char *str2 = pool_tmpappend(pool, str, "@", s->repo->name);
 677       for (; str2[l]; l++)
 678         if (str2[l] == ' ' || str2[l] == '\t')
 679           str2[l] = '_';
 680       return str2;
 681     }
 682   sprintf(buf, "@#%d", s->repo->repoid);
 683   return pool_tmpappend(pool, str, buf, 0);
 684 }
 685
 686 Repo *
 687 testcase_str2repo(Pool *pool, const char *str)
 688 {
 689   int repoid;
 690   Repo *repo = 0;
 691   if (str[0] == '#' && (str[1] >= '0' && str[1] <= '9'))
 692     {
 693       int j;
 694       repoid = 0;
 695       for (j = 1; str[j] >= '0' && str[j] <= '9'; j++)
 696         repoid = repoid * 10 + (str[j] - '0');
 697       if (!str[j] && repoid > 0 && repoid < pool->nrepos)
 698         repo = pool_id2repo(pool, repoid);
 699     }
 700   if (!repo)
 701     {
 702       FOR_REPOS(repoid, repo)
 703         {
 704           int i, l;
 705           if (!repo->name)
 706             continue;
 707           l = strlen(repo->name);
 708           for (i = 0; i < l; i++)
 709             {
 710               int c = repo->name[i];
 711               if (c == ' ' || c == '\t')
 712                 c = '_';
 713               if (c != str[i])
 714                 break;
 715             }
 716           if (i == l && !str[l])
 717             break;
 718         }
 719       if (repoid >= pool->nrepos)
 720         repo = 0;
 721     }
 722   return repo;
 723 }
 724
 725 Id
 726 testcase_str2solvid(Pool *pool, const char *str)
 727 {
 728   int i, l = strlen(str);
 729   int repostart;
 730   Repo *repo;
 731   Id arch;
 732
 733   if (!l)
 734     return 0;
 735   if (*str == '@' && !strcmp(str, "@SYSTEM"))
 736     return SYSTEMSOLVABLE;
 737   repo = 0;
 738   for (i = l - 1; i >= 0; i--)
 739     if (str[i] == '@' && (repo = testcase_str2repo(pool, str + i + 1)) != 0)
 740       break;
 741   if (i < 0)
 742     i = l;
 743   repostart = i;
 744   /* now find the arch (if present) */
 745   arch = 0;
 746   for (i = repostart - 1; i > 0; i--)
 747     if (str[i] == '.')
 748       {
 749         arch = pool_strn2id(pool, str + i + 1, repostart - (i + 1), 0);
 750         if (arch)
 751           repostart = i;
 752         break;
 753       }
 754   /* now find the name */
 755   for (i = repostart - 1; i > 0; i--)
 756     {
 757       if (str[i] == '-')
 758         {
 759           Id nid, evrid, p, pp;
 760           nid = pool_strn2id(pool, str, i, 0);
 761           if (!nid)
 762             continue;
 763           evrid = pool_strn2id(pool, str + i + 1, repostart - (i + 1), 0);
 764           if (!evrid)
 765             continue;
 766           FOR_PROVIDES(p, pp, nid)
 767             {
 768               Solvable *s = pool->solvables + p;
 769               if (s->name != nid || s->evr != evrid)
 770                 continue;
 771               if (repo && s->repo != repo)
 772                 continue;
 773               if (arch && s->arch != arch)
 774                 continue;
 775               return p;
 776             }
 777         }
 778     }
 779   return 0;
 780 }
 781
 782 const char *
 783 testcase_job2str(Pool *pool, Id how, Id what)
 784 {
 785   char *ret;
 786   const char *jobstr;
 787   const char *selstr;
 788   const char *pkgstr;
 789   int i, o;
 790   Id select = how & SOLVER_SELECTMASK;
 791
 792   for (i = 0; job2str[i].str; i++)
 793     if ((how & SOLVER_JOBMASK) == job2str[i].job)
 794       break;
 795   jobstr = job2str[i].str ? job2str[i].str : "unknown";
 796   if (select == SOLVER_SOLVABLE)
 797     {
 798       selstr = " pkg ";
 799       pkgstr = testcase_solvid2str(pool, what);
 800     }
 801   else if (select == SOLVER_SOLVABLE_NAME)
 802     {
 803       selstr = " name ";
 804       pkgstr = testcase_dep2str(pool, what);
 805     }
 806   else if (select == SOLVER_SOLVABLE_PROVIDES)
 807     {
 808       selstr = " provides ";
 809       pkgstr = testcase_dep2str(pool, what);
 810     }
 811   else if (select == SOLVER_SOLVABLE_ONE_OF)
 812     {
 813       Id p;
 814       selstr = " oneof ";
 815       pkgstr = 0;
 816       while ((p = pool->whatprovidesdata[what++]) != 0)
 817         {
 818           const char *s = testcase_solvid2str(pool, p);
 819           if (pkgstr)
 820             {
 821               pkgstr = pool_tmpappend(pool, pkgstr, " ", s);
 822               pool_freetmpspace(pool, s);
 823             }
 824           else
 825             pkgstr = s;
 826         }
 827       if (!pkgstr)
 828         pkgstr = "nothing";
 829     }
 830   else if (select == SOLVER_SOLVABLE_REPO)
 831     {
 832       Repo *repo = pool_id2repo(pool, what);
 833       selstr = " repo ";
 834       if (!repo->name)
 835         {
 836           char buf[20];
 837           sprintf(buf, "#%d", repo->repoid);
 838           pkgstr = pool_tmpjoin(pool, buf, 0, 0);
 839         }
 840       else
 841         pkgstr = pool_tmpjoin(pool, repo->name, 0, 0);
 842     }
 843   else if (select == SOLVER_SOLVABLE_ALL)
 844     {
 845       selstr = " all ";
 846       pkgstr = "packages";
 847     }
 848   else
 849     {
 850       selstr = " unknown ";
 851       pkgstr = "unknown";
 852     }
 853   ret = pool_tmpjoin(pool, jobstr, selstr, pkgstr);
 854   o = strlen(ret);
 855   ret = pool_tmpappend(pool, ret, " ", 0);
 856   for (i = 0; jobflags2str[i].str; i++)
 857     if ((how & jobflags2str[i].flag) != 0)
 858       ret = pool_tmpappend(pool, ret, ",", jobflags2str[i].str);
 859   if (!ret[o + 1])
 860     ret[o] = 0;
 861   else
 862     {
 863       ret[o + 1] = '[';
 864       ret = pool_tmpappend(pool, ret, "]", 0);
 865     }
 866   return ret;
 867 }
 868
 869 static int
 870 str2selflags(Pool *pool, char *s)       /* modifies the string! */
 871 {
 872   int i, selflags = 0;
 873   while (s)
 874     {
 875       char *se = strchr(s, ',');
 876       if (se)
 877         *se++ = 0;
 878       for (i = 0; selflags2str[i].str; i++)
 879         if (!strcmp(s, selflags2str[i].str))
 880           {
 881             selflags |= selflags2str[i].flag;
 882             break;
 883           }
 884       if (!selflags2str[i].str)
 885         pool_debug(pool, SOLV_ERROR, "str2job: unknown selection flag '%s'\n", s);
 886       s = se;
 887     }
 888   return selflags;
 889 }
 890
 891 static int
 892 str2jobflags(Pool *pool, char *s)       /* modifies the string */
 893 {
 894   int i, jobflags = 0;
 895   while (s)
 896     {
 897       char *se = strchr(s, ',');
 898       if (se)
 899         *se++ = 0;
 900       for (i = 0; jobflags2str[i].str; i++)
 901         if (!strcmp(s, jobflags2str[i].str))
 902           {
 903             jobflags |= jobflags2str[i].flag;
 904             break;
 905           }
 906       if (!jobflags2str[i].str)
 907         pool_debug(pool, SOLV_ERROR, "str2job: unknown job flag '%s'\n", s);
 908       s = se;
 909     }
 910   return jobflags;
 911 }
 912
 913 Id
 914 testcase_str2job(Pool *pool, const char *str, Id *whatp)
 915 {
 916   int i;
 917   Id job;
 918   Id what;
 919   char *s;
 920   char **pieces = 0;
 921   int npieces = 0;
 922
 923   *whatp = 0;
 924   /* so we can patch it */
 925   s = pool_tmpjoin(pool, str, 0, 0);
 926   /* split it in pieces */
 927   for (;;)
 928     {
 929       while (*s == ' ' || *s == '\t')
 930         s++;
 931       if (!*s)
 932         break;
 933       pieces = solv_extend(pieces, npieces, 1, sizeof(*pieces), 7);
 934       pieces[npieces++] = s;
 935       while (*s && *s != ' ' && *s != '\t')
 936         s++;
 937       if (*s)
 938         *s++ = 0;
 939     }
 940   if (npieces < 3)
 941     {
 942       pool_debug(pool, SOLV_ERROR, "str2job: bad line '%s'\n", str);
 943       solv_free(pieces);
 944       return -1;
 945     }
 946
 947   for (i = 0; job2str[i].str; i++)
 948     if (!strcmp(pieces[0], job2str[i].str))
 949       break;
 950   if (!job2str[i].str)
 951     {
 952       pool_debug(pool, SOLV_ERROR, "str2job: unknown job '%s'\n", str);
 953       solv_free(pieces);
 954       return -1;
 955     }
 956   job = job2str[i].job;
 957   what = 0;
 958   if (npieces > 3)
 959     {
 960       char *flags = pieces[npieces - 1];
 961       if (*flags == '[' && flags[strlen(flags) - 1] == ']')
 962         {
 963           npieces--;
 964           flags++;
 965           flags[strlen(flags) - 1] = 0;
 966           job |= str2jobflags(pool, flags);
 967         }
 968     }
 969   if (!strcmp(pieces[1], "pkg"))
 970     {
 971       if (npieces != 3)
 972         {
 973           pool_debug(pool, SOLV_ERROR, "str2job: bad pkg selector in '%s'\n", str);
 974           solv_free(pieces);
 975           return -1;
 976         }
 977       job |= SOLVER_SOLVABLE;
 978       what = testcase_str2solvid(pool, pieces[2]);
 979       if (!what)
 980         {
 981           pool_debug(pool, SOLV_ERROR, "str2job: unknown package '%s'\n", pieces[2]);
 982           solv_free(pieces);
 983           return -1;
 984         }
 985     }
 986   else if (!strcmp(pieces[1], "name") || !strcmp(pieces[1], "provides"))
 987     {
 988       /* join em again for dep2str... */
 989       char *sp;
 990       for (sp = pieces[2]; sp < pieces[npieces - 1]; sp++)
 991         if (*sp == 0)
 992           *sp = ' ';
 993       what = 0;
 994       if (pieces[1][0] == 'p' && strncmp(pieces[2], "namespace:", 10) == 0)
 995         {
 996           char *spe = strchr(pieces[2], '(');
 997           int l = strlen(pieces[2]);
 998           if (spe && pieces[2][l - 1] == ')')
 999             {
1000               /* special namespace provides */
1001               if (strcmp(spe, "(<NULL>)") != 0)
1002                 {
1003                   pieces[2][l - 1] = 0;
1004                   what = testcase_str2dep(pool, spe + 1);
1005                   pieces[2][l - 1] = ')';
1006                 }
1007               what = pool_rel2id(pool, pool_strn2id(pool, pieces[2], spe - pieces[2], 1), what, REL_NAMESPACE, 1);
1008             }
1009         }
1010       if (!what)
1011         what = testcase_str2dep(pool, pieces[2]);
1012       if (pieces[1][0] == 'n')
1013         job |= SOLVER_SOLVABLE_NAME;
1014       else
1015         job |= SOLVER_SOLVABLE_PROVIDES;
1016     }
1017   else if (!strcmp(pieces[1], "oneof"))
1018     {
1019       Queue q;
1020       job |= SOLVER_SOLVABLE_ONE_OF;
1021       queue_init(&q);
1022       if (npieces > 3 && strcmp(pieces[2], "nothing") != 0)
1023         {
1024           for (i = 2; i < npieces; i++)
1025             {
1026               Id p = testcase_str2solvid(pool, pieces[i]);
1027               if (!p)
1028                 {
1029                   pool_debug(pool, SOLV_ERROR, "str2job: unknown package '%s'\n", pieces[i]);
1030                   queue_free(&q);
1031                   solv_free(pieces);
1032                   return -1;
1033                 }
1034               queue_push(&q, p);
1035             }
1036         }
1037       what = pool_queuetowhatprovides(pool, &q);
1038       queue_free(&q);
1039     }
1040   else if (!strcmp(pieces[1], "repo"))
1041     {
1042       Repo *repo;
1043       if (npieces != 3)
1044         {
1045           pool_debug(pool, SOLV_ERROR, "str2job: bad line '%s'\n", str);
1046           solv_free(pieces);
1047           return -1;
1048         }
1049       repo = testcase_str2repo(pool, pieces[2]);
1050       if (!repo)
1051         {
1052           pool_debug(pool, SOLV_ERROR, "str2job: unknown repo '%s'\n", pieces[2]);
1053           solv_free(pieces);
1054           return -1;
1055         }
1056       job |= SOLVER_SOLVABLE_REPO;
1057       what = repo->repoid;
1058     }
1059   else if (!strcmp(pieces[1], "all"))
1060     {
1061       if (npieces != 3 && strcmp(pieces[2], "packages") != 0)
1062         {
1063           pool_debug(pool, SOLV_ERROR, "str2job: bad line '%s'\n", str);
1064           solv_free(pieces);
1065           return -1;
1066         }
1067       job |= SOLVER_SOLVABLE_ALL;
1068       what = 0;
1069     }
1070   else
1071     {
1072       pool_debug(pool, SOLV_ERROR, "str2job: unknown selection in '%s'\n", str);
1073       solv_free(pieces);
1074       return -1;
1075     }
1076   *whatp = what;
1077   solv_free(pieces);
1078   return job;
1079 }
1080
1081 int
1082 addselectionjob(Pool *pool, char **pieces, int npieces, Queue *jobqueue)
1083 {
1084   Id job;
1085   int i, r;
1086   int selflags;
1087   Queue sel;
1088
1089   for (i = 0; job2str[i].str; i++)
1090     if (!strcmp(pieces[0], job2str[i].str))
1091       break;
1092   if (!job2str[i].str)
1093     {
1094       pool_debug(pool, SOLV_ERROR, "selstr2job: unknown job '%s'\n", pieces[0]);
1095       return -1;
1096     }
1097   job = job2str[i].job;
1098   if (npieces > 3)
1099     {
1100       char *flags = pieces[npieces - 1];
1101       if (*flags == '[' && flags[strlen(flags) - 1] == ']')
1102         {
1103           npieces--;
1104           flags++;
1105           flags[strlen(flags) - 1] = 0;
1106           job |= str2jobflags(pool, flags);
1107         }
1108     }
1109   if (npieces < 4)
1110     {
1111       pool_debug(pool, SOLV_ERROR, "selstr2job: no selection flags\n");
1112       return -1;
1113     }
1114   selflags = str2selflags(pool, pieces[3]);
1115   queue_init(&sel);
1116   r = selection_make(pool, &sel, pieces[2], selflags);
1117   for (i = 0; i < sel.count; i += 2)
1118     queue_push2(jobqueue, job | sel.elements[i], sel.elements[i + 1]);
1119   queue_free(&sel);
1120   return r;
1121 }
1122
1123 static void
1124 writedeps(Repo *repo, FILE *fp, const char *tag, Id key, Solvable *s, Offset off)
1125 {
1126   Pool *pool = repo->pool;
1127   Id id, *dp;
1128   int tagwritten = 0;
1129   const char *idstr;
1130
1131   if (!off)
1132     return;
1133   dp = repo->idarraydata + off;
1134   while ((id = *dp++) != 0)
1135     {
1136       if (key == SOLVABLE_REQUIRES && id == SOLVABLE_PREREQMARKER)
1137         {
1138           if (tagwritten)
1139             fprintf(fp, "-%s\n", tag);
1140           tagwritten = 0;
1141           tag = "Prq:";
1142           continue;
1143         }
1144       if (key == SOLVABLE_PROVIDES && id == SOLVABLE_FILEMARKER)
1145         continue;
1146       idstr = testcase_dep2str(pool, id);
1147       if (!tagwritten)
1148         {
1149           fprintf(fp, "+%s\n", tag);
1150           tagwritten = 1;
1151         }
1152       fprintf(fp, "%s\n", idstr);
1153     }
1154   if (tagwritten)
1155     fprintf(fp, "-%s\n", tag);
1156 }
1157
1158 static void
1159 writefilelist(Repo *repo, FILE *fp, const char *tag, Solvable *s)
1160 {
1161   Pool *pool = repo->pool;
1162   int tagwritten = 0;
1163   Dataiterator di;
1164
1165   dataiterator_init(&di, pool, repo, s - pool->solvables, SOLVABLE_FILELIST, 0, 0);
1166   while (dataiterator_step(&di))
1167     {
1168       const char *s = repodata_dir2str(di.data, di.kv.id, di.kv.str);
1169       if (!tagwritten)
1170         {
1171           fprintf(fp, "+%s\n", tag);
1172           tagwritten = 1;
1173         }
1174       fprintf(fp, "%s\n", s);
1175     }
1176   if (tagwritten)
1177     fprintf(fp, "-%s\n", tag);
1178   dataiterator_free(&di);
1179 }
1180
1181 int
1182 testcase_write_testtags(Repo *repo, FILE *fp)
1183 {
1184   Pool *pool = repo->pool;
1185   Solvable *s;
1186   Id p;
1187   const char *name;
1188   const char *evr;
1189   const char *arch;
1190   const char *release;
1191   const char *tmp;
1192   unsigned int ti;
1193
1194   fprintf(fp, "=Ver: 3.0\n");
1195   FOR_REPO_SOLVABLES(repo, p, s)
1196     {
1197       name = pool_id2str(pool, s->name);
1198       evr = pool_id2str(pool, s->evr);
1199       arch = pool_id2str(pool, s->arch);
1200       release = strrchr(evr, '-');
1201       if (!release)
1202         release = evr + strlen(evr);
1203       fprintf(fp, "=Pkg: %s %.*s %s %s\n", name, (int)(release - evr), evr, *release && release[1] ? release + 1 : "-", arch);
1204       tmp = solvable_lookup_str(s, SOLVABLE_SUMMARY);
1205       if (tmp)
1206         fprintf(fp, "=Sum: %s\n", tmp);
1207       writedeps(repo, fp, "Req:", SOLVABLE_REQUIRES, s, s->requires);
1208       writedeps(repo, fp, "Prv:", SOLVABLE_PROVIDES, s, s->provides);
1209       writedeps(repo, fp, "Obs:", SOLVABLE_OBSOLETES, s, s->obsoletes);
1210       writedeps(repo, fp, "Con:", SOLVABLE_CONFLICTS, s, s->conflicts);
1211       writedeps(repo, fp, "Rec:", SOLVABLE_RECOMMENDS, s, s->recommends);
1212       writedeps(repo, fp, "Sup:", SOLVABLE_SUPPLEMENTS, s, s->supplements);
1213       writedeps(repo, fp, "Sug:", SOLVABLE_SUGGESTS, s, s->suggests);
1214       writedeps(repo, fp, "Enh:", SOLVABLE_ENHANCES, s, s->enhances);
1215       if (s->vendor)
1216         fprintf(fp, "=Vnd: %s\n", pool_id2str(pool, s->vendor));
1217       ti = solvable_lookup_num(s, SOLVABLE_BUILDTIME, 0);
1218       if (ti)
1219         fprintf(fp, "=Tim: %u\n", ti);
1220       writefilelist(repo, fp, "Fls:", s);
1221     }
1222   return 0;
1223 }
1224
1225 static inline Offset
1226 adddep(Repo *repo, Offset olddeps, char *str, Id marker)
1227 {
1228   Id id = *str == '/' ? pool_str2id(repo->pool, str, 1) : testcase_str2dep(repo->pool, str);
1229   return repo_addid_dep(repo, olddeps, id, marker);
1230 }
1231
1232 static void
1233 finish_v2_solvable(Pool *pool, Repodata *data, Solvable *s, char *filelist, int nfilelist)
1234 {
1235   if (nfilelist)
1236     {
1237       int l;
1238       Id did;
1239       for (l = 0; l < nfilelist; l += strlen(filelist + l) + 1)
1240         {
1241           char *p = strrchr(filelist + l, '/');
1242           if (!p)
1243             continue;
1244           *p++ = 0;
1245           did = repodata_str2dir(data, filelist + l, 1);
1246           p[-1] = '/';
1247           if (!did)
1248             did = repodata_str2dir(data, "/", 1);
1249           repodata_add_dirstr(data, s - pool->solvables, SOLVABLE_FILELIST, did, p);
1250         }
1251     }
1252   s->supplements = repo_fix_supplements(s->repo, s->provides, s->supplements, 0);
1253   s->conflicts = repo_fix_conflicts(s->repo, s->conflicts);
1254 }
1255
1256 /* stripped down version of susetags parser used for testcases */
1257 int
1258 testcase_add_testtags(Repo *repo, FILE *fp, int flags)
1259 {
1260   Pool *pool = repo->pool;
1261   char *line, *linep;
1262   int aline;
1263   int tag;
1264   Repodata *data;
1265   Solvable *s;
1266   char *sp[5];
1267   unsigned int t;
1268   int intag;
1269   char *filelist = 0;
1270   int afilelist = 0;
1271   int nfilelist = 0;
1272   int tagsversion = 0;
1273   int addselfprovides = 1;      /* for compat reasons */
1274
1275   data = repo_add_repodata(repo, flags);
1276   s = 0;
1277   intag = 0;
1278
1279   aline = 1024;
1280   line = solv_malloc(aline);
1281   linep = line;
1282   for (;;)
1283     {
1284       if (linep - line + 16 > aline)
1285         {
1286           aline = linep - line;
1287           line = solv_realloc(line, aline + 512);
1288           linep = line + aline;
1289           aline += 512;
1290         }
1291       if (!fgets(linep, aline - (linep - line), fp))
1292         break;
1293       linep += strlen(linep);
1294       if (linep == line || linep[-1] != '\n')
1295         continue;
1296       linep[-1] = 0;
1297       linep = line + intag;
1298       if (intag)
1299         {
1300           if (line[intag] == '-' && !strncmp(line + 1, line + intag + 1, intag - 2))
1301             {
1302               intag = 0;
1303               linep = line;
1304               continue;
1305             }
1306         }
1307       else if (line[0] == '+' && line[1] && line[1] != ':')
1308         {
1309           char *tagend = strchr(line, ':');
1310           if (!tagend)
1311             continue;
1312           line[0] = '=';
1313           tagend[1] = ' ';
1314           intag = tagend + 2 - line;
1315           linep = line + intag;
1316           continue;
1317         }
1318       if (*line != '=' || !line[1] || !line[2] || !line[3] || line[4] != ':')
1319         continue;
1320       tag = line[1] << 16 | line[2] << 8 | line[3];
1321       switch(tag)
1322         {
1323         case 'V' << 16 | 'e' << 8 | 'r':
1324           tagsversion = atoi(line + 6);
1325           addselfprovides = tagsversion < 3 || strstr(line + 6, "addselfprovides") != 0;
1326           break;
1327         case 'P' << 16 | 'k' << 8 | 'g':
1328           if (s)
1329             {
1330               if (tagsversion == 2)
1331                 finish_v2_solvable(pool, data, s, filelist, nfilelist);
1332               if (addselfprovides && s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
1333                 s->provides = repo_addid_dep(s->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
1334             }
1335           nfilelist = 0;
1336           if (split(line + 5, sp, 5) != 4)
1337             break;
1338           s = pool_id2solvable(pool, repo_add_solvable(repo));
1339           s->name = pool_str2id(pool, sp[0], 1);
1340           /* join back version and release */
1341           if (sp[2] && !(sp[2][0] == '-' && !sp[2][1]))
1342             sp[2][-1] = '-';
1343           s->evr = makeevr(pool, sp[1]);
1344           s->arch = pool_str2id(pool, sp[3], 1);
1345           break;
1346         case 'S' << 16 | 'u' << 8 | 'm':
1347           repodata_set_str(data, s - pool->solvables, SOLVABLE_SUMMARY, line + 6);
1348           break;
1349         case 'V' << 16 | 'n' << 8 | 'd':
1350           s->vendor = pool_str2id(pool, line + 6, 1);
1351           break;
1352         case 'T' << 16 | 'i' << 8 | 'm':
1353           t = atoi(line + 6);
1354           if (t)
1355             repodata_set_num(data, s - pool->solvables, SOLVABLE_BUILDTIME, t);
1356           break;
1357         case 'R' << 16 | 'e' << 8 | 'q':
1358           s->requires = adddep(repo, s->requires, line + 6, -SOLVABLE_PREREQMARKER);
1359           break;
1360         case 'P' << 16 | 'r' << 8 | 'q':
1361           s->requires = adddep(repo, s->requires, line + 6, SOLVABLE_PREREQMARKER);
1362           break;
1363         case 'P' << 16 | 'r' << 8 | 'v':
1364           /* version 2 had the file list at the end of the provides */
1365           if (tagsversion == 2)
1366             {
1367               if (line[6] == '/')
1368                 {
1369                   int l = strlen(line + 6) + 1;
1370                   if (nfilelist + l > afilelist)
1371                     {
1372                       afilelist = nfilelist + l + 512;
1373                       filelist = solv_realloc(filelist, afilelist);
1374                     }
1375                   memcpy(filelist + nfilelist, line + 6, l);
1376                   nfilelist += l;
1377                   break;
1378                 }
1379               if (nfilelist)
1380                 {
1381                   int l;
1382                   for (l = 0; l < nfilelist; l += strlen(filelist + l) + 1)
1383                     s->provides = repo_addid_dep(repo, s->provides, pool_str2id(pool, filelist + l, 1), 0);
1384                   nfilelist = 0;
1385                 }
1386             }
1387           s->provides = adddep(repo, s->provides, line + 6, 0);
1388           break;
1389         case 'F' << 16 | 'l' << 8 | 's':
1390           {
1391             char *p = strrchr(line + 6, '/');
1392             Id did;
1393             if (!p)
1394               break;
1395             *p++ = 0;
1396             did = repodata_str2dir(data, line + 6, 1);
1397             if (!did)
1398               did = repodata_str2dir(data, "/", 1);
1399             repodata_add_dirstr(data, s - pool->solvables, SOLVABLE_FILELIST, did, p);
1400             break;
1401           }
1402         case 'O' << 16 | 'b' << 8 | 's':
1403           s->obsoletes = adddep(repo, s->obsoletes, line + 6, 0);
1404           break;
1405         case 'C' << 16 | 'o' << 8 | 'n':
1406           s->conflicts = adddep(repo, s->conflicts, line + 6, 0);
1407           break;
1408         case 'R' << 16 | 'e' << 8 | 'c':
1409           s->recommends = adddep(repo, s->recommends, line + 6, 0);
1410           break;
1411         case 'S' << 16 | 'u' << 8 | 'p':
1412           s->supplements = adddep(repo, s->supplements, line + 6, 0);
1413           break;
1414         case 'S' << 16 | 'u' << 8 | 'g':
1415           s->suggests = adddep(repo, s->suggests, line + 6, 0);
1416           break;
1417         case 'E' << 16 | 'n' << 8 | 'h':
1418           s->enhances = adddep(repo, s->enhances, line + 6, 0);
1419           break;
1420         default:
1421           break;
1422         }
1423     }
1424   if (s)
1425     {
1426       if (tagsversion == 2)
1427         finish_v2_solvable(pool, data, s, filelist, nfilelist);
1428       if (addselfprovides && s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
1429         s->provides = repo_addid_dep(s->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
1430     }
1431   solv_free(line);
1432   solv_free(filelist);
1433   repodata_free_dircache(data);
1434   if (!(flags & REPO_NO_INTERNALIZE))
1435     repodata_internalize(data);
1436   return 0;
1437 }
1438
1439 const char *
1440 testcase_getpoolflags(Pool *pool)
1441 {
1442   const char *str = 0;
1443   int i, v;
1444   for (i = 0; poolflags2str[i].str; i++)
1445     {
1446       v = pool_get_flag(pool, poolflags2str[i].flag);
1447       if (v == poolflags2str[i].def)
1448         continue;
1449       str = pool_tmpappend(pool, str, v ? " " : " !", poolflags2str[i].str);
1450     }
1451   return str ? str + 1 : "";
1452 }
1453
1454 int
1455 testcase_setpoolflags(Pool *pool, const char *str)
1456 {
1457   const char *p = str, *s;
1458   int i, v;
1459   for (;;)
1460     {
1461       while (*p == ' ' || *p == '\t' || *p == ',')
1462         p++;
1463       v = 1;
1464       if (*p == '!')
1465         {
1466           p++;
1467           v = 0;
1468         }
1469       if (!*p)
1470         break;
1471       s = p;
1472       while (*p && *p != ' ' && *p != '\t' && *p != ',')
1473         p++;
1474       for (i = 0; poolflags2str[i].str; i++)
1475         if (!strncmp(poolflags2str[i].str, s, p - s) && poolflags2str[i].str[p - s] == 0)
1476           break;
1477       if (!poolflags2str[i].str)
1478         {
1479           pool_debug(pool, SOLV_ERROR, "setpoolflags: unknown flag '%.*s'\n", (int)(p - s), s);
1480           return 0;
1481         }
1482       pool_set_flag(pool, poolflags2str[i].flag, v);
1483     }
1484   return 1;
1485 }
1486
1487 void
1488 testcase_resetpoolflags(Pool *pool)
1489 {
1490   int i;
1491   for (i = 0; poolflags2str[i].str; i++)
1492     pool_set_flag(pool, poolflags2str[i].flag, poolflags2str[i].def);
1493 }
1494
1495 const char *
1496 testcase_getsolverflags(Solver *solv)
1497 {
1498   Pool *pool = solv->pool;
1499   const char *str = 0;
1500   int i, v;
1501   for (i = 0; solverflags2str[i].str; i++)
1502     {
1503       v = solver_get_flag(solv, solverflags2str[i].flag);
1504       if (v == solverflags2str[i].def)
1505         continue;
1506       str = pool_tmpappend(pool, str, v ? " " : " !", solverflags2str[i].str);
1507     }
1508   return str ? str + 1 : "";
1509 }
1510
1511 int
1512 testcase_setsolverflags(Solver *solv, const char *str)
1513 {
1514   const char *p = str, *s;
1515   int i, v;
1516   for (;;)
1517     {
1518       while (*p == ' ' || *p == '\t' || *p == ',')
1519         p++;
1520       v = 1;
1521       if (*p == '!')
1522         {
1523           p++;
1524           v = 0;
1525         }
1526       if (!*p)
1527         break;
1528       s = p;
1529       while (*p && *p != ' ' && *p != '\t' && *p != ',')
1530         p++;
1531       for (i = 0; solverflags2str[i].str; i++)
1532         if (!strncmp(solverflags2str[i].str, s, p - s) && solverflags2str[i].str[p - s] == 0)
1533           break;
1534       if (!solverflags2str[i].str)
1535         {
1536           pool_debug(solv->pool, SOLV_ERROR, "setsolverflags: unknown flag '%.*s'\n", (int)(p - s), s);
1537           return 0;
1538         }
1539       solver_set_flag(solv, solverflags2str[i].flag, v);
1540     }
1541   return 1;
1542 }
1543
1544 void
1545 testcase_resetsolverflags(Solver *solv)
1546 {
1547   int i;
1548   for (i = 0; solverflags2str[i].str; i++)
1549     solver_set_flag(solv, solverflags2str[i].flag, solverflags2str[i].def);
1550 }
1551
1552 static const char *
1553 testcase_ruleid(Solver *solv, Id rid)
1554 {
1555   Strqueue sq;
1556   Queue q;
1557   int i;
1558   Chksum *chk;
1559   const unsigned char *md5;
1560   int md5l;
1561   const char *s;
1562
1563   queue_init(&q);
1564   strqueue_init(&sq);
1565   solver_ruleliterals(solv, rid, &q);
1566   for (i = 0; i < q.count; i++)
1567     {
1568       Id p = q.elements[i];
1569       s = testcase_solvid2str(solv->pool, p > 0 ? p : -p);
1570       if (p < 0)
1571         s = pool_tmpjoin(solv->pool, "!", s, 0);
1572       strqueue_push(&sq, s);
1573     }
1574   queue_free(&q);
1575   strqueue_sort_u(&sq);
1576   chk = solv_chksum_create(REPOKEY_TYPE_MD5);
1577   for (i = 0; i < sq.nstr; i++)
1578     solv_chksum_add(chk, sq.str[i], strlen(sq.str[i]) + 1);
1579   md5 = solv_chksum_get(chk, &md5l);
1580   s = pool_bin2hex(solv->pool, md5, md5l);
1581   chk = solv_chksum_free(chk, 0);
1582   strqueue_free(&sq);
1583   return s;
1584 }
1585
1586 static const char *
1587 testcase_problemid(Solver *solv, Id problem)
1588 {
1589   Strqueue sq;
1590   Queue q;
1591   Chksum *chk;
1592   const unsigned char *md5;
1593   int i, md5l;
1594   const char *s;
1595
1596   /* we build a hash of all rules that define the problem */
1597   queue_init(&q);
1598   strqueue_init(&sq);
1599   solver_findallproblemrules(solv, problem, &q);
1600   for (i = 0; i < q.count; i++)
1601     strqueue_push(&sq, testcase_ruleid(solv, q.elements[i]));
1602   queue_free(&q);
1603   strqueue_sort_u(&sq);
1604   chk = solv_chksum_create(REPOKEY_TYPE_MD5);
1605   for (i = 0; i < sq.nstr; i++)
1606     solv_chksum_add(chk, sq.str[i], strlen(sq.str[i]) + 1);
1607   md5 = solv_chksum_get(chk, &md5l);
1608   s = pool_bin2hex(solv->pool, md5, 4);
1609   chk = solv_chksum_free(chk, 0);
1610   strqueue_free(&sq);
1611   return s;
1612 }
1613
1614 static const char *
1615 testcase_solutionid(Solver *solv, Id problem, Id solution)
1616 {
1617   Id intid;
1618   Chksum *chk;
1619   const unsigned char *md5;
1620   int md5l;
1621   const char *s;
1622
1623   intid = solver_solutionelement_internalid(solv, problem, solution);
1624   /* internal stuff! handle with care! */
1625   if (intid < 0)
1626     {
1627       /* it's a job */
1628       s = testcase_job2str(solv->pool, solv->job.elements[-intid - 1], solv->job.elements[-intid]);
1629     }
1630   else
1631     {
1632       /* it's a rule */
1633       s = testcase_ruleid(solv, intid);
1634     }
1635   chk = solv_chksum_create(REPOKEY_TYPE_MD5);
1636   solv_chksum_add(chk, s, strlen(s) + 1);
1637   md5 = solv_chksum_get(chk, &md5l);
1638   s = pool_bin2hex(solv->pool, md5, 4);
1639   chk = solv_chksum_free(chk, 0);
1640   return s;
1641 }
1642
1643 static const char *
1644 testcase_alternativeid(Solver *solv, int type, Id id, Id from)
1645 {
1646   const char *s;
1647   Pool *pool = solv->pool;
1648   Chksum *chk;
1649   const unsigned char *md5;
1650   int md5l;
1651   chk = solv_chksum_create(REPOKEY_TYPE_MD5);
1652   if (type == SOLVER_ALTERNATIVE_TYPE_RECOMMENDS)
1653     {
1654       s = testcase_solvid2str(pool, from);
1655       solv_chksum_add(chk, s, strlen(s) + 1);
1656       s = testcase_dep2str(pool, id);
1657       solv_chksum_add(chk, s, strlen(s) + 1);
1658     }
1659   else if (type == SOLVER_ALTERNATIVE_TYPE_RULE)
1660     {
1661       s = testcase_ruleid(solv, id);
1662       solv_chksum_add(chk, s, strlen(s) + 1);
1663     }
1664   md5 = solv_chksum_get(chk, &md5l);
1665   s = pool_bin2hex(pool, md5, 4);
1666   chk = solv_chksum_free(chk, 0);
1667   return s;
1668 }
1669
1670 static struct class2str {
1671   Id class;
1672   const char *str;
1673 } class2str[] = {
1674   { SOLVER_TRANSACTION_ERASE,          "erase" },
1675   { SOLVER_TRANSACTION_INSTALL,        "install" },
1676   { SOLVER_TRANSACTION_REINSTALLED,    "reinstall" },
1677   { SOLVER_TRANSACTION_DOWNGRADED,     "downgrade" },
1678   { SOLVER_TRANSACTION_CHANGED,        "change" },
1679   { SOLVER_TRANSACTION_UPGRADED,       "upgrade" },
1680   { SOLVER_TRANSACTION_OBSOLETED,      "obsolete" },
1681   { SOLVER_TRANSACTION_MULTIINSTALL,   "multiinstall" },
1682   { SOLVER_TRANSACTION_MULTIREINSTALL, "multireinstall" },
1683   { 0, 0 }
1684 };
1685
1686 static int
1687 dump_genid(Pool *pool, Strqueue *sq, Id id, int cnt)
1688 {
1689   struct oplist *op;
1690   char cntbuf[20];
1691   const char *s;
1692
1693   if (ISRELDEP(id))
1694     {
1695       Reldep *rd = GETRELDEP(pool, id);
1696       for (op = oplist; op->flags; op++)
1697         if (rd->flags == op->flags)
1698           break;
1699       cnt = dump_genid(pool, sq, rd->name, cnt);
1700       cnt = dump_genid(pool, sq, rd->evr, cnt);
1701       sprintf(cntbuf, "genid %2d: genid ", cnt++);
1702       s = pool_tmpjoin(pool, cntbuf, "op ", op->flags ? op->opname : "unknown");
1703     }
1704   else
1705     {
1706       sprintf(cntbuf, "genid %2d: genid ", cnt++);
1707       s = pool_tmpjoin(pool, cntbuf, id ? "lit " : "null", id ? pool_id2str(pool, id) : 0);
1708     }
1709   strqueue_push(sq, s);
1710   return cnt;
1711 }
1712
1713 char *
1714 testcase_solverresult(Solver *solv, int resultflags)
1715 {
1716   Pool *pool = solv->pool;
1717   int i, j;
1718   Id p, op;
1719   const char *s;
1720   char *result;
1721   Strqueue sq;
1722
1723   strqueue_init(&sq);
1724   if ((resultflags & TESTCASE_RESULT_TRANSACTION) != 0)
1725     {
1726       Transaction *trans = solver_create_transaction(solv);
1727       Queue q;
1728
1729       queue_init(&q);
1730       for (i = 0; class2str[i].str; i++)
1731         {
1732           queue_empty(&q);
1733           transaction_classify_pkgs(trans, SOLVER_TRANSACTION_KEEP_PSEUDO, class2str[i].class, 0, 0, &q);
1734           for (j = 0; j < q.count; j++)
1735             {
1736               p = q.elements[j];
1737               op = 0;
1738               if (pool->installed && pool->solvables[p].repo == pool->installed)
1739                 op = transaction_obs_pkg(trans, p);
1740               s = pool_tmpjoin(pool, class2str[i].str, " ", testcase_solvid2str(pool, p));
1741               if (op)
1742                 s = pool_tmpjoin(pool, s, " ", testcase_solvid2str(pool, op));
1743               strqueue_push(&sq, s);
1744             }
1745         }
1746       queue_free(&q);
1747       transaction_free(trans);
1748     }
1749   if ((resultflags & TESTCASE_RESULT_PROBLEMS) != 0)
1750     {
1751       char *probprefix, *solprefix;
1752       int problem, solution, element;
1753       int pcnt, scnt;
1754
1755       pcnt = solver_problem_count(solv);
1756       for (problem = 1; problem <= pcnt; problem++)
1757         {
1758           Id rid, from, to, dep;
1759           SolverRuleinfo rinfo;
1760           rid = solver_findproblemrule(solv, problem);
1761           s = testcase_problemid(solv, problem);
1762           probprefix = solv_dupjoin("problem ", s, 0);
1763           rinfo = solver_ruleinfo(solv, rid, &from, &to, &dep);
1764           s = pool_tmpjoin(pool, probprefix, " info ", solver_problemruleinfo2str(solv, rinfo, from, to, dep));
1765           strqueue_push(&sq, s);
1766           scnt = solver_solution_count(solv, problem);
1767           for (solution = 1; solution <= scnt; solution++)
1768             {
1769               s = testcase_solutionid(solv, problem, solution);
1770               solprefix = solv_dupjoin(probprefix, " solution ", s);
1771               element = 0;
1772               while ((element = solver_next_solutionelement(solv, problem, solution, element, &p, &op)) != 0)
1773                 {
1774                   if (p == SOLVER_SOLUTION_JOB)
1775                     s = pool_tmpjoin(pool, solprefix, " deljob ", testcase_job2str(pool, solv->job.elements[op - 1], solv->job.elements[op]));
1776                   else if (p > 0 && op == 0)
1777                     s = pool_tmpjoin(pool, solprefix, " erase ", testcase_solvid2str(pool, p));
1778                   else if (p > 0 && op > 0)
1779                     {
1780                       s = pool_tmpjoin(pool, solprefix, " replace ", testcase_solvid2str(pool, p));
1781                       s = pool_tmpappend(pool, s, " ", testcase_solvid2str(pool, op));
1782                     }
1783                   else if (p < 0 && op > 0)
1784                     s = pool_tmpjoin(pool, solprefix, " allow ", testcase_solvid2str(pool, op));
1785                   else
1786                     s = pool_tmpjoin(pool, solprefix, " unknown", 0);
1787                   strqueue_push(&sq, s);
1788                 }
1789               solv_free(solprefix);
1790             }
1791           solv_free(probprefix);
1792         }
1793     }
1794
1795   if ((resultflags & TESTCASE_RESULT_ORPHANED) != 0)
1796     {
1797       Queue q;
1798
1799       queue_init(&q);
1800       solver_get_orphaned(solv, &q);
1801       for (i = 0; i < q.count; i++)
1802         {
1803           s = pool_tmpjoin(pool, "orphaned ", testcase_solvid2str(pool, q.elements[i]), 0);
1804           strqueue_push(&sq, s);
1805         }
1806       queue_free(&q);
1807     }
1808
1809   if ((resultflags & TESTCASE_RESULT_RECOMMENDED) != 0)
1810     {
1811       Queue qr, qs;
1812
1813       queue_init(&qr);
1814       queue_init(&qs);
1815       solver_get_recommendations(solv, &qr, &qs, 0);
1816       for (i = 0; i < qr.count; i++)
1817         {
1818           s = pool_tmpjoin(pool, "recommended ", testcase_solvid2str(pool, qr.elements[i]), 0);
1819           strqueue_push(&sq, s);
1820         }
1821       for (i = 0; i < qs.count; i++)
1822         {
1823           s = pool_tmpjoin(pool, "suggested ", testcase_solvid2str(pool, qs.elements[i]), 0);
1824           strqueue_push(&sq, s);
1825         }
1826       queue_free(&qr);
1827       queue_free(&qs);
1828     }
1829
1830   if ((resultflags & TESTCASE_RESULT_UNNEEDED) != 0)
1831     {
1832       Queue q, qf;
1833
1834       queue_init(&q);
1835       queue_init(&qf);
1836       solver_get_unneeded(solv, &q, 0);
1837       solver_get_unneeded(solv, &qf, 1);
1838       for (i = j = 0; i < q.count; i++)
1839         {
1840           /* we rely on qf containing a subset of q in the same order */
1841           if (j < qf.count && q.elements[i] == qf.elements[j])
1842             {
1843               s = pool_tmpjoin(pool, "unneeded_filtered ", testcase_solvid2str(pool, q.elements[i]), 0);
1844               j++;
1845             }
1846           else
1847             s = pool_tmpjoin(pool, "unneeded ", testcase_solvid2str(pool, q.elements[i]), 0);
1848           strqueue_push(&sq, s);
1849         }
1850       queue_free(&q);
1851       queue_free(&qf);
1852     }
1853   if ((resultflags & TESTCASE_RESULT_ALTERNATIVES) != 0)
1854     {
1855       char *altprefix;
1856       Queue q, rq;
1857       int cnt;
1858       Id alternative;
1859       queue_init(&q);
1860       queue_init(&rq);
1861       cnt = solver_alternatives_count(solv);
1862       for (alternative = 1; alternative <= cnt; alternative++)
1863         {
1864           Id id, from, chosen;
1865           char num[20];
1866           int type = solver_get_alternative(solv, alternative, &id, &from, &chosen, &q, 0);
1867           altprefix = solv_dupjoin("alternative ", testcase_alternativeid(solv, type, id, from), " ");
1868           strcpy(num, " 0 ");
1869           if (type == SOLVER_ALTERNATIVE_TYPE_RECOMMENDS)
1870             {
1871               char *s = pool_tmpjoin(pool, altprefix, num, testcase_solvid2str(pool, from));
1872               s = pool_tmpappend(pool, s, " recommends ", testcase_dep2str(pool, id));
1873               strqueue_push(&sq, s);
1874             }
1875           else if (type == SOLVER_ALTERNATIVE_TYPE_RULE)
1876             {
1877               /* map choice rules back to pkg rules */
1878               if (solver_ruleclass(solv, id) == SOLVER_RULE_CHOICE)
1879                 id = solver_rule2pkgrule(solv, id);
1880               solver_allruleinfos(solv, id, &rq);
1881               for (i = 0; i < rq.count; i += 4)
1882                 {
1883                   int rtype = rq.elements[i];
1884                   if ((rtype & SOLVER_RULE_TYPEMASK) == SOLVER_RULE_JOB)
1885                     {
1886                       const char *js = testcase_job2str(pool, rq.elements[i + 2], rq.elements[i + 3]);
1887                       char *s = pool_tmpjoin(pool, altprefix, num, " job ");
1888                       s = pool_tmpappend(pool, s, js, 0);
1889                       strqueue_push(&sq, s);
1890                     }
1891                   else if (rtype == SOLVER_RULE_PKG_REQUIRES)
1892                     {
1893                       char *s = pool_tmpjoin(pool, altprefix, num, testcase_solvid2str(pool, rq.elements[i + 1]));
1894                       s = pool_tmpappend(pool, s, " requires ", testcase_dep2str(pool, rq.elements[i + 3]));
1895                       strqueue_push(&sq, s);
1896                     }
1897                 }
1898             }
1899           for (i = 0; i < q.count; i++)
1900             {
1901               Id p = q.elements[i];
1902               if (i >= 9)
1903                 num[0] = '0' + (i + 1) / 10;
1904               num[1] = '0' + (i + 1) % 10;
1905               if (-p == chosen)
1906                 s = pool_tmpjoin(pool, altprefix, num, "+ ");
1907               else if (p < 0)
1908                 s = pool_tmpjoin(pool, altprefix, num, "- ");
1909               else if (p >= 0)
1910                 s = pool_tmpjoin(pool, altprefix, num, "  ");
1911               s = pool_tmpappend(pool, s,  testcase_solvid2str(pool, p < 0 ? -p : p), 0);
1912               strqueue_push(&sq, s);
1913             }
1914           solv_free(altprefix);
1915         }
1916       queue_free(&q);
1917       queue_free(&rq);
1918     }
1919   if ((resultflags & TESTCASE_RESULT_RULES) != 0)
1920     {
1921       /* dump all rules */
1922       Id rid;
1923       SolverRuleinfo rclass;
1924       Queue q;
1925       int i;
1926
1927       queue_init(&q);
1928       for (rid = 1; (rclass = solver_ruleclass(solv, rid)) != SOLVER_RULE_UNKNOWN; rid++)
1929         {
1930           char *prefix;
1931           switch (rclass)
1932             {
1933             case SOLVER_RULE_PKG:
1934               prefix = "pkg ";
1935               break;
1936             case SOLVER_RULE_UPDATE:
1937               prefix = "update ";
1938               break;
1939             case SOLVER_RULE_FEATURE:
1940               prefix = "feature ";
1941               break;
1942             case SOLVER_RULE_JOB:
1943               prefix = "job ";
1944               break;
1945             case SOLVER_RULE_DISTUPGRADE:
1946               prefix = "distupgrade ";
1947               break;
1948             case SOLVER_RULE_INFARCH:
1949               prefix = "infarch ";
1950               break;
1951             case SOLVER_RULE_CHOICE:
1952               prefix = "choice ";
1953               break;
1954             case SOLVER_RULE_LEARNT:
1955               prefix = "learnt ";
1956               break;
1957             case SOLVER_RULE_BEST:
1958               prefix = "best ";
1959               break;
1960             case SOLVER_RULE_YUMOBS:
1961               prefix = "yumobs ";
1962               break;
1963             default:
1964               prefix = "unknown ";
1965               break;
1966             }
1967           prefix = solv_dupjoin("rule ", prefix, testcase_ruleid(solv, rid));
1968           solver_ruleliterals(solv, rid, &q);
1969           if (rclass == SOLVER_RULE_FEATURE && q.count == 1 && q.elements[0] == -SYSTEMSOLVABLE)
1970             continue;
1971           for (i = 0; i < q.count; i++)
1972             {
1973               Id p = q.elements[i];
1974               const char *s;
1975               if (p < 0)
1976                 s = pool_tmpjoin(pool, prefix, " -", testcase_solvid2str(pool, -p));
1977               else
1978                 s = pool_tmpjoin(pool, prefix, "  ", testcase_solvid2str(pool, p));
1979               strqueue_push(&sq, s);
1980             }
1981           solv_free(prefix);
1982         }
1983       queue_free(&q);
1984     }
1985   if ((resultflags & TESTCASE_RESULT_GENID) != 0)
1986     {
1987       for (i = 0 ; i < solv->job.count; i += 2)
1988         {
1989           Id id, id2;
1990           if (solv->job.elements[i] != (SOLVER_NOOP | SOLVER_SOLVABLE_PROVIDES))
1991             continue;
1992           id = solv->job.elements[i + 1];
1993           s = testcase_dep2str(pool, id);
1994           strqueue_push(&sq, pool_tmpjoin(pool, "genid dep ", s, 0));
1995           if ((id2 = testcase_str2dep(pool, s)) != id)
1996             {
1997               s = pool_tmpjoin(pool, "genid roundtrip error: ", testcase_dep2str(pool, id2), 0);
1998               strqueue_push(&sq, s);
1999             }
2000           dump_genid(pool, &sq, id, 1);
2001         }
2002     }
2003   strqueue_sort(&sq);
2004   result = strqueue_join(&sq);
2005   strqueue_free(&sq);
2006   return result;
2007 }
2008
2009
2010 int
2011 testcase_write(Solver *solv, const char *dir, int resultflags, const char *testcasename, const char *resultname)
2012 {
2013   Pool *pool = solv->pool;
2014   Repo *repo;
2015   int i;
2016   Id arch, repoid;
2017   Id lowscore;
2018   FILE *fp;
2019   Strqueue sq;
2020   char *cmd, *out;
2021   const char *s;
2022
2023   if (!testcasename)
2024     testcasename = "testcase.t";
2025   if (!resultname)
2026     resultname = "solver.result";
2027
2028   if (mkdir(dir, 0777) && errno != EEXIST)
2029     {
2030       pool_debug(solv->pool, SOLV_ERROR, "testcase_write: could not create directory '%s'\n", dir);
2031       return 0;
2032     }
2033   strqueue_init(&sq);
2034   FOR_REPOS(repoid, repo)
2035     {
2036       const char *name = testcase_repoid2str(pool, repoid);
2037       char priobuf[50];
2038       if (repo->subpriority)
2039         sprintf(priobuf, "%d.%d", repo->priority, repo->subpriority);
2040       else
2041         sprintf(priobuf, "%d", repo->priority);
2042       out = pool_tmpjoin(pool, name, ".repo", ".gz");
2043       cmd = pool_tmpjoin(pool, "repo ", name, " ");
2044       cmd = pool_tmpappend(pool, cmd, priobuf, " ");
2045       cmd = pool_tmpappend(pool, cmd, "testtags ", out);
2046       strqueue_push(&sq, cmd);
2047       out = pool_tmpjoin(pool, dir, "/", out);
2048       if (!(fp = solv_xfopen(out, "w")))
2049         {
2050           pool_debug(solv->pool, SOLV_ERROR, "testcase_write: could not open '%s' for writing\n", out);
2051           strqueue_free(&sq);
2052           return 0;
2053         }
2054       testcase_write_testtags(repo, fp);
2055       if (fclose(fp))
2056         {
2057           pool_debug(solv->pool, SOLV_ERROR, "testcase_write: write error\n");
2058           strqueue_free(&sq);
2059           return 0;
2060         }
2061     }
2062   /* hmm, this is not optimal... we currently search for the lowest score */
2063   lowscore = 0;
2064   arch = pool->solvables[SYSTEMSOLVABLE].arch;
2065   for (i = 0; i < pool->lastarch; i++)
2066     {
2067       if (pool->id2arch[i] == 1 && !lowscore)
2068         arch = i;
2069       if (pool->id2arch[i] > 0x10000 && (!lowscore || pool->id2arch[i] < lowscore))
2070         {
2071           arch = i;
2072           lowscore = pool->id2arch[i];
2073         }
2074     }
2075   cmd = pool_tmpjoin(pool, "system ", pool->lastarch ? pool_id2str(pool, arch) : "unset", 0);
2076   for (i = 0; disttype2str[i].str != 0; i++)
2077     if (pool->disttype == disttype2str[i].type)
2078       break;
2079   pool_tmpappend(pool, cmd, " ", disttype2str[i].str ? disttype2str[i].str : "unknown");
2080   if (pool->installed)
2081     cmd = pool_tmpappend(pool, cmd, " ", testcase_repoid2str(pool, pool->installed->repoid));
2082   strqueue_push(&sq, cmd);
2083   s = testcase_getpoolflags(solv->pool);
2084   if (*s)
2085     {
2086       cmd = pool_tmpjoin(pool, "poolflags ", s, 0);
2087       strqueue_push(&sq, cmd);
2088     }
2089
2090   if (pool->vendorclasses)
2091     {
2092       cmd = 0;
2093       for (i = 0; pool->vendorclasses[i]; i++)
2094         {
2095           cmd = pool_tmpappend(pool, cmd ? cmd : "vendorclass", " ", pool->vendorclasses[i]);
2096           if (!pool->vendorclasses[i + 1])
2097             {
2098               strqueue_push(&sq, cmd);
2099               cmd = 0;
2100               i++;
2101             }
2102         }
2103     }
2104
2105   /* dump disabled packages (must come before the namespace/job lines) */
2106   if (pool->considered)
2107     {
2108       Id p;
2109       FOR_POOL_SOLVABLES(p)
2110         if (!MAPTST(pool->considered, p))
2111           {
2112             cmd = pool_tmpjoin(pool, "disable pkg ", testcase_solvid2str(pool, p), 0);
2113             strqueue_push(&sq, cmd);
2114           }
2115     }
2116
2117   s = testcase_getsolverflags(solv);
2118   if (*s)
2119     {
2120       cmd = pool_tmpjoin(pool, "solverflags ", s, 0);
2121       strqueue_push(&sq, cmd);
2122     }
2123
2124   /* now dump all the ns callback values we know */
2125   if (pool->nscallback)
2126     {
2127       Id rid;
2128       int d;
2129       for (rid = 1; rid < pool->nrels; rid++)
2130         {
2131           Reldep *rd = pool->rels + rid;
2132           if (rd->flags != REL_NAMESPACE || rd->name == NAMESPACE_OTHERPROVIDERS)
2133             continue;
2134           /* evaluate all namespace ids, skip empty results */
2135           d = pool_whatprovides(pool, MAKERELDEP(rid));
2136           if (!d || !pool->whatprovidesdata[d])
2137             continue;
2138           cmd = pool_tmpjoin(pool, "namespace ", pool_id2str(pool, rd->name), "(");
2139           cmd = pool_tmpappend(pool, cmd, pool_id2str(pool, rd->evr), ")");
2140           for (;  pool->whatprovidesdata[d]; d++)
2141             cmd = pool_tmpappend(pool, cmd, " ", testcase_solvid2str(pool, pool->whatprovidesdata[d]));
2142           strqueue_push(&sq, cmd);
2143         }
2144     }
2145
2146   for (i = 0; i < solv->job.count; i += 2)
2147     {
2148       cmd = (char *)testcase_job2str(pool, solv->job.elements[i], solv->job.elements[i + 1]);
2149       cmd = pool_tmpjoin(pool, "job ", cmd, 0);
2150       strqueue_push(&sq, cmd);
2151     }
2152
2153   if (resultflags)
2154     {
2155       char *result;
2156       cmd = 0;
2157       for (i = 0; resultflags2str[i].str; i++)
2158         if ((resultflags & resultflags2str[i].flag) != 0)
2159           cmd = pool_tmpappend(pool, cmd, cmd ? "," : 0, resultflags2str[i].str);
2160       cmd = pool_tmpjoin(pool, "result ", cmd ? cmd : "?", 0);
2161       cmd = pool_tmpappend(pool, cmd, " ", resultname);
2162       strqueue_push(&sq, cmd);
2163       result = testcase_solverresult(solv, resultflags);
2164       if (!strcmp(resultname, "<inline>"))
2165         {
2166           int i;
2167           Strqueue rsq;
2168           strqueue_init(&rsq);
2169           strqueue_split(&rsq, result);
2170           for (i = 0; i < rsq.nstr; i++)
2171             {
2172               cmd = pool_tmpjoin(pool, "#>", rsq.str[i], 0);
2173               strqueue_push(&sq, cmd);
2174             }
2175           strqueue_free(&rsq);
2176         }
2177       else
2178         {
2179           out = pool_tmpjoin(pool, dir, "/", resultname);
2180           if (!(fp = fopen(out, "w")))
2181             {
2182               pool_debug(solv->pool, SOLV_ERROR, "testcase_write: could not open '%s' for writing\n", out);
2183               solv_free(result);
2184               strqueue_free(&sq);
2185               return 0;
2186             }
2187           if (result && *result && fwrite(result, strlen(result), 1, fp) != 1)
2188             {
2189               pool_debug(solv->pool, SOLV_ERROR, "testcase_write: write error\n");
2190               solv_free(result);
2191               strqueue_free(&sq);
2192               fclose(fp);
2193               return 0;
2194             }
2195           if (fclose(fp))
2196             {
2197               pool_debug(solv->pool, SOLV_ERROR, "testcase_write: write error\n");
2198               strqueue_free(&sq);
2199               return 0;
2200             }
2201         }
2202       solv_free(result);
2203     }
2204
2205   cmd = strqueue_join(&sq);
2206   out = pool_tmpjoin(pool, dir, "/", testcasename);
2207   if (!(fp = fopen(out, "w")))
2208     {
2209       pool_debug(solv->pool, SOLV_ERROR, "testcase_write: could not open '%s' for writing\n", out);
2210       strqueue_free(&sq);
2211       return 0;
2212     }
2213   if (*cmd && fwrite(cmd, strlen(cmd), 1, fp) != 1)
2214     {
2215       pool_debug(solv->pool, SOLV_ERROR, "testcase_write: write error\n");
2216       strqueue_free(&sq);
2217       fclose(fp);
2218       return 0;
2219     }
2220   if (fclose(fp))
2221     {
2222       pool_debug(solv->pool, SOLV_ERROR, "testcase_write: write error\n");
2223       strqueue_free(&sq);
2224       return 0;
2225     }
2226   solv_free(cmd);
2227   strqueue_free(&sq);
2228   return 1;
2229 }
2230
2231 static char *
2232 read_inline_file(FILE *fp, char **bufp, char **bufpp, int *buflp)
2233 {
2234   char *result = solv_malloc(1024);
2235   char *rp = result;
2236   int resultl = 1024;
2237
2238   for (;;)
2239     {
2240       size_t rl;
2241       if (rp - result + 256 >= resultl)
2242         {
2243           resultl = rp - result;
2244           result = solv_realloc(result, resultl + 1024);
2245           rp = result + resultl;
2246           resultl += 1024;
2247         }
2248       if (!fgets(rp, resultl - (rp - result), fp))
2249         *rp = 0;
2250       rl = strlen(rp);
2251       if (rl && (rp == result || rp[-1] == '\n'))
2252         {
2253           if (rl > 1 && rp[0] == '#' && rp[1] == '>')
2254             {
2255               memmove(rp, rp + 2, rl - 2);
2256               rl -= 2;
2257             }
2258           else
2259             {
2260               while (rl + 16 > *buflp)
2261                 {
2262                   *bufp = solv_realloc(*bufp, *buflp + 512);
2263                   *buflp += 512;
2264                 }
2265               memmove(*bufp, rp, rl);
2266               if ((*bufp)[rl - 1] == '\n')
2267                 {
2268                   ungetc('\n', fp);
2269                   rl--;
2270                 }
2271               (*bufp)[rl] = 0;
2272               (*bufpp) = *bufp + rl;
2273               rl = 0;
2274             }
2275         }
2276       if (rl <= 0)
2277         {
2278           *rp = 0;
2279           break;
2280         }
2281       rp += rl;
2282     }
2283   return result;
2284 }
2285
2286 static char *
2287 read_file(FILE *fp)
2288 {
2289   char *result = solv_malloc(1024);
2290   char *rp = result;
2291   int resultl = 1024;
2292
2293   for (;;)
2294     {
2295       size_t rl;
2296       if (rp - result + 256 >= resultl)
2297         {
2298           resultl = rp - result;
2299           result = solv_realloc(result, resultl + 1024);
2300           rp = result + resultl;
2301           resultl += 1024;
2302         }
2303       rl = fread(rp, 1, resultl - (rp - result), fp);
2304       if (rl <= 0)
2305         {
2306           *rp = 0;
2307           break;
2308         }
2309       rp += rl;
2310     }
2311   return result;
2312 }
2313
2314 static int
2315 str2resultflags(Pool *pool, char *s)    /* modifies the string! */
2316 {
2317   int i, resultflags = 0;
2318   while (s)
2319     {
2320       char *se = strchr(s, ',');
2321       if (se)
2322         *se++ = 0;
2323       for (i = 0; resultflags2str[i].str; i++)
2324         if (!strcmp(s, resultflags2str[i].str))
2325           {
2326             resultflags |= resultflags2str[i].flag;
2327             break;
2328           }
2329       if (!resultflags2str[i].str)
2330         pool_debug(pool, SOLV_ERROR, "result: unknown flag '%s'\n", s);
2331       s = se;
2332     }
2333   return resultflags;
2334 }
2335
2336 Solver *
2337 testcase_read(Pool *pool, FILE *fp, const char *testcase, Queue *job, char **resultp, int *resultflagsp)
2338 {
2339   Solver *solv;
2340   char *buf, *bufp;
2341   int bufl;
2342   char *testcasedir, *s;
2343   int l;
2344   char **pieces = 0;
2345   int npieces = 0;
2346   int prepared = 0;
2347   int closefp = !fp;
2348   int poolflagsreset = 0;
2349   int missing_features = 0;
2350   Id *genid = 0;
2351   int ngenid = 0;
2352
2353   if (!fp && !(fp = fopen(testcase, "r")))
2354     {
2355       pool_debug(pool, SOLV_ERROR, "testcase_read: could not open '%s'\n", testcase);
2356       return 0;
2357     }
2358   testcasedir = solv_strdup(testcase);
2359   if ((s = strrchr(testcasedir, '/')) != 0)
2360     s[1] = 0;
2361   else
2362     *testcasedir = 0;
2363   bufl = 1024;
2364   buf = solv_malloc(bufl);
2365   bufp = buf;
2366   solv = 0;
2367   for (;;)
2368     {
2369       if (bufp - buf + 16 > bufl)
2370         {
2371           bufl = bufp - buf;
2372           buf = solv_realloc(buf, bufl + 512);
2373           bufp = buf + bufl;
2374           bufl += 512;
2375         }
2376       if (!fgets(bufp, bufl - (bufp - buf), fp))
2377         break;
2378       bufp = buf;
2379       l = strlen(buf);
2380       if (!l || buf[l - 1] != '\n')
2381         {
2382           bufp += l;
2383           continue;
2384         }
2385       buf[--l] = 0;
2386       s = buf;
2387       while (*s && (*s == ' ' || *s == '\t'))
2388         s++;
2389       if (!*s || *s == '#')
2390         continue;
2391       npieces = 0;
2392       /* split it in pieces */
2393       for (;;)
2394         {
2395           while (*s == ' ' || *s == '\t')
2396             s++;
2397           if (!*s)
2398             break;
2399           pieces = solv_extend(pieces, npieces, 1, sizeof(*pieces), 7);
2400           pieces[npieces++] = s;
2401           while (*s && *s != ' ' && *s != '\t')
2402             s++;
2403           if (*s)
2404             *s++ = 0;
2405         }
2406       pieces = solv_extend(pieces, npieces, 1, sizeof(*pieces), 7);
2407       pieces[npieces] = 0;
2408       if (!strcmp(pieces[0], "repo") && npieces >= 4)
2409         {
2410           Repo *repo = repo_create(pool, pieces[1]);
2411           FILE *rfp;
2412           int prio, subprio;
2413           const char *rdata;
2414
2415           prepared = 0;
2416           if (!poolflagsreset)
2417             {
2418               poolflagsreset = 1;
2419               testcase_resetpoolflags(pool);    /* hmm */
2420             }
2421           if (sscanf(pieces[2], "%d.%d", &prio, &subprio) != 2)
2422             {
2423               subprio = 0;
2424               prio = atoi(pieces[2]);
2425             }
2426           repo->priority = prio;
2427           repo->subpriority = subprio;
2428           if (strcmp(pieces[3], "empty") != 0)
2429             {
2430               const char *repotype = pool_tmpjoin(pool, pieces[3], 0, 0);       /* gets overwritten in <inline> case */
2431               if (!strcmp(pieces[4], "<inline>"))
2432                 {
2433                   char *idata = read_inline_file(fp, &buf, &bufp, &bufl);
2434                   rdata = "<inline>";
2435                   rfp = solv_xfopen_buf(rdata, &idata, 0, "rf");
2436                 }
2437               else
2438                 {
2439                   rdata = pool_tmpjoin(pool, testcasedir, pieces[4], 0);
2440                   rfp = solv_xfopen(rdata, "r");
2441                 }
2442               if (!rfp)
2443                 {
2444                   pool_debug(pool, SOLV_ERROR, "testcase_read: could not open '%s'\n", rdata);
2445                 }
2446               else if (!strcmp(repotype, "testtags"))
2447                 {
2448                   testcase_add_testtags(repo, rfp, 0);
2449                   fclose(rfp);
2450                 }
2451               else if (!strcmp(repotype, "solv"))
2452                 {
2453                   repo_add_solv(repo, rfp, 0);
2454                   fclose(rfp);
2455                 }
2456 #if 0
2457               else if (!strcmp(repotype, "helix"))
2458                 {
2459                   extern int repo_add_helix(Repo *repo, FILE *fp, int flags);
2460                   repo_add_helix(repo, rfp, 0);
2461                   fclose(rfp);
2462                 }
2463 #endif
2464               else
2465                 {
2466                   fclose(rfp);
2467                   pool_debug(pool, SOLV_ERROR, "testcase_read: unknown repo type for repo '%s'\n", repo->name);
2468                 }
2469             }
2470         }
2471       else if (!strcmp(pieces[0], "system") && npieces >= 3)
2472         {
2473           int i;
2474
2475           /* must set the disttype before the arch */
2476           prepared = 0;
2477           if (strcmp(pieces[2], "*") != 0)
2478             {
2479               char *dp = pieces[2];
2480               while (dp && *dp)
2481                 {
2482                   char *dpe = strchr(dp, ',');
2483                   if (dpe)
2484                     *dpe = 0;
2485                   for (i = 0; disttype2str[i].str != 0; i++)
2486                     if (!strcmp(disttype2str[i].str, dp))
2487                       break;
2488                   if (dpe)
2489                     *dpe++ = ',';
2490                   if (disttype2str[i].str)
2491                     {
2492 #ifdef MULTI_SEMANTICS
2493                       if (pool->disttype != disttype2str[i].type)
2494                         pool_setdisttype(pool, disttype2str[i].type);
2495 #endif
2496                       if (pool->disttype == disttype2str[i].type)
2497                         break;
2498                     }
2499                   dp = dpe;
2500                 }
2501               if (!(dp && *dp))
2502                 {
2503                   pool_debug(pool, SOLV_ERROR, "testcase_read: system: could not change disttype to '%s'\n", pieces[2]);
2504                   missing_features = 1;
2505                 }
2506             }
2507           if (strcmp(pieces[1], "unset") == 0)
2508             pool_setarch(pool, 0);
2509           else if (pieces[1][0] == ':')
2510             pool_setarchpolicy(pool, pieces[1] + 1);
2511           else
2512             pool_setarch(pool, pieces[1]);
2513           if (npieces > 3)
2514             {
2515               Repo *repo = testcase_str2repo(pool, pieces[3]);
2516               if (!repo)
2517                 pool_debug(pool, SOLV_ERROR, "testcase_read: system: unknown repo '%s'\n", pieces[3]);
2518               else
2519                 pool_set_installed(pool, repo);
2520             }
2521         }
2522       else if (!strcmp(pieces[0], "job") && npieces > 1)
2523         {
2524           char *sp;
2525           Id how, what;
2526           if (prepared <= 0)
2527             {
2528               pool_addfileprovides(pool);
2529               pool_createwhatprovides(pool);
2530               prepared = 1;
2531             }
2532           if (npieces >= 3 && !strcmp(pieces[2], "selection"))
2533             {
2534               addselectionjob(pool, pieces + 1, npieces - 1, job);
2535               continue;
2536             }
2537           /* rejoin */
2538           for (sp = pieces[1]; sp < pieces[npieces - 1]; sp++)
2539             if (*sp == 0)
2540               *sp = ' ';
2541           how = testcase_str2job(pool, pieces[1], &what);
2542           if (how >= 0 && job)
2543             queue_push2(job, how, what);
2544         }
2545       else if (!strcmp(pieces[0], "vendorclass") && npieces > 1)
2546         {
2547           pool_addvendorclass(pool, (const char **)(pieces + 1));
2548         }
2549       else if (!strcmp(pieces[0], "namespace") && npieces > 1)
2550         {
2551           int i = strlen(pieces[1]);
2552           s = strchr(pieces[1], '(');
2553           if (!s && pieces[1][i - 1] != ')')
2554             {
2555               pool_debug(pool, SOLV_ERROR, "testcase_read: bad namespace '%s'\n", pieces[1]);
2556             }
2557           else
2558             {
2559               Id name, evr, id;
2560               Queue q;
2561               queue_init(&q);
2562               *s = 0;
2563               pieces[1][i - 1] = 0;
2564               name = pool_str2id(pool, pieces[1], 1);
2565               evr = pool_str2id(pool, s + 1, 1);
2566               *s = '(';
2567               pieces[1][i - 1] = ')';
2568               id = pool_rel2id(pool, name, evr, REL_NAMESPACE, 1);
2569               for (i = 2; i < npieces; i++)
2570                 queue_push(&q, testcase_str2solvid(pool, pieces[i]));
2571               /* now do the callback */
2572               if (prepared <= 0)
2573                 {
2574                   pool_addfileprovides(pool);
2575                   pool_createwhatprovides(pool);
2576                   prepared = 1;
2577                 }
2578               pool->whatprovides_rel[GETRELID(id)] = pool_queuetowhatprovides(pool, &q);
2579               queue_free(&q);
2580             }
2581         }
2582       else if (!strcmp(pieces[0], "poolflags"))
2583         {
2584           int i;
2585           if (!poolflagsreset)
2586             {
2587               poolflagsreset = 1;
2588               testcase_resetpoolflags(pool);    /* hmm */
2589             }
2590           for (i = 1; i < npieces; i++)
2591             testcase_setpoolflags(pool, pieces[i]);
2592         }
2593       else if (!strcmp(pieces[0], "solverflags") && npieces > 1)
2594         {
2595           int i;
2596           if (!solv)
2597             {
2598               solv = solver_create(pool);
2599               testcase_resetsolverflags(solv);
2600             }
2601           for (i = 1; i < npieces; i++)
2602             testcase_setsolverflags(solv, pieces[i]);
2603         }
2604       else if (!strcmp(pieces[0], "result") && npieces > 1)
2605         {
2606           char *result = 0;
2607           int resultflags = str2resultflags(pool, pieces[1]);
2608           const char *rdata;
2609           if (npieces > 2)
2610             {
2611               rdata = pool_tmpjoin(pool, testcasedir, pieces[2], 0);
2612               if (!strcmp(pieces[2], "<inline>"))
2613                 result = read_inline_file(fp, &buf, &bufp, &bufl);
2614               else
2615                 {
2616                   FILE *rfp = fopen(rdata, "r");
2617                   if (!rfp)
2618                     pool_debug(pool, SOLV_ERROR, "testcase_read: could not open '%s'\n", rdata);
2619                   else
2620                     {
2621                       result = read_file(rfp);
2622                       fclose(rfp);
2623                     }
2624                 }
2625             }
2626           if (resultp)
2627             *resultp = result;
2628           else
2629             solv_free(result);
2630           if (resultflagsp)
2631             *resultflagsp = resultflags;
2632         }
2633       else if (!strcmp(pieces[0], "nextjob") && npieces == 1)
2634         {
2635           break;
2636         }
2637       else if (!strcmp(pieces[0], "disable") && npieces == 3)
2638         {
2639           Id p;
2640           if (strcmp(pieces[1], "pkg"))
2641             {
2642               pool_debug(pool, SOLV_ERROR, "testcase_read: bad disable type '%s'\n", pieces[1]);
2643               continue;
2644             }
2645           if (!prepared)
2646             pool_createwhatprovides(pool);
2647           prepared = -1;
2648           if (!pool->considered)
2649             {
2650               pool->considered = solv_calloc(1, sizeof(Map));
2651               map_init(pool->considered, pool->nsolvables);
2652               map_setall(pool->considered);
2653             }
2654           p = testcase_str2solvid(pool, pieces[2]);
2655           if (p)
2656             MAPCLR(pool->considered, p);
2657           else
2658             pool_debug(pool, SOLV_ERROR, "disable: unknown package '%s'\n", pieces[2]);
2659         }
2660       else if (!strcmp(pieces[0], "feature"))
2661         {
2662           int i, j;
2663           for (i = 1; i < npieces; i++)
2664             {
2665               for (j = 0; features[j]; j++)
2666                 if (!strcmp(pieces[i], features[j]))
2667                   break;
2668               if (!features[j])
2669                 {
2670                   pool_debug(pool, SOLV_ERROR, "testcase_read: missing feature '%s'\n", pieces[i]);
2671                   missing_features++;
2672                 }
2673             }
2674           if (missing_features)
2675             break;
2676         }
2677       else if (!strcmp(pieces[0], "genid") && npieces > 1)
2678         {
2679           Id id;
2680           /* rejoin */
2681           if (npieces > 2)
2682             {
2683               char *sp;
2684               for (sp = pieces[2]; sp < pieces[npieces - 1]; sp++)
2685                 if (*sp == 0)
2686                   *sp = ' ';
2687             }
2688           genid = solv_extend(genid, ngenid, 1, sizeof(*genid), 7);
2689           if (!strcmp(pieces[1], "op") && npieces > 2)
2690             {
2691               struct oplist *op;
2692               for (op = oplist; op->flags; op++)
2693                 if (!strncmp(pieces[2], op->opname, strlen(op->opname)))
2694                   break;
2695               if (!op->flags)
2696                 {
2697                   pool_debug(pool, SOLV_ERROR, "testcase_read: genid: unknown op '%s'\n", pieces[2]);
2698                   break;
2699                 }
2700               if (ngenid < 2)
2701                 {
2702                   pool_debug(pool, SOLV_ERROR, "testcase_read: genid: out of stack\n");
2703                   break;
2704                 }
2705               ngenid -= 2;
2706               id = pool_rel2id(pool, genid[ngenid] , genid[ngenid + 1], op->flags, 1);
2707             }
2708           else if (!strcmp(pieces[1], "lit"))
2709             id = pool_str2id(pool, npieces > 2 ? pieces[2] : "", 1);
2710           else if (!strcmp(pieces[1], "null"))
2711             id = 0;
2712           else if (!strcmp(pieces[1], "dep"))
2713             id = testcase_str2dep(pool, pieces[2]);
2714           else
2715             {
2716               pool_debug(pool, SOLV_ERROR, "testcase_read: genid: unknown command '%s'\n", pieces[1]);
2717               break;
2718             }
2719           genid[ngenid++] = id;
2720         }
2721       else
2722         {
2723           pool_debug(pool, SOLV_ERROR, "testcase_read: cannot parse command '%s'\n", pieces[0]);
2724         }
2725     }
2726   while (job && ngenid > 0)
2727     queue_push2(job, SOLVER_NOOP | SOLVER_SOLVABLE_PROVIDES, genid[--ngenid]);
2728   genid = solv_free(genid);
2729   buf = solv_free(buf);
2730   pieces = solv_free(pieces);
2731   solv_free(testcasedir);
2732   if (!prepared)
2733     {
2734       pool_addfileprovides(pool);
2735       pool_createwhatprovides(pool);
2736     }
2737   if (!solv)
2738     {
2739       solv = solver_create(pool);
2740       testcase_resetsolverflags(solv);
2741     }
2742   if (closefp)
2743     fclose(fp);
2744   if (missing_features)
2745     {
2746       solver_free(solv);
2747       solv = 0;
2748       if (resultflagsp)
2749         *resultflagsp = 77;     /* hack for testsolv */
2750     }
2751   return solv;
2752 }
2753
2754 char *
2755 testcase_resultdiff(const char *result1, const char *result2)
2756 {
2757   Strqueue sq1, sq2, osq;
2758   char *r;
2759   strqueue_init(&sq1);
2760   strqueue_init(&sq2);
2761   strqueue_init(&osq);
2762   strqueue_split(&sq1, result1);
2763   strqueue_split(&sq2, result2);
2764   strqueue_sort(&sq1);
2765   strqueue_sort(&sq2);
2766   strqueue_diff(&sq1, &sq2, &osq);
2767   r = osq.nstr ? strqueue_join(&osq) : 0;
2768   strqueue_free(&sq1);
2769   strqueue_free(&sq2);
2770   strqueue_free(&osq);
2771   return r;
2772 }
2773