tools/testsolv.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4
   5 #include "pool.h"
   6 #include "repo.h"
   7 #include "solver.h"
   8 #include "selection.h"
   9 #include "solverdebug.h"
  10 #include "testcase.h"
  11
  12 static struct resultflags2str {
  13   Id flag;
  14   const char *str;
  15 } resultflags2str[] = {
  16   { TESTCASE_RESULT_TRANSACTION,        "transaction" },
  17   { TESTCASE_RESULT_PROBLEMS,           "problems" },
  18   { TESTCASE_RESULT_ORPHANED,           "orphaned" },
  19   { TESTCASE_RESULT_RECOMMENDED,        "recommended" },
  20   { TESTCASE_RESULT_UNNEEDED,           "unneeded" },
  21   { 0, 0 }
  22 };
  23
  24 static void
  25 usage(ex)
  26 {
  27   fprintf(ex ? stderr : stdout, "Usage: testsolv <testcase>\n");
  28   exit(ex);
  29 }
  30
  31 int
  32 main(int argc, char **argv)
  33 {
  34   Pool *pool;
  35   Queue job;
  36   Solver *solv;
  37   char *result = 0;
  38   int resultflags = 0;
  39   int debuglevel = 0;
  40   int writeresult = 0;
  41   int multijob = 0;
  42   int c;
  43   int ex = 0;
  44   const char *list = 0;
  45   FILE *fp;
  46
  47   while ((c = getopt(argc, argv, "vrhl:")) >= 0)
  48     {
  49       switch (c)
  50       {
  51         case 'v':
  52           debuglevel++;
  53           break;
  54         case 'r':
  55           writeresult++;
  56           break;
  57         case 'h':
  58           usage(0);
  59           break;
  60         case 'l':
  61           list = optarg;
  62           break;
  63         default:
  64           usage(1);
  65           break;
  66       }
  67     }
  68   if (optind == argc)
  69     usage(1);
  70   for (; optind < argc; optind++)
  71     {
  72       pool = pool_create();
  73       pool_setdebuglevel(pool, debuglevel);
  74
  75       fp = fopen(argv[optind], "r");
  76       if (!fp)
  77         {
  78           perror(argv[optind]);
  79           exit(0);
  80         }
  81       while(!feof(fp))
  82         {
  83           queue_init(&job);
  84           result = 0;
  85           resultflags = 0;
  86           solv = testcase_read(pool, fp, argv[optind], &job, &result, &resultflags);
  87           if (!solv)
  88             {
  89               pool_free(pool);
  90               exit(1);
  91             }
  92
  93           if (!multijob && !feof(fp))
  94             multijob = 1;
  95
  96           if (multijob)
  97             printf("test %d:\n", multijob++);
  98           if (list)
  99             {
 100               queue_empty(&job);
 101               selection_make(pool, &job, list, SELECTION_NAME|SELECTION_PROVIDES|SELECTION_FILELIST|SELECTION_CANON|SELECTION_DOTARCH|SELECTION_REL|SELECTION_GLOB|SELECTION_FLAT);
 102               if (!job.elements)
 103                 printf("No match\n");
 104               else
 105                 {
 106                   Queue q;
 107                   int i;
 108                   queue_init(&q);
 109                   selection_solvables(pool, &job, &q);
 110                   for (i = 0; i < q.count; i++)
 111                     printf("  - %s\n", testcase_solvid2str(pool, q.elements[i]));
 112                   queue_free(&q);
 113                 }
 114             }
 115           else if (result || writeresult)
 116             {
 117               char *myresult, *resultdiff;
 118               solver_solve(solv, &job);
 119               if (!resultflags)
 120                 resultflags = TESTCASE_RESULT_TRANSACTION | TESTCASE_RESULT_PROBLEMS;
 121               myresult = testcase_solverresult(solv, resultflags);
 122               if (writeresult)
 123                 {
 124                   if (*myresult)
 125                     {
 126                       if (writeresult > 1)
 127                         {
 128                           const char *p;
 129                           int i;
 130
 131                           printf("result ");
 132                           p = "%s";
 133                           for (i = 0; resultflags2str[i].str; i++)
 134                             if ((resultflags & resultflags2str[i].flag) != 0)
 135                               {
 136                                 printf(p, resultflags2str[i].str);
 137                                 p = ",%s";
 138                               }
 139                           printf(" <inline>\n");
 140                           p = myresult;
 141                           while (*p)
 142                             {
 143                               const char *p2 = strchr(p, '\n');
 144                               p2 = p2 ? p2 + 1 : p + strlen(p);
 145                               printf("#>%.*s", (int)(p2 - p), p);
 146                               p = p2;
 147                             }
 148                         }
 149                       else
 150                         printf("%s", myresult);
 151                     }
 152                 }
 153               else
 154                 {
 155                   resultdiff = testcase_resultdiff(result, myresult);
 156                   if (resultdiff)
 157                     {
 158                       printf("Results differ:\n%s", resultdiff);
 159                       ex = 1;
 160                       solv_free(resultdiff);
 161                     }
 162                 }
 163               solv_free(result);
 164               solv_free(myresult);
 165             }
 166           else
 167             {
 168               if (solver_solve(solv, &job))
 169                 {
 170                   int problem, solution, pcnt, scnt;
 171                   pcnt = solver_problem_count(solv);
 172                   printf("Found %d problems:\n", pcnt);
 173                   for (problem = 1; problem <= pcnt; problem++)
 174                     {
 175                       printf("Problem %d:\n", problem);
 176                       solver_printprobleminfo(solv, problem);
 177                       printf("\n");
 178                       scnt = solver_solution_count(solv, problem);
 179                       for (solution = 1; solution <= scnt; solution++)
 180                         {
 181                           printf("Solution %d:\n", solution);
 182                           solver_printsolution(solv, problem, solution);
 183                           printf("\n");
 184                         }
 185                     }
 186                 }
 187               else
 188                 {
 189                   Transaction *trans = solver_create_transaction(solv);
 190                   printf("Transaction summary:\n\n");
 191                   transaction_print(trans);
 192                   transaction_free(trans);
 193                 }
 194             }
 195           queue_free(&job);
 196           solver_free(solv);
 197         }
 198       pool_free(pool);
 199       fclose(fp);
 200     }
 201   exit(ex);
 202 }