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