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   { 0, 0 }
  49 };
  50
  51 static struct jobflags2str {
  52   Id flag;
  53   const char *str;
  54 } jobflags2str[] = {
  55   { SOLVER_WEAK,      "weak" },
  56   { SOLVER_ESSENTIAL, "essential" },
  57   { SOLVER_CLEANDEPS, "cleandeps" },
  58   { SOLVER_ORUPDATE,  "orupdate" },
  59   { SOLVER_FORCEBEST, "forcebest" },
  60   { SOLVER_TARGETED,  "targeted" },
  61   { SOLVER_SETEV,     "setev" },
  62   { SOLVER_SETEVR,    "setevr" },
  63   { SOLVER_SETARCH,   "setarch" },
  64   { SOLVER_SETVENDOR, "setvendor" },
  65   { SOLVER_SETREPO,   "setrepo" },
  66   { SOLVER_NOAUTOSET, "noautoset" },
  67   { 0, 0 }
  68 };
  69
  70 static struct resultflags2str {
  71   Id flag;
  72   const char *str;
  73 } resultflags2str[] = {
  74   { TESTCASE_RESULT_TRANSACTION,        "transaction" },
  75   { TESTCASE_RESULT_PROBLEMS,           "problems" },
  76   { TESTCASE_RESULT_ORPHANED,           "orphaned" },
  77   { TESTCASE_RESULT_RECOMMENDED,        "recommended" },
  78   { TESTCASE_RESULT_UNNEEDED,           "unneeded" },
  79   { 0, 0 }
  80 };
  81
  82 static struct solverflags2str {
  83   Id flag;
  84   const char *str;
  85   int def;
  86 } solverflags2str[] = {
  87   { SOLVER_FLAG_ALLOW_DOWNGRADE,            "allowdowngrade", 0 },
  88   { SOLVER_FLAG_ALLOW_NAMECHANGE,           "allownamechange", 1 },
  89   { SOLVER_FLAG_ALLOW_ARCHCHANGE,           "allowarchchange", 0 },
  90   { SOLVER_FLAG_ALLOW_VENDORCHANGE,         "allowvendorchange", 0 },
  91   { SOLVER_FLAG_ALLOW_UNINSTALL,            "allowuninstall", 0 },
  92   { SOLVER_FLAG_NO_UPDATEPROVIDE,           "noupdateprovide", 0 },
  93   { SOLVER_FLAG_SPLITPROVIDES,              "splitprovides", 0 },
  94   { SOLVER_FLAG_IGNORE_RECOMMENDED,         "ignorerecommended", 0 },
  95   { SOLVER_FLAG_ADD_ALREADY_RECOMMENDED,    "addalreadyrecommended", 0 },
  96   { SOLVER_FLAG_NO_INFARCHCHECK,            "noinfarchcheck", 0 },
  97   { SOLVER_FLAG_KEEP_EXPLICIT_OBSOLETES,    "keepexplicitobsoletes", 0 },
  98   { SOLVER_FLAG_BEST_OBEY_POLICY,           "bestobeypolicy", 0 },
  99   { SOLVER_FLAG_NO_AUTOTARGET,              "noautotarget", 0 },
 100   { 0, 0, 0 }
 101 };
 102
 103 static struct poolflags2str {
 104   Id flag;
 105   const char *str;
 106   int def;
 107 } poolflags2str[] = {
 108   { POOL_FLAG_PROMOTEEPOCH,                 "promoteepoch", 0 },
 109   { POOL_FLAG_FORBIDSELFCONFLICTS,          "forbidselfconflicts", 0 },
 110   { POOL_FLAG_OBSOLETEUSESPROVIDES,         "obsoleteusesprovides", 0 },
 111   { POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES, "implicitobsoleteusesprovides", 0 },
 112   { POOL_FLAG_OBSOLETEUSESCOLORS,           "obsoleteusescolors", 0 },
 113   { POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS,   "implicitobsoleteusescolors", 0 },
 114   { POOL_FLAG_NOINSTALLEDOBSOLETES,         "noinstalledobsoletes", 0 },
 115   { POOL_FLAG_HAVEDISTEPOCH,                "havedistepoch", 0 },
 116   { POOL_FLAG_NOOBSOLETESMULTIVERSION,      "noobsoletesmultiversion", 0 },
 117   { POOL_FLAG_ADDFILEPROVIDESFILTERED,      "addfileprovidesfiltered", 0 },
 118   { 0, 0, 0 }
 119 };
 120
 121 static struct disttype2str {
 122   Id type;
 123   const char *str;
 124 } disttype2str[] = {
 125   { DISTTYPE_RPM,  "rpm" },
 126   { DISTTYPE_DEB,  "deb" },
 127   { DISTTYPE_ARCH, "arch" },
 128   { 0, 0 }
 129 };
 130
 131 static struct selflags2str {
 132   Id flag;
 133   const char *str;
 134 } selflags2str[] = {
 135   { SELECTION_NAME, "name" },
 136   { SELECTION_PROVIDES, "provides" },
 137   { SELECTION_FILELIST, "filelist" },
 138   { SELECTION_CANON, "canon" },
 139   { SELECTION_DOTARCH, "dotarch" },
 140   { SELECTION_REL, "rel" },
 141   { SELECTION_INSTALLED_ONLY, "installedonly" },
 142   { SELECTION_GLOB, "glob" },
 143   { SELECTION_FLAT, "flat" },
 144   { SELECTION_NOCASE, "nocase" },
 145   { SELECTION_SOURCE_ONLY, "sourceonly" },
 146   { SELECTION_WITH_SOURCE, "withsource" },
 147   { 0, 0 }
 148 };
 149
 150
 151 typedef struct strqueue {
 152   char **str;
 153   int nstr;
 154 } Strqueue;
 155
 156 #define STRQUEUE_BLOCK 63
 157
 158 static void
 159 strqueue_init(Strqueue *q)
 160 {
 161   q->str = 0;
 162   q->nstr = 0;
 163 }
 164
 165 static void
 166 strqueue_free(Strqueue *q)
 167 {
 168   int i;
 169   for (i = 0; i < q->nstr; i++)
 170     solv_free(q->str[i]);
 171   q->str = solv_free(q->str);
 172   q->nstr = 0;
 173 }
 174
 175 static void
 176 strqueue_push(Strqueue *q, const char *s)
 177 {
 178   q->str = solv_extend(q->str, q->nstr, 1, sizeof(*q->str), STRQUEUE_BLOCK);
 179   q->str[q->nstr++] = solv_strdup(s);
 180 }
 181
 182 static void
 183 strqueue_pushjoin(Strqueue *q, const char *s1, const char *s2, const char *s3)
 184 {
 185   q->str = solv_extend(q->str, q->nstr, 1, sizeof(*q->str), STRQUEUE_BLOCK);
 186   q->str[q->nstr++] = solv_dupjoin(s1, s2, s3);
 187 }
 188
 189 static int
 190 strqueue_sort_cmp(const void *ap, const void *bp, void *dp)
 191 {
 192   const char *a = *(const char **)ap;
 193   const char *b = *(const char **)bp;
 194   return strcmp(a ? a : "", b ? b : "");
 195 }
 196
 197 static void
 198 strqueue_sort(Strqueue *q)
 199 {
 200   if (q->nstr > 1)
 201     solv_sort(q->str, q->nstr, sizeof(*q->str), strqueue_sort_cmp, 0);
 202 }
 203
 204 static void
 205 strqueue_sort_u(Strqueue *q)
 206 {
 207   int i, j;
 208   strqueue_sort(q);
 209   for (i = j = 0; i < q->nstr; i++)
 210     if (!j || strqueue_sort_cmp(q->str + i, q->str + j - 1, 0) != 0)
 211       q->str[j++] = q->str[i];
 212   q->nstr = j;
 213 }
 214
 215 static char *
 216 strqueue_join(Strqueue *q)
 217 {
 218   int i, l = 0;
 219   char *r, *rp;
 220   for (i = 0; i < q->nstr; i++)
 221     if (q->str[i])
 222       l += strlen(q->str[i]) + 1;
 223   l++;  /* trailing \0 */
 224   r = solv_malloc(l);
 225   rp = r;
 226   for (i = 0; i < q->nstr; i++)
 227     if (q->str[i])
 228       {
 229         strcpy(rp, q->str[i]);
 230         rp += strlen(rp);
 231         *rp++ = '\n';
 232       }
 233   *rp = 0;
 234   return r;
 235 }
 236
 237 static void
 238 strqueue_split(Strqueue *q, const char *s)
 239 {
 240   const char *p;
 241   if (!s)
 242     return;
 243   while ((p = strchr(s, '\n')) != 0)
 244     {
 245       q->str = solv_extend(q->str, q->nstr, 1, sizeof(*q->str), STRQUEUE_BLOCK);
 246       q->str[q->nstr] = solv_malloc(p - s + 1);
 247       if (p > s)
 248         memcpy(q->str[q->nstr], s, p - s);
 249       q->str[q->nstr][p - s] = 0;
 250       q->nstr++;
 251       s = p + 1;
 252     }
 253   if (*s)
 254     strqueue_push(q, s);
 255 }
 256
 257 static void
 258 strqueue_diff(Strqueue *sq1, Strqueue *sq2, Strqueue *osq)
 259 {
 260   int i = 0, j = 0;
 261   while (i < sq1->nstr && j < sq2->nstr)
 262     {
 263       int r = strqueue_sort_cmp(sq1->str + i, sq2->str + j, 0);
 264       if (!r)
 265         i++, j++;
 266       else if (r < 0)
 267         strqueue_pushjoin(osq, "-", sq1->str[i++], 0);
 268       else
 269         strqueue_pushjoin(osq, "+", sq2->str[j++], 0);
 270     }
 271   while (i < sq1->nstr)
 272     strqueue_pushjoin(osq, "-", sq1->str[i++], 0);
 273   while (j < sq2->nstr)
 274     strqueue_pushjoin(osq, "+", sq2->str[j++], 0);
 275 }
 276
 277 static inline int
 278 pool_isknownarch(Pool *pool, Id id)
 279 {
 280   if (!id || id == ID_EMPTY)
 281     return 0;
 282   if (id == ARCH_SRC || id == ARCH_NOSRC || id == ARCH_NOARCH)
 283     return 1;
 284   if (!pool->id2arch || (id > pool->lastarch || !pool->id2arch[id]))
 285     return 0;
 286   return 1;
 287 }
 288
 289 Id
 290 testcase_str2dep(Pool *pool, char *s)
 291 {
 292   char *n, *a;
 293   Id id;
 294   int flags;
 295
 296   if ((n = strchr(s, '|')) != 0)
 297     {
 298       id = testcase_str2dep(pool, n + 1);
 299       *n = 0;
 300       id = pool_rel2id(pool, testcase_str2dep(pool, s), id, REL_OR, 1);
 301       *n = '|';
 302       return id;
 303     }
 304   while (*s == ' ' || *s == '\t')
 305     s++;
 306   n = s;
 307   while (*s && *s != ' ' && *s != '\t' && *s != '<' && *s != '=' && *s != '>')
 308     {
 309       if (*s == '(')
 310         {
 311           while (*s && *s != ')')
 312             s++;
 313         }
 314       else
 315         s++;
 316     }
 317   if ((a = strchr(n, '.')) != 0 && a + 1 < s && s[-1] != ')')
 318     {
 319       Id archid = pool_strn2id(pool, a + 1, s - (a + 1), 0);
 320       if (pool_isknownarch(pool, archid))
 321         {
 322           id = pool_strn2id(pool, n, a - n, 1);
 323           id = pool_rel2id(pool, id, archid, REL_ARCH, 1);
 324         }
 325       else
 326         id = pool_strn2id(pool, n, s - n, 1);
 327     }
 328   else
 329     id = pool_strn2id(pool, n, s - n, 1);
 330   if (!*s)
 331     return id;
 332   while (*s == ' ' || *s == '\t')
 333     s++;
 334   flags = 0;
 335   if (*s == '!' && s[1] == '=') /* support != as synonym for <> */
 336     {
 337       flags = REL_LT | REL_GT;
 338       s += 2;
 339     }
 340   for (;;s++)
 341     {
 342       if (*s == '<')
 343         flags |= REL_LT;
 344       else if (*s == '=')
 345         flags |= REL_EQ;
 346       else if (*s == '>')
 347         flags |= REL_GT;
 348       else
 349         break;
 350     }
 351   if (!flags)
 352     return id;
 353   while (*s == ' ' || *s == '\t')
 354     s++;
 355   n = s;
 356   while (*s && *s != ' ' && *s != '\t')
 357     s++;
 358   return pool_rel2id(pool, id, pool_strn2id(pool, n, s - n, 1), flags, 1);
 359 }
 360
 361 const char *
 362 testcase_repoid2str(Pool *pool, Id repoid)
 363 {
 364   Repo *repo = pool_id2repo(pool, repoid);
 365   if (repo->name)
 366     {
 367       char *r = pool_tmpjoin(pool, repo->name, 0, 0);
 368       char *rp;
 369       for (rp = r; *rp; rp++)
 370         if (*rp == ' ' || *rp == '\t')
 371           *rp = '_';
 372       return r;
 373     }
 374   else
 375     {
 376       char buf[20];
 377       sprintf(buf, "#%d", repoid);
 378       return pool_tmpjoin(pool, buf, 0, 0);
 379     }
 380 }
 381
 382 const char *
 383 testcase_solvid2str(Pool *pool, Id p)
 384 {
 385   Solvable *s = pool->solvables + p;
 386   const char *n, *e, *a;
 387   char *str, buf[20];
 388
 389   if (p == SYSTEMSOLVABLE)
 390     return "@SYSTEM";
 391   n = pool_id2str(pool, s->name);
 392   e = pool_id2str(pool, s->evr);
 393   a = pool_id2str(pool, s->arch);
 394   str = pool_alloctmpspace(pool, strlen(n) + strlen(e) + strlen(a) + 3);
 395   sprintf(str, "%s-%s.%s", n, e, a);
 396   if (!s->repo)
 397     return pool_tmpappend(pool, str, "@", 0);
 398   if (s->repo->name)
 399     {
 400       int l = strlen(str);
 401       char *str2 = pool_tmpappend(pool, str, "@", s->repo->name);
 402       for (; str2[l]; l++)
 403         if (str2[l] == ' ' || str2[l] == '\t')
 404           str2[l] = '_';
 405       return str2;
 406     }
 407   sprintf(buf, "@#%d", s->repo->repoid);
 408   return pool_tmpappend(pool, str, buf, 0);
 409 }
 410
 411 Repo *
 412 testcase_str2repo(Pool *pool, const char *str)
 413 {
 414   int repoid;
 415   Repo *repo = 0;
 416   if (str[0] == '#' && (str[1] >= '0' && str[1] <= '9'))
 417     {
 418       int j;
 419       repoid = 0;
 420       for (j = 1; str[j] >= '0' && str[j] <= '9'; j++)
 421         repoid = repoid * 10 + (str[j] - '0');
 422       if (!str[j] && repoid > 0 && repoid < pool->nrepos)
 423         repo = pool_id2repo(pool, repoid);
 424     }
 425   if (!repo)
 426     {
 427       FOR_REPOS(repoid, repo)
 428         {
 429           int i, l;
 430           if (!repo->name)
 431             continue;
 432           l = strlen(repo->name);
 433           for (i = 0; i < l; i++)
 434             {
 435               int c = repo->name[i];
 436               if (c == ' ' || c == '\t')
 437                 c = '_';
 438               if (c != str[i])
 439                 break;
 440             }
 441           if (i == l && !str[l])
 442             break;
 443         }
 444       if (repoid >= pool->nrepos)
 445         repo = 0;
 446     }
 447   return repo;
 448 }
 449
 450 Id
 451 testcase_str2solvid(Pool *pool, const char *str)
 452 {
 453   int i, l = strlen(str);
 454   int repostart;
 455   Repo *repo;
 456   Id arch;
 457
 458   if (!l)
 459     return 0;
 460   if (*str == '@' && !strcmp(str, "@SYSTEM"))
 461     return SYSTEMSOLVABLE;
 462   repo = 0;
 463   for (i = l - 1; i >= 0; i--)
 464     if (str[i] == '@' && (repo = testcase_str2repo(pool, str + i + 1)) != 0)
 465       break;
 466   if (i < 0)
 467     i = l;
 468   repostart = i;
 469   /* now find the arch (if present) */
 470   arch = 0;
 471   for (i = repostart - 1; i > 0; i--)
 472     if (str[i] == '.')
 473       {
 474         arch = pool_strn2id(pool, str + i + 1, repostart - (i + 1), 0);
 475         if (arch)
 476           repostart = i;
 477         break;
 478       }
 479   /* now find the name */
 480   for (i = repostart - 1; i > 0; i--)
 481     {
 482       if (str[i] == '-')
 483         {
 484           Id nid, evrid, p, pp;
 485           nid = pool_strn2id(pool, str, i, 0);
 486           if (!nid)
 487             continue;
 488           evrid = pool_strn2id(pool, str + i + 1, repostart - (i + 1), 0);
 489           if (!evrid)
 490             continue;
 491           FOR_PROVIDES(p, pp, nid)
 492             {
 493               Solvable *s = pool->solvables + p;
 494               if (s->name != nid || s->evr != evrid)
 495                 continue;
 496               if (repo && s->repo != repo)
 497                 continue;
 498               if (arch && s->arch != arch)
 499                 continue;
 500               return p;
 501             }
 502         }
 503     }
 504   return 0;
 505 }
 506
 507 const char *
 508 testcase_job2str(Pool *pool, Id how, Id what)
 509 {
 510   char *ret;
 511   const char *jobstr;
 512   const char *selstr;
 513   const char *pkgstr;
 514   int i, o;
 515   Id select = how & SOLVER_SELECTMASK;
 516
 517   for (i = 0; job2str[i].str; i++)
 518     if ((how & SOLVER_JOBMASK) == job2str[i].job)
 519       break;
 520   jobstr = job2str[i].str ? job2str[i].str : "unknown";
 521   if (select == SOLVER_SOLVABLE)
 522     {
 523       selstr = " pkg ";
 524       pkgstr = testcase_solvid2str(pool, what);
 525     }
 526   else if (select == SOLVER_SOLVABLE_NAME)
 527     {
 528       selstr = " name ";
 529       pkgstr = pool_dep2str(pool, what);
 530     }
 531   else if (select == SOLVER_SOLVABLE_PROVIDES)
 532     {
 533       selstr = " provides ";
 534       pkgstr = pool_dep2str(pool, what);
 535     }
 536   else if (select == SOLVER_SOLVABLE_ONE_OF)
 537     {
 538       Id p;
 539       selstr = " oneof ";
 540       pkgstr = 0;
 541       while ((p = pool->whatprovidesdata[what++]) != 0)
 542         {
 543           const char *s = testcase_solvid2str(pool, p);
 544           if (pkgstr)
 545             {
 546               pkgstr = pool_tmpappend(pool, pkgstr, " ", s);
 547               pool_freetmpspace(pool, s);
 548             }
 549           else
 550             pkgstr = s;
 551         }
 552       if (!pkgstr)
 553         pkgstr = "nothing";
 554     }
 555   else if (select == SOLVER_SOLVABLE_REPO)
 556     {
 557       Repo *repo = pool_id2repo(pool, what);
 558       selstr = " repo ";
 559       if (!repo->name)
 560         {
 561           char buf[20];
 562           sprintf(buf, "#%d", repo->repoid);
 563           pkgstr = pool_tmpjoin(pool, buf, 0, 0);
 564         }
 565       else
 566         pkgstr = pool_tmpjoin(pool, repo->name, 0, 0);
 567     }
 568   else if (select == SOLVER_SOLVABLE_ALL)
 569     {
 570       selstr = " all ";
 571       pkgstr = "packages";
 572     }
 573   else
 574     {
 575       selstr = " unknown ";
 576       pkgstr = "unknown";
 577     }
 578   ret = pool_tmpjoin(pool, jobstr, selstr, pkgstr);
 579   o = strlen(ret);
 580   ret = pool_tmpappend(pool, ret, " ", 0);
 581   for (i = 0; jobflags2str[i].str; i++)
 582     if ((how & jobflags2str[i].flag) != 0)
 583       ret = pool_tmpappend(pool, ret, ",", jobflags2str[i].str);
 584   if (!ret[o + 1])
 585     ret[o] = 0;
 586   else
 587     {
 588       ret[o + 1] = '[';
 589       ret = pool_tmpappend(pool, ret, "]", 0);
 590     }
 591   return ret;
 592 }
 593
 594 static int
 595 str2selflags(Pool *pool, char *s)       /* modifies the string! */
 596 {
 597   int i, selflags = 0;
 598   while (s)
 599     {
 600       char *se = strchr(s, ',');
 601       if (se)
 602         *se++ = 0;
 603       for (i = 0; selflags2str[i].str; i++)
 604         if (!strcmp(s, selflags2str[i].str))
 605           {
 606             selflags |= selflags2str[i].flag;
 607             break;
 608           }
 609       if (!selflags2str[i].str)
 610         pool_debug(pool, SOLV_ERROR, "str2job: unknown selection flag '%s'\n", s);
 611       s = se;
 612     }
 613   return selflags;
 614 }
 615
 616 static int
 617 str2jobflags(Pool *pool, char *s)       /* modifies the string */
 618 {
 619   int i, jobflags = 0;
 620   while (s)
 621     {
 622       char *se = strchr(s, ',');
 623       if (se)
 624         *se++ = 0;
 625       for (i = 0; jobflags2str[i].str; i++)
 626         if (!strcmp(s, jobflags2str[i].str))
 627           {
 628             jobflags |= jobflags2str[i].flag;
 629             break;
 630           }
 631       if (!jobflags2str[i].str)
 632         pool_debug(pool, SOLV_ERROR, "str2job: unknown job flag '%s'\n", s);
 633       s = se;
 634     }
 635   return jobflags;
 636 }
 637
 638 Id
 639 testcase_str2job(Pool *pool, const char *str, Id *whatp)
 640 {
 641   int i;
 642   Id job;
 643   Id what;
 644   char *s;
 645   char **pieces = 0;
 646   int npieces = 0;
 647
 648   *whatp = 0;
 649   /* so we can patch it */
 650   s = pool_tmpjoin(pool, str, 0, 0);
 651   /* split it in pieces */
 652   for (;;)
 653     {
 654       while (*s == ' ' || *s == '\t')
 655         s++;
 656       if (!*s)
 657         break;
 658       pieces = solv_extend(pieces, npieces, 1, sizeof(*pieces), 7);
 659       pieces[npieces++] = s;
 660       while (*s && *s != ' ' && *s != '\t')
 661         s++;
 662       if (*s)
 663         *s++ = 0;
 664     }
 665   if (npieces < 3)
 666     {
 667       pool_debug(pool, SOLV_ERROR, "str2job: bad line '%s'\n", str);
 668       solv_free(pieces);
 669       return -1;
 670     }
 671
 672   for (i = 0; job2str[i].str; i++)
 673     if (!strcmp(pieces[0], job2str[i].str))
 674       break;
 675   if (!job2str[i].str)
 676     {
 677       pool_debug(pool, SOLV_ERROR, "str2job: unknown job '%s'\n", str);
 678       solv_free(pieces);
 679       return -1;
 680     }
 681   job = job2str[i].job;
 682   what = 0;
 683   if (npieces > 3)
 684     {
 685       char *flags = pieces[npieces - 1];
 686       if (*flags == '[' && flags[strlen(flags) - 1] == ']')
 687         {
 688           npieces--;
 689           flags++;
 690           flags[strlen(flags) - 1] = 0;
 691           job |= str2jobflags(pool, flags);
 692         }
 693     }
 694   if (!strcmp(pieces[1], "pkg"))
 695     {
 696       if (npieces != 3)
 697         {
 698           pool_debug(pool, SOLV_ERROR, "str2job: bad pkg selector in '%s'\n", str);
 699           solv_free(pieces);
 700           return -1;
 701         }
 702       job |= SOLVER_SOLVABLE;
 703       what = testcase_str2solvid(pool, pieces[2]);
 704       if (!what)
 705         {
 706           pool_debug(pool, SOLV_ERROR, "str2job: unknown package '%s'\n", pieces[2]);
 707           solv_free(pieces);
 708           return -1;
 709         }
 710     }
 711   else if (!strcmp(pieces[1], "name") || !strcmp(pieces[1], "provides"))
 712     {
 713       /* join em again for dep2str... */
 714       char *sp;
 715       for (sp = pieces[2]; sp < pieces[npieces - 1]; sp++)
 716         if (*sp == 0)
 717           *sp = ' ';
 718       what = 0;
 719       if (pieces[1][0] == 'p' && strncmp(pieces[2], "namespace:", 10) == 0)
 720         {
 721           char *spe = strchr(pieces[2], '(');
 722           int l = strlen(pieces[2]);
 723           if (spe && pieces[2][l - 1] == ')')
 724             {
 725               /* special namespace provides */
 726               if (strcmp(spe, "(<NULL>)") != 0)
 727                 {
 728                   pieces[2][l - 1] = 0;
 729                   what = testcase_str2dep(pool, spe + 1);
 730                   pieces[2][l - 1] = ')';
 731                 }
 732               what = pool_rel2id(pool, pool_strn2id(pool, pieces[2], spe - pieces[2], 1), what, REL_NAMESPACE, 1);
 733             }
 734         }
 735       if (!what)
 736         what = testcase_str2dep(pool, pieces[2]);
 737       if (pieces[1][0] == 'n')
 738         job |= SOLVER_SOLVABLE_NAME;
 739       else
 740         job |= SOLVER_SOLVABLE_PROVIDES;
 741     }
 742   else if (!strcmp(pieces[1], "oneof"))
 743     {
 744       Queue q;
 745       job |= SOLVER_SOLVABLE_ONE_OF;
 746       queue_init(&q);
 747       if (npieces > 3 && strcmp(pieces[2], "nothing") != 0)
 748         {
 749           for (i = 2; i < npieces; i++)
 750             {
 751               Id p = testcase_str2solvid(pool, pieces[i]);
 752               if (!p)
 753                 {
 754                   pool_debug(pool, SOLV_ERROR, "str2job: unknown package '%s'\n", pieces[i]);
 755                   queue_free(&q);
 756                   solv_free(pieces);
 757                   return -1;
 758                 }
 759               queue_push(&q, p);
 760             }
 761         }
 762       what = pool_queuetowhatprovides(pool, &q);
 763       queue_free(&q);
 764     }
 765   else if (!strcmp(pieces[1], "repo"))
 766     {
 767       Repo *repo;
 768       if (npieces != 3)
 769         {
 770           pool_debug(pool, SOLV_ERROR, "str2job: bad line '%s'\n", str);
 771           solv_free(pieces);
 772           return -1;
 773         }
 774       repo = testcase_str2repo(pool, pieces[2]);
 775       if (!repo)
 776         {
 777           pool_debug(pool, SOLV_ERROR, "str2job: unknown repo '%s'\n", pieces[2]);
 778           solv_free(pieces);
 779           return -1;
 780         }
 781       job |= SOLVER_SOLVABLE_REPO;
 782       what = repo->repoid;
 783     }
 784   else if (!strcmp(pieces[1], "all"))
 785     {
 786       if (npieces != 3 && strcmp(pieces[2], "packages") != 0)
 787         {
 788           pool_debug(pool, SOLV_ERROR, "str2job: bad line '%s'\n", str);
 789           solv_free(pieces);
 790           return -1;
 791         }
 792       job |= SOLVER_SOLVABLE_ALL;
 793       what = 0;
 794     }
 795   else
 796     {
 797       pool_debug(pool, SOLV_ERROR, "str2job: unknown selection in '%s'\n", str);
 798       solv_free(pieces);
 799       return -1;
 800     }
 801   *whatp = what;
 802   solv_free(pieces);
 803   return job;
 804 }
 805
 806 int
 807 addselectionjob(Pool *pool, char **pieces, int npieces, Queue *jobqueue)
 808 {
 809   Id job;
 810   int i, r;
 811   int selflags;
 812   Queue sel;
 813
 814   for (i = 0; job2str[i].str; i++)
 815     if (!strcmp(pieces[0], job2str[i].str))
 816       break;
 817   if (!job2str[i].str)
 818     {
 819       pool_debug(pool, SOLV_ERROR, "selstr2job: unknown job '%s'\n", pieces[0]);
 820       return -1;
 821     }
 822   job = job2str[i].job;
 823   if (npieces > 3)
 824     {
 825       char *flags = pieces[npieces - 1];
 826       if (*flags == '[' && flags[strlen(flags) - 1] == ']')
 827         {
 828           npieces--;
 829           flags++;
 830           flags[strlen(flags) - 1] = 0;
 831           job |= str2jobflags(pool, flags);
 832         }
 833     }
 834   if (npieces < 4)
 835     {
 836       pool_debug(pool, SOLV_ERROR, "selstr2job: no selection flags\n");
 837       return -1;
 838     }
 839   selflags = str2selflags(pool, pieces[3]);
 840   queue_init(&sel);
 841   r = selection_make(pool, &sel, pieces[2], selflags);
 842   for (i = 0; i < sel.count; i += 2)
 843     queue_push2(jobqueue, job | sel.elements[i], sel.elements[i + 1]);
 844   queue_free(&sel);
 845   return r;
 846 }
 847
 848 static void
 849 writedeps(Repo *repo, FILE *fp, const char *tag, Id key, Solvable *s, Offset off)
 850 {
 851   Pool *pool = repo->pool;
 852   Id id, *dp, *prvdp;
 853   int tagwritten = 0;
 854   const char *idstr;
 855
 856   if (!off)
 857     return;
 858   dp = repo->idarraydata + off;
 859   prvdp = 0;
 860   while ((id = *dp++) != 0)
 861     {
 862       if (key == SOLVABLE_REQUIRES && id == SOLVABLE_PREREQMARKER)
 863         {
 864           if (tagwritten)
 865             fprintf(fp, "-%s\n", tag);
 866           tagwritten = 0;
 867           tag = "Prq:";
 868           continue;
 869         }
 870       if (key == SOLVABLE_PROVIDES && id == SOLVABLE_FILEMARKER)
 871         {
 872           prvdp = dp;
 873           continue;
 874         }
 875       idstr = pool_dep2str(pool, id);
 876       if (ISRELDEP(id))
 877         {
 878           Reldep *rd = GETRELDEP(pool, id);
 879           if (key == SOLVABLE_CONFLICTS && rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_OTHERPROVIDERS)
 880             {
 881               if (!strncmp(idstr, "namespace:", 10))
 882                 idstr += 10;
 883             }
 884           if (key == SOLVABLE_SUPPLEMENTS)
 885             {
 886               if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_FILESYSTEM)
 887                 {
 888                   if (!strncmp(idstr, "namespace:", 10))
 889                     idstr += 10;
 890                 }
 891               else if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_MODALIAS)
 892                 {
 893                   if (!strncmp(idstr, "namespace:", 10))
 894                     idstr += 10;
 895                 }
 896               else if (rd->flags == REL_AND)
 897                 {
 898                   /* either packageand chain or modalias */
 899                   idstr = 0;
 900                   if (ISRELDEP(rd->evr))
 901                     {
 902                       Reldep *mrd = GETRELDEP(pool, rd->evr);
 903                       if (mrd->flags == REL_NAMESPACE && mrd->name == NAMESPACE_MODALIAS)
 904                         {
 905                           idstr = pool_tmpjoin(pool, "modalias(", pool_dep2str(pool, rd->name), ":");
 906                           idstr = pool_tmpappend(pool, idstr, pool_dep2str(pool, mrd->evr), ")");
 907                         }
 908                       else if (mrd->flags >= 8)
 909                         continue;
 910                     }
 911                   if (!idstr)
 912                     {
 913                       /* must be and chain */
 914                       idstr = pool_dep2str(pool, rd->evr);
 915                       for (;;)
 916                         {
 917                           id = rd->name;
 918                           if (!ISRELDEP(id))
 919                             break;
 920                           rd = GETRELDEP(pool, id);
 921                           if (rd->flags != REL_AND)
 922                             break;
 923                           idstr = pool_tmpjoin(pool, pool_dep2str(pool, rd->evr), ":", idstr);
 924                         }
 925                       idstr = pool_tmpjoin(pool, pool_dep2str(pool, id), ":", idstr);
 926                       idstr = pool_tmpjoin(pool, "packageand(", idstr, ")");
 927                     }
 928                 }
 929               else if (rd->flags >= 8)
 930                 continue;
 931             }
 932         }
 933       if (!tagwritten)
 934         {
 935           fprintf(fp, "+%s\n", tag);
 936           tagwritten = 1;
 937         }
 938       fprintf(fp, "%s\n", idstr);
 939     }
 940   if (key == SOLVABLE_PROVIDES)
 941     {
 942       /* add the filelist */
 943       Dataiterator di;
 944       dataiterator_init(&di, pool, repo, s - pool->solvables, SOLVABLE_FILELIST, 0, 0);
 945       while (dataiterator_step(&di))
 946         {
 947           const char *s = repodata_dir2str(di.data, di.kv.id, di.kv.str);
 948           if (prvdp)
 949             {
 950               Id id = pool_str2id(pool, s, 0);
 951               if (id)
 952                 {
 953                   for (dp = prvdp; *dp; dp++)
 954                     if (*dp == id)
 955                       break;
 956                   if (*dp)
 957                     continue;   /* already included */
 958                 }
 959             }
 960           if (!tagwritten)
 961             {
 962               fprintf(fp, "+%s", tag);
 963               tagwritten = 1;
 964             }
 965           fprintf(fp, "%s\n", s);
 966         }
 967     }
 968   if (tagwritten)
 969     fprintf(fp, "-%s\n", tag);
 970 }
 971
 972 int
 973 testcase_write_testtags(Repo *repo, FILE *fp)
 974 {
 975   Pool *pool = repo->pool;
 976   Solvable *s;
 977   Id p;
 978   const char *name;
 979   const char *evr;
 980   const char *arch;
 981   const char *release;
 982   const char *tmp;
 983   unsigned int ti;
 984
 985   fprintf(fp, "=Ver: 2.0\n");
 986   FOR_REPO_SOLVABLES(repo, p, s)
 987     {
 988       name = pool_id2str(pool, s->name);
 989       evr = pool_id2str(pool, s->evr);
 990       arch = pool_id2str(pool, s->arch);
 991       release = strrchr(evr, '-');
 992       if (!release)
 993         release = evr + strlen(evr);
 994       fprintf(fp, "=Pkg: %s %.*s %s %s\n", name, (int)(release - evr), evr, *release && release[1] ? release + 1 : "-", arch);
 995       tmp = solvable_lookup_str(s, SOLVABLE_SUMMARY);
 996       if (tmp)
 997         fprintf(fp, "=Sum: %s\n", tmp);
 998       writedeps(repo, fp, "Req:", SOLVABLE_REQUIRES, s, s->requires);
 999       writedeps(repo, fp, "Prv:", SOLVABLE_PROVIDES, s, s->provides);
1000       writedeps(repo, fp, "Obs:", SOLVABLE_OBSOLETES, s, s->obsoletes);
1001       writedeps(repo, fp, "Con:", SOLVABLE_CONFLICTS, s, s->conflicts);
1002       writedeps(repo, fp, "Rec:", SOLVABLE_RECOMMENDS, s, s->recommends);
1003       writedeps(repo, fp, "Sup:", SOLVABLE_SUPPLEMENTS, s, s->supplements);
1004       writedeps(repo, fp, "Sug:", SOLVABLE_SUGGESTS, s, s->suggests);
1005       writedeps(repo, fp, "Enh:", SOLVABLE_ENHANCES, s, s->enhances);
1006       if (s->vendor)
1007         fprintf(fp, "=Vnd: %s\n", pool_id2str(pool, s->vendor));
1008       ti = solvable_lookup_num(s, SOLVABLE_BUILDTIME, 0);
1009       if (ti)
1010         fprintf(fp, "=Tim: %u\n", ti);
1011     }
1012   return 0;
1013 }
1014
1015 static inline Offset
1016 adddep(Repo *repo, Offset olddeps, char *str, Id marker)
1017 {
1018   Id id = *str == '/' ? pool_str2id(repo->pool, str, 1) : testcase_str2dep(repo->pool, str);
1019   return repo_addid_dep(repo, olddeps, id, marker);
1020 }
1021
1022 static void
1023 finish_solvable(Pool *pool, Repodata *data, Solvable *s, char *filelist, int nfilelist)
1024 {
1025   if (nfilelist)
1026     {
1027       int l;
1028       Id did;
1029       for (l = 0; l < nfilelist; l += strlen(filelist + l) + 1)
1030         {
1031           char *p = strrchr(filelist + l, '/');
1032           if (!p)
1033             continue;
1034           *p++ = 0;
1035           did = repodata_str2dir(data, filelist + l, 1);
1036           p[-1] = '/';
1037           if (!did)
1038             did = repodata_str2dir(data, "/", 1);
1039           repodata_add_dirstr(data, s - pool->solvables, SOLVABLE_FILELIST, did, p);
1040         }
1041     }
1042   if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
1043     s->provides = repo_addid_dep(s->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
1044   s->supplements = repo_fix_supplements(s->repo, s->provides, s->supplements, 0);
1045   s->conflicts = repo_fix_conflicts(s->repo, s->conflicts);
1046 }
1047
1048 /* stripped down version of susetags parser used for testcases */
1049 int
1050 testcase_add_testtags(Repo *repo, FILE *fp, int flags)
1051 {
1052   Pool *pool = repo->pool;
1053   char *line, *linep;
1054   int aline;
1055   int tag;
1056   Repodata *data;
1057   Solvable *s;
1058   char *sp[5];
1059   unsigned int t;
1060   int intag;
1061   char *filelist = 0;
1062   int afilelist = 0;
1063   int nfilelist = 0;
1064
1065   data = repo_add_repodata(repo, flags);
1066   s = 0;
1067   intag = 0;
1068
1069   aline = 1024;
1070   line = solv_malloc(aline);
1071   linep = line;
1072   for (;;)
1073     {
1074       if (linep - line + 16 > aline)
1075         {
1076           aline = linep - line;
1077           line = solv_realloc(line, aline + 512);
1078           linep = line + aline;
1079           aline += 512;
1080         }
1081       if (!fgets(linep, aline - (linep - line), fp))
1082         break;
1083       linep += strlen(linep);
1084       if (linep == line || linep[-1] != '\n')
1085         continue;
1086       *--linep = 0;
1087       linep = line + intag;
1088       if (intag)
1089         {
1090           if (line[intag] == '-' && !strncmp(line + 1, line + intag + 1, intag - 2))
1091             {
1092               intag = 0;
1093               linep = line;
1094               continue;
1095             }
1096         }
1097       else if (line[0] == '+' && line[1] && line[1] != ':')
1098         {
1099           char *tagend = strchr(line, ':');
1100           if (!tagend)
1101             continue;
1102           line[0] = '=';
1103           tagend[1] = ' ';
1104           intag = tagend + 2 - line;
1105           linep = line + intag;
1106           continue;
1107         }
1108       if (*line != '=' || !line[1] || !line[2] || !line[3] || line[4] != ':')
1109         continue;
1110       tag = line[1] << 16 | line[2] << 8 | line[3];
1111       switch(tag)
1112         {
1113         case 'P' << 16 | 'k' << 8 | 'g':
1114           if (s)
1115             finish_solvable(pool, data, s, filelist, nfilelist);
1116           nfilelist = 0;
1117           if (split(line + 5, sp, 5) != 4)
1118             break;
1119           s = pool_id2solvable(pool, repo_add_solvable(repo));
1120           s->name = pool_str2id(pool, sp[0], 1);
1121           /* join back version and release */
1122           if (sp[2] && !(sp[2][0] == '-' && !sp[2][1]))
1123             sp[2][-1] = '-';
1124           s->evr = makeevr(pool, sp[1]);
1125           s->arch = pool_str2id(pool, sp[3], 1);
1126           break;
1127         case 'S' << 16 | 'u' << 8 | 'm':
1128           repodata_set_str(data, s - pool->solvables, SOLVABLE_SUMMARY, line + 6);
1129           break;
1130         case 'V' << 16 | 'n' << 8 | 'd':
1131           s->vendor = pool_str2id(pool, line + 6, 1);
1132           break;
1133         case 'T' << 16 | 'i' << 8 | 'm':
1134           t = atoi(line + 6);
1135           if (t)
1136             repodata_set_num(data, s - pool->solvables, SOLVABLE_BUILDTIME, t);
1137           break;
1138         case 'R' << 16 | 'e' << 8 | 'q':
1139           s->requires = adddep(repo, s->requires, line + 6, -SOLVABLE_PREREQMARKER);
1140           break;
1141         case 'P' << 16 | 'r' << 8 | 'q':
1142           s->requires = adddep(repo, s->requires, line + 6, SOLVABLE_PREREQMARKER);
1143           break;
1144         case 'P' << 16 | 'r' << 8 | 'v':
1145           if (line[6] == '/')
1146             {
1147               int l = strlen(line + 6) + 1;
1148               if (nfilelist + l > afilelist)
1149                 {
1150                   afilelist = nfilelist + l + 512;
1151                   filelist = solv_realloc(filelist, afilelist);
1152                 }
1153               memcpy(filelist + nfilelist, line + 6, l);
1154               nfilelist += l;
1155               break;
1156             }
1157           if (nfilelist)
1158             {
1159               int l;
1160               for (l = 0; l < nfilelist; l += strlen(filelist + l) + 1)
1161                 s->provides = repo_addid_dep(repo, s->provides, pool_str2id(pool, filelist + l, 1), 0);
1162               nfilelist = 0;
1163             }
1164           s->provides = adddep(repo, s->provides, line + 6, 0);
1165           break;
1166         case 'O' << 16 | 'b' << 8 | 's':
1167           s->obsoletes = adddep(repo, s->obsoletes, line + 6, 0);
1168           break;
1169         case 'C' << 16 | 'o' << 8 | 'n':
1170           s->conflicts = adddep(repo, s->conflicts, line + 6, 0);
1171           break;
1172         case 'R' << 16 | 'e' << 8 | 'c':
1173           s->recommends = adddep(repo, s->recommends, line + 6, 0);
1174           break;
1175         case 'S' << 16 | 'u' << 8 | 'p':
1176           s->supplements = adddep(repo, s->supplements, line + 6, 0);
1177           break;
1178         case 'S' << 16 | 'u' << 8 | 'g':
1179           s->suggests = adddep(repo, s->suggests, line + 6, 0);
1180           break;
1181         case 'E' << 16 | 'n' << 8 | 'h':
1182           s->enhances = adddep(repo, s->enhances, line + 6, 0);
1183           break;
1184         default:
1185           break;
1186         }
1187     }
1188   if (s)
1189     finish_solvable(pool, data, s, filelist, nfilelist);
1190   solv_free(line);
1191   solv_free(filelist);
1192   repodata_free_dircache(data);
1193   if (!(flags & REPO_NO_INTERNALIZE))
1194     repodata_internalize(data);
1195   return 0;
1196 }
1197
1198 const char *
1199 testcase_getpoolflags(Pool *pool)
1200 {
1201   const char *str = 0;
1202   int i, v;
1203   for (i = 0; poolflags2str[i].str; i++)
1204     {
1205       v = pool_get_flag(pool, poolflags2str[i].flag);
1206       if (v == poolflags2str[i].def)
1207         continue;
1208       str = pool_tmpappend(pool, str, v ? " " : " !", poolflags2str[i].str);
1209     }
1210   return str ? str + 1 : "";
1211 }
1212
1213 int
1214 testcase_setpoolflags(Pool *pool, const char *str)
1215 {
1216   const char *p = str, *s;
1217   int i, v;
1218   for (;;)
1219     {
1220       while (*p == ' ' || *p == '\t' || *p == ',')
1221         p++;
1222       v = 1;
1223       if (*p == '!')
1224         {
1225           p++;
1226           v = 0;
1227         }
1228       if (!*p)
1229         break;
1230       s = p;
1231       while (*p && *p != ' ' && *p != '\t' && *p != ',')
1232         p++;
1233       for (i = 0; poolflags2str[i].str; i++)
1234         if (!strncmp(poolflags2str[i].str, s, p - s) && poolflags2str[i].str[p - s] == 0)
1235           break;
1236       if (!poolflags2str[i].str)
1237         {
1238           pool_debug(pool, SOLV_ERROR, "setpoolflags: unknown flag '%.*s'\n", (int)(p - s), s);
1239           return 0;
1240         }
1241       pool_set_flag(pool, poolflags2str[i].flag, v);
1242     }
1243   return 1;
1244 }
1245
1246 void
1247 testcase_resetpoolflags(Pool *pool)
1248 {
1249   int i;
1250   for (i = 0; poolflags2str[i].str; i++)
1251     pool_set_flag(pool, poolflags2str[i].flag, poolflags2str[i].def);
1252 }
1253
1254 const char *
1255 testcase_getsolverflags(Solver *solv)
1256 {
1257   Pool *pool = solv->pool;
1258   const char *str = 0;
1259   int i, v;
1260   for (i = 0; solverflags2str[i].str; i++)
1261     {
1262       v = solver_get_flag(solv, solverflags2str[i].flag);
1263       if (v == solverflags2str[i].def)
1264         continue;
1265       str = pool_tmpappend(pool, str, v ? " " : " !", solverflags2str[i].str);
1266     }
1267   return str ? str + 1 : "";
1268 }
1269
1270 int
1271 testcase_setsolverflags(Solver *solv, const char *str)
1272 {
1273   const char *p = str, *s;
1274   int i, v;
1275   for (;;)
1276     {
1277       while (*p == ' ' || *p == '\t' || *p == ',')
1278         p++;
1279       v = 1;
1280       if (*p == '!')
1281         {
1282           p++;
1283           v = 0;
1284         }
1285       if (!*p)
1286         break;
1287       s = p;
1288       while (*p && *p != ' ' && *p != '\t' && *p != ',')
1289         p++;
1290       for (i = 0; solverflags2str[i].str; i++)
1291         if (!strncmp(solverflags2str[i].str, s, p - s) && solverflags2str[i].str[p - s] == 0)
1292           break;
1293       if (!solverflags2str[i].str)
1294         {
1295           pool_debug(solv->pool, SOLV_ERROR, "setsolverflags: unknown flag '%.*s'\n", (int)(p - s), s);
1296           return 0;
1297         }
1298       solver_set_flag(solv, solverflags2str[i].flag, v);
1299     }
1300   return 1;
1301 }
1302
1303 void
1304 testcase_resetsolverflags(Solver *solv)
1305 {
1306   int i;
1307   for (i = 0; solverflags2str[i].str; i++)
1308     solver_set_flag(solv, solverflags2str[i].flag, solverflags2str[i].def);
1309 }
1310
1311 static const char *
1312 testcase_ruleid(Solver *solv, Id rid)
1313 {
1314   Strqueue sq;
1315   Queue q;
1316   int i;
1317   void *chk;
1318   const unsigned char *md5;
1319   int md5l;
1320   const char *s;
1321
1322   queue_init(&q);
1323   strqueue_init(&sq);
1324   solver_ruleliterals(solv, rid, &q);
1325   for (i = 0; i < q.count; i++)
1326     {
1327       Id p = q.elements[i];
1328       s = testcase_solvid2str(solv->pool, p > 0 ? p : -p);
1329       if (p < 0)
1330         s = pool_tmpjoin(solv->pool, "!", s, 0);
1331       strqueue_push(&sq, s);
1332     }
1333   queue_free(&q);
1334   strqueue_sort_u(&sq);
1335   chk = solv_chksum_create(REPOKEY_TYPE_MD5);
1336   for (i = 0; i < sq.nstr; i++)
1337     solv_chksum_add(chk, sq.str[i], strlen(sq.str[i]) + 1);
1338   md5 = solv_chksum_get(chk, &md5l);
1339   s = pool_bin2hex(solv->pool, md5, md5l);
1340   chk = solv_chksum_free(chk, 0);
1341   strqueue_free(&sq);
1342   return s;
1343 }
1344
1345 static const char *
1346 testcase_problemid(Solver *solv, Id problem)
1347 {
1348   Strqueue sq;
1349   Queue q;
1350   void *chk;
1351   const unsigned char *md5;
1352   int i, md5l;
1353   const char *s;
1354
1355   /* we build a hash of all rules that define the problem */
1356   queue_init(&q);
1357   strqueue_init(&sq);
1358   solver_findallproblemrules(solv, problem, &q);
1359   for (i = 0; i < q.count; i++)
1360     strqueue_push(&sq, testcase_ruleid(solv, q.elements[i]));
1361   queue_free(&q);
1362   strqueue_sort_u(&sq);
1363   chk = solv_chksum_create(REPOKEY_TYPE_MD5);
1364   for (i = 0; i < sq.nstr; i++)
1365     solv_chksum_add(chk, sq.str[i], strlen(sq.str[i]) + 1);
1366   md5 = solv_chksum_get(chk, &md5l);
1367   s = pool_bin2hex(solv->pool, md5, 4);
1368   chk = solv_chksum_free(chk, 0);
1369   strqueue_free(&sq);
1370   return s;
1371 }
1372
1373 static const char *
1374 testcase_solutionid(Solver *solv, Id problem, Id solution)
1375 {
1376   Id intid;
1377   void *chk;
1378   const unsigned char *md5;
1379   int md5l;
1380   const char *s;
1381
1382   intid = solver_solutionelement_internalid(solv, problem, solution);
1383   /* internal stuff! handle with care! */
1384   if (intid < 0)
1385     {
1386       /* it's a job */
1387       s = testcase_job2str(solv->pool, solv->job.elements[-intid - 1], solv->job.elements[-intid]);
1388     }
1389   else
1390     {
1391       /* it's a rule */
1392       s = testcase_ruleid(solv, intid);
1393     }
1394   chk = solv_chksum_create(REPOKEY_TYPE_MD5);
1395   solv_chksum_add(chk, s, strlen(s) + 1);
1396   md5 = solv_chksum_get(chk, &md5l);
1397   s = pool_bin2hex(solv->pool, md5, 4);
1398   chk = solv_chksum_free(chk, 0);
1399   return s;
1400 }
1401
1402 static struct class2str {
1403   Id class;
1404   const char *str;
1405 } class2str[] = {
1406   { SOLVER_TRANSACTION_ERASE,          "erase" },
1407   { SOLVER_TRANSACTION_INSTALL,        "install" },
1408   { SOLVER_TRANSACTION_REINSTALLED,    "reinstall" },
1409   { SOLVER_TRANSACTION_DOWNGRADED,     "downgrade" },
1410   { SOLVER_TRANSACTION_CHANGED,        "change" },
1411   { SOLVER_TRANSACTION_UPGRADED,       "upgrade" },
1412   { SOLVER_TRANSACTION_OBSOLETED,      "obsolete" },
1413   { SOLVER_TRANSACTION_MULTIINSTALL,   "multiinstall" },
1414   { SOLVER_TRANSACTION_MULTIREINSTALL, "multireinstall" },
1415   { 0, 0 }
1416 };
1417
1418 char *
1419 testcase_solverresult(Solver *solv, int resultflags)
1420 {
1421   Pool *pool = solv->pool;
1422   int i, j;
1423   Id p, op;
1424   const char *s;
1425   char *result;
1426   Strqueue sq;
1427
1428   strqueue_init(&sq);
1429   if ((resultflags & TESTCASE_RESULT_TRANSACTION) != 0)
1430     {
1431       Transaction *trans = solver_create_transaction(solv);
1432       Queue q;
1433
1434       queue_init(&q);
1435       for (i = 0; class2str[i].str; i++)
1436         {
1437           queue_empty(&q);
1438           transaction_classify_pkgs(trans, SOLVER_TRANSACTION_KEEP_PSEUDO, class2str[i].class, 0, 0, &q);
1439           for (j = 0; j < q.count; j++)
1440             {
1441               p = q.elements[j];
1442               op = 0;
1443               if (pool->installed && pool->solvables[p].repo == pool->installed)
1444                 op = transaction_obs_pkg(trans, p);
1445               s = pool_tmpjoin(pool, class2str[i].str, " ", testcase_solvid2str(pool, p));
1446               if (op)
1447                 s = pool_tmpjoin(pool, s, " ", testcase_solvid2str(pool, op));
1448               strqueue_push(&sq, s);
1449             }
1450         }
1451       queue_free(&q);
1452       transaction_free(trans);
1453     }
1454   if ((resultflags & TESTCASE_RESULT_PROBLEMS) != 0)
1455     {
1456       char *probprefix, *solprefix;
1457       int problem, solution, element;
1458       int pcnt, scnt;
1459
1460       pcnt = solver_problem_count(solv);
1461       for (problem = 1; problem <= pcnt; problem++)
1462         {
1463           Id rid, from, to, dep;
1464           SolverRuleinfo rinfo;
1465           rid = solver_findproblemrule(solv, problem);
1466           s = testcase_problemid(solv, problem);
1467           probprefix = solv_dupjoin("problem ", s, 0);
1468           rinfo = solver_ruleinfo(solv, rid, &from, &to, &dep);
1469           s = pool_tmpjoin(pool, probprefix, " info ", solver_problemruleinfo2str(solv, rinfo, from, to, dep));
1470           strqueue_push(&sq, s);
1471           scnt = solver_solution_count(solv, problem);
1472           for (solution = 1; solution <= scnt; solution++)
1473             {
1474               s = testcase_solutionid(solv, problem, solution);
1475               solprefix = solv_dupjoin(probprefix, " solution ", s);
1476               element = 0;
1477               while ((element = solver_next_solutionelement(solv, problem, solution, element, &p, &op)) != 0)
1478                 {
1479                   if (p == SOLVER_SOLUTION_JOB)
1480                     s = pool_tmpjoin(pool, solprefix, " deljob ", testcase_job2str(pool, solv->job.elements[op - 1], solv->job.elements[op]));
1481                   else if (p > 0 && op == 0)
1482                     s = pool_tmpjoin(pool, solprefix, " erase ", testcase_solvid2str(pool, p));
1483                   else if (p > 0 && op > 0)
1484                     {
1485                       s = pool_tmpjoin(pool, solprefix, " replace ", testcase_solvid2str(pool, p));
1486                       s = pool_tmpappend(pool, s, " ", testcase_solvid2str(pool, op));
1487                     }
1488                   else if (p < 0 && op > 0)
1489                     s = pool_tmpjoin(pool, solprefix, " allow ", testcase_solvid2str(pool, op));
1490                   else
1491                     s = pool_tmpjoin(pool, solprefix, " unknown", 0);
1492                   strqueue_push(&sq, s);
1493                 }
1494               solv_free(solprefix);
1495             }
1496           solv_free(probprefix);
1497         }
1498     }
1499
1500   if ((resultflags & TESTCASE_RESULT_ORPHANED) != 0)
1501     {
1502       Queue q;
1503
1504       queue_init(&q);
1505       solver_get_orphaned(solv, &q);
1506       for (i = 0; i < q.count; i++)
1507         {
1508           s = pool_tmpjoin(pool, "orphaned ", testcase_solvid2str(pool, q.elements[i]), 0);
1509           strqueue_push(&sq, s);
1510         }
1511       queue_free(&q);
1512     }
1513
1514   if ((resultflags & TESTCASE_RESULT_RECOMMENDED) != 0)
1515     {
1516       Queue qr, qs;
1517
1518       queue_init(&qr);
1519       queue_init(&qs);
1520       solver_get_recommendations(solv, &qr, &qs, 0);
1521       for (i = 0; i < qr.count; i++)
1522         {
1523           s = pool_tmpjoin(pool, "recommended ", testcase_solvid2str(pool, qr.elements[i]), 0);
1524           strqueue_push(&sq, s);
1525         }
1526       for (i = 0; i < qs.count; i++)
1527         {
1528           s = pool_tmpjoin(pool, "suggested ", testcase_solvid2str(pool, qs.elements[i]), 0);
1529           strqueue_push(&sq, s);
1530         }
1531       queue_free(&qr);
1532       queue_free(&qs);
1533     }
1534
1535   if ((resultflags & TESTCASE_RESULT_UNNEEDED) != 0)
1536     {
1537       Queue q;
1538
1539       queue_init(&q);
1540       solver_get_unneeded(solv, &q, 0);
1541       for (i = 0; i < q.count; i++)
1542         {
1543           s = pool_tmpjoin(pool, "unneeded ", testcase_solvid2str(pool, q.elements[i]), 0);
1544           strqueue_push(&sq, s);
1545         }
1546       queue_free(&q);
1547     }
1548
1549   strqueue_sort(&sq);
1550   result = strqueue_join(&sq);
1551   strqueue_free(&sq);
1552   return result;
1553 }
1554
1555
1556 int
1557 testcase_write(Solver *solv, char *dir, int resultflags, const char *testcasename, const char *resultname)
1558 {
1559   Pool *pool = solv->pool;
1560   Repo *repo;
1561   int i;
1562   Id arch, repoid;
1563   Id lowscore;
1564   FILE *fp;
1565   Strqueue sq;
1566   char *cmd, *out;
1567   const char *s;
1568
1569   if (!testcasename)
1570     testcasename = "testcase.t";
1571   if (!resultname)
1572     resultname = "solver.result";
1573
1574   if (mkdir(dir, 0777) && errno != EEXIST)
1575     {
1576       pool_debug(solv->pool, SOLV_ERROR, "testcase_write: could not create directory '%s'\n", dir);
1577       return 0;
1578     }
1579   strqueue_init(&sq);
1580   FOR_REPOS(repoid, repo)
1581     {
1582       const char *name = testcase_repoid2str(pool, repoid);
1583       char priobuf[50];
1584       if (repo->subpriority)
1585         sprintf(priobuf, "%d.%d", repo->priority, repo->subpriority);
1586       else
1587         sprintf(priobuf, "%d", repo->priority);
1588       out = pool_tmpjoin(pool, name, ".repo", ".gz");
1589       cmd = pool_tmpjoin(pool, "repo ", name, " ");
1590       cmd = pool_tmpappend(pool, cmd, priobuf, " ");
1591       cmd = pool_tmpappend(pool, cmd, "testtags ", out);
1592       strqueue_push(&sq, cmd);
1593       out = pool_tmpjoin(pool, dir, "/", out);
1594       if (!(fp = solv_xfopen(out, "w")))
1595         {
1596           pool_debug(solv->pool, SOLV_ERROR, "testcase_write: could not open '%s' for writing\n", out);
1597           strqueue_free(&sq);
1598           return 0;
1599         }
1600       testcase_write_testtags(repo, fp);
1601       if (fclose(fp))
1602         {
1603           pool_debug(solv->pool, SOLV_ERROR, "testcase_write: write error\n");
1604           strqueue_free(&sq);
1605           return 0;
1606         }
1607     }
1608   /* hmm, this is not optimal... we currently search for the lowest score */
1609   lowscore = 0;
1610   arch = pool->solvables[SYSTEMSOLVABLE].arch;
1611   for (i = 0; i < pool->lastarch; i++)
1612     {
1613       if (pool->id2arch[i] == 1 && !lowscore)
1614         arch = i;
1615       if (pool->id2arch[i] > 0x10000 && (!lowscore || pool->id2arch[i] < lowscore))
1616         {
1617           arch = i;
1618           lowscore = pool->id2arch[i];
1619         }
1620     }
1621   cmd = pool_tmpjoin(pool, "system ", pool->lastarch ? pool_id2str(pool, arch) : "unset", 0);
1622   for (i = 0; disttype2str[i].str != 0; i++)
1623     if (pool->disttype == disttype2str[i].type)
1624       break;
1625   pool_tmpappend(pool, cmd, " ", disttype2str[i].str ? disttype2str[i].str : "unknown");
1626   if (pool->installed)
1627     cmd = pool_tmpappend(pool, cmd, " ", testcase_repoid2str(pool, pool->installed->repoid));
1628   strqueue_push(&sq, cmd);
1629   s = testcase_getpoolflags(solv->pool);
1630   if (*s)
1631     {
1632       cmd = pool_tmpjoin(pool, "poolflags ", s, 0);
1633       strqueue_push(&sq, cmd);
1634     }
1635
1636   if (pool->vendorclasses)
1637     {
1638       cmd = 0;
1639       for (i = 0; pool->vendorclasses[i]; i++)
1640         {
1641           cmd = pool_tmpappend(pool, cmd ? cmd : "vendorclass", " ", pool->vendorclasses[i]);
1642           if (!pool->vendorclasses[i + 1])
1643             {
1644               strqueue_push(&sq, cmd);
1645               cmd = 0;
1646               i++;
1647             }
1648         }
1649     }
1650
1651   s = testcase_getsolverflags(solv);
1652   if (*s)
1653     {
1654       cmd = pool_tmpjoin(pool, "solverflags ", s, 0);
1655       strqueue_push(&sq, cmd);
1656     }
1657
1658   /* now dump all the ns callback values we know */
1659   if (pool->nscallback)
1660     {
1661       Id rid;
1662       int d;
1663       for (rid = 1; rid < pool->nrels; rid++)
1664         {
1665           Reldep *rd = pool->rels + rid;
1666           if (rd->flags != REL_NAMESPACE || rd->name == NAMESPACE_OTHERPROVIDERS)
1667             continue;
1668           /* evaluate all namespace ids, skip empty results */
1669           d = pool_whatprovides(pool, MAKERELDEP(rid));
1670           if (!d || !pool->whatprovidesdata[d])
1671             continue;
1672           cmd = pool_tmpjoin(pool, "namespace ", pool_id2str(pool, rd->name), "(");
1673           cmd = pool_tmpappend(pool, cmd, pool_id2str(pool, rd->evr), ")");
1674           for (;  pool->whatprovidesdata[d]; d++)
1675             cmd = pool_tmpappend(pool, cmd, " ", testcase_solvid2str(pool, pool->whatprovidesdata[d]));
1676           strqueue_push(&sq, cmd);
1677         }
1678     }
1679
1680   for (i = 0; i < solv->job.count; i += 2)
1681     {
1682       cmd = (char *)testcase_job2str(pool, solv->job.elements[i], solv->job.elements[i + 1]);
1683       cmd = pool_tmpjoin(pool, "job ", cmd, 0);
1684       strqueue_push(&sq, cmd);
1685     }
1686
1687   if (resultflags)
1688     {
1689       char *result;
1690       cmd = 0;
1691       for (i = 0; resultflags2str[i].str; i++)
1692         if ((resultflags & resultflags2str[i].flag) != 0)
1693           cmd = pool_tmpappend(pool, cmd, cmd ? "," : 0, resultflags2str[i].str);
1694       cmd = pool_tmpjoin(pool, "result ", cmd ? cmd : "?", 0);
1695       cmd = pool_tmpappend(pool, cmd, " ", resultname);
1696       strqueue_push(&sq, cmd);
1697       result = testcase_solverresult(solv, resultflags);
1698       if (!strcmp(resultname, "<inline>"))
1699         {
1700           int i;
1701           Strqueue rsq;
1702           strqueue_init(&rsq);
1703           strqueue_split(&rsq, result);
1704           for (i = 0; i < rsq.nstr; i++)
1705             {
1706               cmd = pool_tmpjoin(pool, "#>", rsq.str[i], 0);
1707               strqueue_push(&sq, cmd);
1708             }
1709           strqueue_free(&rsq);
1710         }
1711       else
1712         {
1713           out = pool_tmpjoin(pool, dir, "/", resultname);
1714           if (!(fp = fopen(out, "w")))
1715             {
1716               pool_debug(solv->pool, SOLV_ERROR, "testcase_write: could not open '%s' for writing\n", out);
1717               solv_free(result);
1718               strqueue_free(&sq);
1719               return 0;
1720             }
1721           if (result && *result && fwrite(result, strlen(result), 1, fp) != 1)
1722             {
1723               pool_debug(solv->pool, SOLV_ERROR, "testcase_write: write error\n");
1724               solv_free(result);
1725               strqueue_free(&sq);
1726               return 0;
1727             }
1728           if (fclose(fp))
1729             {
1730               pool_debug(solv->pool, SOLV_ERROR, "testcase_write: write error\n");
1731               strqueue_free(&sq);
1732               return 0;
1733             }
1734         }
1735       solv_free(result);
1736     }
1737
1738   cmd = strqueue_join(&sq);
1739   out = pool_tmpjoin(pool, dir, "/", testcasename);
1740   if (!(fp = fopen(out, "w")))
1741     {
1742       pool_debug(solv->pool, SOLV_ERROR, "testcase_write: could not open '%s' for writing\n", out);
1743       strqueue_free(&sq);
1744       return 0;
1745     }
1746   if (*cmd && fwrite(cmd, strlen(cmd), 1, fp) != 1)
1747     {
1748       pool_debug(solv->pool, SOLV_ERROR, "testcase_write: write error\n");
1749       strqueue_free(&sq);
1750       return 0;
1751     }
1752   if (fclose(fp))
1753     {
1754       pool_debug(solv->pool, SOLV_ERROR, "testcase_write: write error\n");
1755       strqueue_free(&sq);
1756       return 0;
1757     }
1758   solv_free(cmd);
1759   strqueue_free(&sq);
1760   return 1;
1761 }
1762
1763 static char *
1764 read_inline_file(FILE *fp, char **bufp, char **bufpp, int *buflp)
1765 {
1766   char *result = solv_malloc(1024);
1767   char *rp = result;
1768   int resultl = 1024;
1769
1770   for (;;)
1771     {
1772       size_t rl;
1773       if (rp - result + 256 >= resultl)
1774         {
1775           resultl = rp - result;
1776           result = solv_realloc(result, resultl + 1024);
1777           rp = result + resultl;
1778           resultl += 1024;
1779         }
1780       if (!fgets(rp, resultl - (rp - result), fp))
1781         *rp = 0;
1782       rl = strlen(rp);
1783       if (rl && (rp == result || rp[-1] == '\n'))
1784         {
1785           if (rl > 1 && rp[0] == '#' && rp[1] == '>')
1786             {
1787               memmove(rp, rp + 2, rl - 2);
1788               rl -= 2;
1789             }
1790           else
1791             {
1792               while (rl + 16 > *buflp)
1793                 {
1794                   *bufp = solv_realloc(*bufp, *buflp + 512);
1795                   *buflp += 512;
1796                 }
1797               memmove(*bufp, rp, rl);
1798               if ((*bufp)[rl - 1] == '\n')
1799                 {
1800                   ungetc('\n', fp);
1801                   rl--;
1802                 }
1803               (*bufp)[rl] = 0;
1804               (*bufpp) = *bufp + rl;
1805               rl = 0;
1806             }
1807         }
1808       if (rl <= 0)
1809         {
1810           *rp = 0;
1811           break;
1812         }
1813       rp += rl;
1814     }
1815   return result;
1816 }
1817
1818 static char *
1819 read_file(FILE *fp)
1820 {
1821   char *result = solv_malloc(1024);
1822   char *rp = result;
1823   int resultl = 1024;
1824
1825   for (;;)
1826     {
1827       size_t rl;
1828       if (rp - result + 256 >= resultl)
1829         {
1830           resultl = rp - result;
1831           result = solv_realloc(result, resultl + 1024);
1832           rp = result + resultl;
1833           resultl += 1024;
1834         }
1835       rl = fread(rp, 1, resultl - (rp - result), fp);
1836       if (rl <= 0)
1837         {
1838           *rp = 0;
1839           break;
1840         }
1841       rp += rl;
1842     }
1843   return result;
1844 }
1845
1846 static int
1847 str2resultflags(Pool *pool, char *s)    /* modifies the string! */
1848 {
1849   int i, resultflags = 0;
1850   while (s)
1851     {
1852       char *se = strchr(s, ',');
1853       if (se)
1854         *se++ = 0;
1855       for (i = 0; resultflags2str[i].str; i++)
1856         if (!strcmp(s, resultflags2str[i].str))
1857           {
1858             resultflags |= resultflags2str[i].flag;
1859             break;
1860           }
1861       if (!resultflags2str[i].str)
1862         pool_debug(pool, SOLV_ERROR, "result: unknown flag '%s'\n", s);
1863       s = se;
1864     }
1865   return resultflags;
1866 }
1867
1868 Solver *
1869 testcase_read(Pool *pool, FILE *fp, char *testcase, Queue *job, char **resultp, int *resultflagsp)
1870 {
1871   Solver *solv;
1872   char *buf, *bufp;
1873   int bufl;
1874   char *testcasedir, *s;
1875   int l;
1876   char **pieces = 0;
1877   int npieces = 0;
1878   int prepared = 0;
1879   int closefp = !fp;
1880   int poolflagsreset = 0;
1881
1882   if (!fp && !(fp = fopen(testcase, "r")))
1883     {
1884       pool_debug(pool, SOLV_ERROR, "testcase_read: could not open '%s'\n", testcase);
1885       return 0;
1886     }
1887   testcasedir = solv_strdup(testcase);
1888   if ((s = strrchr(testcasedir, '/')) != 0)
1889     s[1] = 0;
1890   else
1891     *testcasedir = 0;
1892   bufl = 1024;
1893   buf = solv_malloc(bufl);
1894   bufp = buf;
1895   solv = 0;
1896   for (;;)
1897     {
1898       if (bufp - buf + 16 > bufl)
1899         {
1900           bufl = bufp - buf;
1901           buf = solv_realloc(buf, bufl + 512);
1902           bufp = buf + bufl;
1903           bufl += 512;
1904         }
1905       if (!fgets(bufp, bufl - (bufp - buf), fp))
1906         break;
1907       bufp = buf;
1908       l = strlen(buf);
1909       if (!l || buf[l - 1] != '\n')
1910         {
1911           bufp += l;
1912           continue;
1913         }
1914       buf[--l] = 0;
1915       s = buf;
1916       while (*s && (*s == ' ' || *s == '\t'))
1917         s++;
1918       if (!*s || *s == '#')
1919         continue;
1920       npieces = 0;
1921       /* split it in pieces */
1922       for (;;)
1923         {
1924           while (*s == ' ' || *s == '\t')
1925             s++;
1926           if (!*s)
1927             break;
1928           pieces = solv_extend(pieces, npieces, 1, sizeof(*pieces), 7);
1929           pieces[npieces++] = s;
1930           while (*s && *s != ' ' && *s != '\t')
1931             s++;
1932           if (*s)
1933             *s++ = 0;
1934         }
1935       pieces = solv_extend(pieces, npieces, 1, sizeof(*pieces), 7);
1936       pieces[npieces] = 0;
1937       if (!strcmp(pieces[0], "repo") && npieces >= 4)
1938         {
1939           Repo *repo = repo_create(pool, pieces[1]);
1940           FILE *rfp;
1941           int prio, subprio;
1942           const char *rdata;
1943
1944           prepared = 0;
1945           if (!poolflagsreset)
1946             {
1947               poolflagsreset = 1;
1948               testcase_resetpoolflags(pool);    /* hmm */
1949             }
1950           if (sscanf(pieces[2], "%d.%d", &prio, &subprio) != 2)
1951             {
1952               subprio = 0;
1953               prio = atoi(pieces[2]);
1954             }
1955           repo->priority = prio;
1956           repo->subpriority = subprio;
1957           if (strcmp(pieces[3], "empty") != 0)
1958             {
1959               const char *repotype = pool_tmpjoin(pool, pieces[3], 0, 0);       /* gets overwritten in <inline> case */
1960               if (!strcmp(pieces[4], "<inline>"))
1961                 {
1962                   char *idata = read_inline_file(fp, &buf, &bufp, &bufl);
1963                   rdata = "<inline>";
1964                   rfp = solv_xfopen_buf(rdata, &idata, 0, "rf");
1965                 }
1966               else
1967                 {
1968                   rdata = pool_tmpjoin(pool, testcasedir, pieces[4], 0);
1969                   rfp = solv_xfopen(rdata, "r");
1970                 }
1971               if (!rfp)
1972                 {
1973                   pool_debug(pool, SOLV_ERROR, "testcase_read: could not open '%s'\n", rdata);
1974                 }
1975               else if (!strcmp(repotype, "testtags"))
1976                 {
1977                   testcase_add_testtags(repo, rfp, 0);
1978                   fclose(rfp);
1979                 }
1980               else if (!strcmp(repotype, "solv"))
1981                 {
1982                   repo_add_solv(repo, rfp, 0);
1983                   fclose(rfp);
1984                 }
1985 #if 0
1986               else if (!strcmp(repotype, "helix"))
1987                 {
1988                   repo_add_helix(repo, rfp, 0);
1989                   fclose(rfp);
1990                 }
1991 #endif
1992               else
1993                 {
1994                   fclose(rfp);
1995                   pool_debug(pool, SOLV_ERROR, "testcase_read: unknown repo type for repo '%s'\n", repo->name);
1996                 }
1997             }
1998         }
1999       else if (!strcmp(pieces[0], "system") && npieces >= 3)
2000         {
2001           int i;
2002           prepared = 0;
2003           /* must set the disttype before the arch */
2004           for (i = 0; disttype2str[i].str != 0; i++)
2005             if (!strcmp(disttype2str[i].str, pieces[2]))
2006               break;
2007           if (!disttype2str[i].str)
2008             pool_debug(pool, SOLV_ERROR, "testcase_read: system: unknown disttype '%s'\n", pieces[2]);
2009           else if (pool->disttype != disttype2str[i].type)
2010             {
2011 #ifdef MULTI_SEMANTICS
2012               pool_setdisttype(pool, disttype2str[i].type);
2013 #else
2014               pool_debug(pool, SOLV_ERROR, "testcase_read: system: cannot change disttype to '%s'\n", pieces[2]);
2015 #endif
2016             }
2017           if (strcmp(pieces[1], "unset") == 0)
2018             pool_setarch(pool, 0);
2019           else if (pieces[1][0] == ':')
2020             pool_setarchpolicy(pool, pieces[1] + 1);
2021           else
2022             pool_setarch(pool, pieces[1]);
2023           if (npieces > 3)
2024             {
2025               Repo *repo = testcase_str2repo(pool, pieces[3]);
2026               if (!repo)
2027                 pool_debug(pool, SOLV_ERROR, "testcase_read: system: unknown repo '%s'\n", pieces[3]);
2028               else
2029                 pool_set_installed(pool, repo);
2030             }
2031         }
2032       else if (!strcmp(pieces[0], "job") && npieces > 1)
2033         {
2034           char *sp;
2035           Id how, what;
2036           if (!prepared)
2037             {
2038               pool_addfileprovides(pool);
2039               pool_createwhatprovides(pool);
2040               prepared = 1;
2041             }
2042           if (npieces >= 3 && !strcmp(pieces[2], "selection"))
2043             {
2044               addselectionjob(pool, pieces + 1, npieces - 1, job);
2045               continue;
2046             }
2047           /* rejoin */
2048           for (sp = pieces[1]; sp < pieces[npieces - 1]; sp++)
2049             if (*sp == 0)
2050               *sp = ' ';
2051           how = testcase_str2job(pool, pieces[1], &what);
2052           if (how >= 0 && job)
2053             queue_push2(job, how, what);
2054         }
2055       else if (!strcmp(pieces[0], "vendorclass") && npieces > 1)
2056         {
2057           pool_addvendorclass(pool, (const char **)(pieces + 1));
2058         }
2059       else if (!strcmp(pieces[0], "namespace") && npieces > 1)
2060         {
2061           int i = strlen(pieces[1]);
2062           s = strchr(pieces[1], '(');
2063           if (!s && pieces[1][i - 1] != ')')
2064             {
2065               pool_debug(pool, SOLV_ERROR, "testcase_read: bad namespace '%s'\n", pieces[1]);
2066             }
2067           else
2068             {
2069               Id name, evr, id;
2070               Queue q;
2071               queue_init(&q);
2072               *s = 0;
2073               pieces[1][i - 1] = 0;
2074               name = pool_str2id(pool, pieces[1], 1);
2075               evr = pool_str2id(pool, s + 1, 1);
2076               *s = '(';
2077               pieces[1][i - 1] = ')';
2078               id = pool_rel2id(pool, name, evr, REL_NAMESPACE, 1);
2079               for (i = 2; i < npieces; i++)
2080                 queue_push(&q, testcase_str2solvid(pool, pieces[i]));
2081               /* now do the callback */
2082               if (!prepared)
2083                 {
2084                   pool_addfileprovides(pool);
2085                   pool_createwhatprovides(pool);
2086                   prepared = 1;
2087                 }
2088               pool->whatprovides_rel[GETRELID(id)] = pool_queuetowhatprovides(pool, &q);
2089               queue_free(&q);
2090             }
2091         }
2092       else if (!strcmp(pieces[0], "poolflags"))
2093         {
2094           int i;
2095           if (!poolflagsreset)
2096             {
2097               poolflagsreset = 1;
2098               testcase_resetpoolflags(pool);    /* hmm */
2099             }
2100           for (i = 1; i < npieces; i++)
2101             testcase_setpoolflags(pool, pieces[i]);
2102         }
2103       else if (!strcmp(pieces[0], "solverflags") && npieces > 1)
2104         {
2105           int i;
2106           if (!solv)
2107             {
2108               solv = solver_create(pool);
2109               testcase_resetsolverflags(solv);
2110             }
2111           for (i = 1; i < npieces; i++)
2112             testcase_setsolverflags(solv, pieces[i]);
2113         }
2114       else if (!strcmp(pieces[0], "result") && npieces > 2)
2115         {
2116           char *result = 0;
2117           int resultflags = str2resultflags(pool, pieces[1]);
2118           const char *rdata = pool_tmpjoin(pool, testcasedir, pieces[2], 0);
2119           if (!strcmp(pieces[2], "<inline>"))
2120             result = read_inline_file(fp, &buf, &bufp, &bufl);
2121           else
2122             {
2123               FILE *rfp = fopen(rdata, "r");
2124               if (!rfp)
2125                 pool_debug(pool, SOLV_ERROR, "testcase_read: could not open '%s'\n", rdata);
2126               else
2127                 {
2128                   result = read_file(rfp);
2129                   fclose(rfp);
2130                 }
2131             }
2132           if (resultp)
2133             *resultp = result;
2134           else
2135             solv_free(result);
2136           if (resultflagsp)
2137             *resultflagsp = resultflags;
2138         }
2139       else if (!strcmp(pieces[0], "nextjob") && npieces == 1)
2140         {
2141           break;
2142         }
2143       else
2144         {
2145           pool_debug(pool, SOLV_ERROR, "testcase_read: cannot parse command '%s'\n", pieces[0]);
2146         }
2147     }
2148   buf = solv_free(buf);
2149   pieces = solv_free(pieces);
2150   solv_free(testcasedir);
2151   if (!prepared)
2152     {
2153       pool_addfileprovides(pool);
2154       pool_createwhatprovides(pool);
2155     }
2156   if (!solv)
2157     {
2158       solv = solver_create(pool);
2159       testcase_resetsolverflags(solv);
2160     }
2161   if (closefp)
2162     fclose(fp);
2163   return solv;
2164 }
2165
2166 char *
2167 testcase_resultdiff(char *result1, char *result2)
2168 {
2169   Strqueue sq1, sq2, osq;
2170   char *r;
2171   strqueue_init(&sq1);
2172   strqueue_init(&sq2);
2173   strqueue_init(&osq);
2174   strqueue_split(&sq1, result1);
2175   strqueue_split(&sq2, result2);
2176   strqueue_sort(&sq1);
2177   strqueue_sort(&sq2);
2178   strqueue_diff(&sq1, &sq2, &osq);
2179   r = osq.nstr ? strqueue_join(&osq) : 0;
2180   strqueue_free(&sq1);
2181   strqueue_free(&sq2);
2182   strqueue_free(&osq);
2183   return r;
2184 }
2185