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