+ scnt = solver_solution_count(solv, problem);
+ for (solution = 1; solution <= scnt; solution++)
+ {
+ s = testcase_solutionid(solv, problem, solution);
+ solprefix = solv_dupjoin(probprefix, " solution ", s);
+ element = 0;
+ while ((element = solver_next_solutionelement(solv, problem, solution, element, &p, &op)) != 0)
+ {
+ if (p == SOLVER_SOLUTION_JOB)
+ s = pool_tmpjoin(pool, solprefix, " deljob ", testcase_job2str(pool, solv->job.elements[op - 1], solv->job.elements[op]));
+ else if (p > 0 && op == 0)
+ s = pool_tmpjoin(pool, solprefix, " erase ", testcase_solvid2str(pool, p));
+ else if (p > 0 && op > 0)
+ {
+ s = pool_tmpjoin(pool, solprefix, " replace ", testcase_solvid2str(pool, p));
+ s = pool_tmpappend(pool, s, " ", testcase_solvid2str(pool, op));
+ }
+ else if (p < 0 && op > 0)
+ s = pool_tmpjoin(pool, solprefix, " allow ", testcase_solvid2str(pool, op));
+ else
+ s = pool_tmpjoin(pool, solprefix, " unknown", 0);
+ strqueue_push(&sq, s);
+ }
+ solv_free(solprefix);
+ }
+ solv_free(probprefix);
+ }
+ }
+
+ if ((resultflags & TESTCASE_RESULT_PROOF) != 0)
+ {
+ char *probprefix;
+ int pcnt, problem;
+ Queue q, lq;
+
+ queue_init(&q);
+ queue_init(&lq);
+ pcnt = solver_problem_count(solv);
+ for (problem = 1; problem <= pcnt + lq.count; problem++)
+ {
+ if (problem <= pcnt)
+ {
+ s = testcase_problemid(solv, problem);
+ solver_get_decisionlist(solv, problem, SOLVER_DECISIONLIST_PROBLEM, &q);
+ }
+ else
+ {
+ s = testcase_ruleid(solv, lq.elements[problem - pcnt - 1]);
+ solver_get_decisionlist(solv, lq.elements[problem - pcnt - 1], SOLVER_DECISIONLIST_LEARNTRULE, &q);
+ }
+ probprefix = solv_dupjoin("proof ", s, 0);
+ for (i = 0; i < q.count; i += 3)
+ {
+ SolverRuleinfo rclass;
+ Queue rq;
+ Id truelit = q.elements[i];
+ Id rid = q.elements[i + 2];
+ char *rprefix;
+ char nbuf[16];
+
+ rclass = solver_ruleclass(solv, rid);
+ if (rclass == SOLVER_RULE_LEARNT)
+ queue_pushunique(&lq, rid);
+ queue_init(&rq);
+ solver_ruleliterals(solv, rid, &rq);
+ sprintf(nbuf, "%3d", i / 3);
+ rprefix = solv_dupjoin(probprefix, " ", nbuf);
+ if (q.elements[i + 1] == SOLVER_REASON_PREMISE)
+ {
+ rprefix = solv_dupappend(rprefix, " premise", 0);
+ queue_empty(&rq);
+ queue_push(&rq, truelit);
+ }
+ else
+ {
+ rprefix = solv_dupappend(rprefix, " ", testcase_rclass2str(rclass));
+ rprefix = solv_dupappend(rprefix, " ", testcase_ruleid(solv, rid));
+ }
+ strqueue_push(&sq, rprefix);
+ solv_free(rprefix);
+ rprefix = solv_dupjoin(probprefix, " ", nbuf);
+ rprefix = solv_dupappend(rprefix, ": ", 0);
+ for (j = 0; j < rq.count; j++)
+ {
+ const char *s;
+ Id p = rq.elements[j];
+ if (p == truelit)
+ s = pool_tmpjoin(pool, rprefix, "-->", 0);
+ else
+ s = pool_tmpjoin(pool, rprefix, " ", 0);
+ if (p < 0)
+ s = pool_tmpappend(pool, s, " -", testcase_solvid2str(pool, -p));
+ else
+ s = pool_tmpappend(pool, s, " ", testcase_solvid2str(pool, p));
+ strqueue_push(&sq, s);
+ }
+ solv_free(rprefix);
+ queue_free(&rq);
+ }
+ solv_free(probprefix);
+ }
+ queue_free(&q);
+ queue_free(&lq);
+ }
+
+ if ((resultflags & TESTCASE_RESULT_ORPHANED) != 0)
+ {
+ Queue q;
+
+ queue_init(&q);
+ solver_get_orphaned(solv, &q);
+ for (i = 0; i < q.count; i++)
+ {
+ s = pool_tmpjoin(pool, "orphaned ", testcase_solvid2str(pool, q.elements[i]), 0);
+ strqueue_push(&sq, s);
+ }
+ queue_free(&q);
+ }
+
+ if ((resultflags & TESTCASE_RESULT_RECOMMENDED) != 0)
+ {
+ Queue qr, qs;
+
+ queue_init(&qr);
+ queue_init(&qs);
+ solver_get_recommendations(solv, &qr, &qs, 0);
+ for (i = 0; i < qr.count; i++)
+ {
+ s = pool_tmpjoin(pool, "recommended ", testcase_solvid2str(pool, qr.elements[i]), 0);
+ strqueue_push(&sq, s);
+ }
+ for (i = 0; i < qs.count; i++)
+ {
+ s = pool_tmpjoin(pool, "suggested ", testcase_solvid2str(pool, qs.elements[i]), 0);
+ strqueue_push(&sq, s);
+ }
+ queue_free(&qr);
+ queue_free(&qs);
+ }
+
+ if ((resultflags & TESTCASE_RESULT_UNNEEDED) != 0)
+ {
+ Queue q, qf;
+
+ queue_init(&q);
+ queue_init(&qf);
+ solver_get_unneeded(solv, &q, 0);
+ solver_get_unneeded(solv, &qf, 1);
+ for (i = j = 0; i < q.count; i++)
+ {
+ /* we rely on qf containing a subset of q in the same order */
+ if (j < qf.count && q.elements[i] == qf.elements[j])
+ {
+ s = pool_tmpjoin(pool, "unneeded_filtered ", testcase_solvid2str(pool, q.elements[i]), 0);
+ j++;
+ }
+ else
+ s = pool_tmpjoin(pool, "unneeded ", testcase_solvid2str(pool, q.elements[i]), 0);
+ strqueue_push(&sq, s);
+ }
+ queue_free(&q);
+ queue_free(&qf);
+ }
+ if ((resultflags & TESTCASE_RESULT_USERINSTALLED) != 0)
+ {
+ Queue q;
+ solver_get_userinstalled(solv, &q, 0);
+ for (i = 0; i < q.count; i++)
+ {
+ s = pool_tmpjoin(pool, "userinstalled pkg ", testcase_solvid2str(pool, q.elements[i]), 0);
+ strqueue_push(&sq, s);
+ }
+ queue_empty(&q);
+ solver_get_userinstalled(solv, &q, GET_USERINSTALLED_NAMES | GET_USERINSTALLED_INVERTED);
+ for (i = 0; i < q.count; i++)
+ {
+ s = pool_tmpjoin(pool, "autoinst name ", pool_id2str(pool, q.elements[i]), 0);
+ strqueue_push(&sq, s);
+ }
+ queue_free(&q);
+ }
+ if ((resultflags & TESTCASE_RESULT_ORDER) != 0)
+ {
+ int i;
+ char buf[256];
+ Id p;
+ Transaction *trans = solver_create_transaction(solv);
+ transaction_order(trans, 0);
+ for (i = 0; i < trans->steps.count; i++)
+ {
+ p = trans->steps.elements[i];
+ if (pool->installed && pool->solvables[p].repo == pool->installed)
+ sprintf(buf, "%4d erase ", i + 1);
+ else
+ sprintf(buf, "%4d install ", i + 1);
+ s = pool_tmpjoin(pool, "order ", buf, testcase_solvid2str(pool, p));
+ strqueue_push(&sq, s);
+ }
+ transaction_free(trans);
+ }
+ if ((resultflags & TESTCASE_RESULT_ORDEREDGES) != 0)
+ {
+ Queue q;
+ int i, j;
+ Id p, p2;
+ Transaction *trans = solver_create_transaction(solv);
+ transaction_order(trans, SOLVER_TRANSACTION_KEEP_ORDEREDGES);
+ queue_init(&q);
+ for (i = 0; i < trans->steps.count; i++)
+ {
+ p = trans->steps.elements[i];
+ transaction_order_get_edges(trans, p, &q, 1);
+ for (j = 0; j < q.count; j += 2)
+ {
+ char typebuf[32], *s;
+ p2 = q.elements[j];
+ sprintf(typebuf, " -%x-> ", q.elements[j + 1]);
+ s = pool_tmpjoin(pool, "orderedge ", testcase_solvid2str(pool, p), typebuf);
+ s = pool_tmpappend(pool, s, testcase_solvid2str(pool, p2), 0);
+ strqueue_push(&sq, s);
+ }
+ }
+ queue_free(&q);
+ transaction_free(trans);
+ }
+ if ((resultflags & TESTCASE_RESULT_ALTERNATIVES) != 0)
+ {
+ Queue q;
+ int cnt;
+ Id alternative;
+ queue_init(&q);
+ cnt = solver_alternatives_count(solv);
+ for (alternative = 1; alternative <= cnt; alternative++)
+ {
+ Id id, from, chosen;
+ char num[20], *s;
+ int type = solver_get_alternative(solv, alternative, &id, &from, &chosen, &q, 0);
+ char *altprefix = solv_dupjoin("alternative ", testcase_alternativeid(solv, type, id, from), " ");
+ strcpy(num, " 0 ");
+ s = pool_tmpjoin(pool, altprefix, num, solver_alternative2str(solv, type, id, from));
+ strqueue_push(&sq, s);
+ for (i = 0; i < q.count; i++)