X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=tools%2Ftestsolv.c;h=d75124621e4b6a99a0290a0786be495190a6f437;hb=e1659dc4ce74d3c47f465103951dafff8fc0cf9f;hp=8221190406e95726f0b80de65f3103eb90d92453;hpb=fca3cc5b797ffa61e9059a0f965023ae4a4806e5;p=platform%2Fupstream%2Flibsolv.git

diff --git a/tools/testsolv.c b/tools/testsolv.c
index 8221190..d751246 100644
--- a/tools/testsolv.c
+++ b/tools/testsolv.c
@@ -5,32 +5,85 @@
 #include "pool.h"
 #include "repo.h"
 #include "solver.h"
+#include "selection.h"
 #include "solverdebug.h"
 #include "testcase.h"
 
+static struct resultflags2str {
+  Id flag;
+  const char *str;
+} resultflags2str[] = {
+  { TESTCASE_RESULT_TRANSACTION,        "transaction" },
+  { TESTCASE_RESULT_PROBLEMS,           "problems" },
+  { TESTCASE_RESULT_ORPHANED,           "orphaned" },
+  { TESTCASE_RESULT_RECOMMENDED,        "recommended" },
+  { TESTCASE_RESULT_UNNEEDED,           "unneeded" },
+  { TESTCASE_RESULT_ALTERNATIVES,       "alternatives" },
+  { TESTCASE_RESULT_RULES,              "rules" },
+  { TESTCASE_RESULT_GENID,              "genid" },
+  { 0, 0 }
+};
+
 static void
-usage(ex)
+usage(int ex)
 {
   fprintf(ex ? stderr : stdout, "Usage: testsolv <testcase>\n");
   exit(ex);
 }
 
+struct reportsolutiondata {
+  int count;
+  char *result;
+};
+
+static int
+reportsolutioncb(Solver *solv, void *cbdata)
+{
+  struct reportsolutiondata *sd = cbdata;
+  char *res;
+
+  sd->count++;
+  res = testcase_solverresult(solv, TESTCASE_RESULT_TRANSACTION);
+  if (*res)
+    {
+      char prefix[64];
+      char *p2, *p = res;
+      sprintf(prefix, "callback%d:", sd->count);
+      while ((p2 = strchr(p, '\n')) != 0)
+	{
+	  char c = p2[1];
+	  p2[1] = 0;
+	  sd->result = solv_dupappend(sd->result, prefix, p);
+	  p2[1] = c;
+	  p = p2 + 1;
+	}
+    }
+  solv_free(res);
+  return 0;
+}
+
 int
 main(int argc, char **argv)
 {
   Pool *pool;
   Queue job;
-  Solver *solv;
+  Queue solq;
+  Solver *solv, *reusesolv = 0;
   char *result = 0;
   int resultflags = 0;
   int debuglevel = 0;
   int writeresult = 0;
+  char *writetestcase = 0;
   int multijob = 0;
+  int rescallback = 0;
   int c;
   int ex = 0;
+  const char *list = 0;
   FILE *fp;
+  const char *p;
 
-  while ((c = getopt(argc, argv, "vrh")) >= 0)
+  queue_init(&solq);
+  while ((c = getopt(argc, argv, "vmrhl:s:T:")) >= 0)
     {
       switch (c)
       {
@@ -40,9 +93,24 @@ main(int argc, char **argv)
         case 'r':
           writeresult++;
           break;
+        case 'm':
+          rescallback = 1;
+          break;
         case 'h':
 	  usage(0);
           break;
+        case 'l':
+	  list = optarg;
+          break;
+        case 's':
+	  if ((p = strchr(optarg, ':')))
+	    queue_push2(&solq, atoi(optarg), atoi(p + 1));
+	  else
+	    queue_push2(&solq, 1, atoi(optarg));
+          break;
+        case 'T':
+	  writetestcase = optarg;
+          break;
         default:
 	  usage(1);
           break;
@@ -61,7 +129,7 @@ main(int argc, char **argv)
 	  perror(argv[optind]);
 	  exit(0);
 	}
-      while(!feof(fp))
+      while (!feof(fp))
 	{
 	  queue_init(&job);
 	  result = 0;
@@ -70,33 +138,85 @@ main(int argc, char **argv)
 	  if (!solv)
 	    {
 	      pool_free(pool);
-	      exit(1);
+	      exit(resultflags == 77 ? 77 : 1);
+	    }
+	  if (reusesolv)
+	    {
+	      solver_free(solv);
+	      solv = reusesolv;
+	      reusesolv = 0;
 	    }
-
 	  if (!multijob && !feof(fp))
 	    multijob = 1;
 
 	  if (multijob)
 	    printf("test %d:\n", multijob++);
-	  if (result || writeresult)
+	  if (list)
+	    {
+	      int selflags = SELECTION_NAME|SELECTION_PROVIDES|SELECTION_CANON|SELECTION_DOTARCH|SELECTION_REL|SELECTION_GLOB|SELECTION_FLAT;
+	      if (*list == '/')
+		selflags |= SELECTION_FILELIST;
+	      queue_empty(&job);
+	      selection_make(pool, &job, list, selflags);
+	      if (!job.elements)
+		printf("No match\n");
+	      else
+		{
+		  Queue q;
+		  int i;
+		  queue_init(&q);
+		  selection_solvables(pool, &job, &q);
+		  for (i = 0; i < q.count; i++)
+		    printf("  - %s\n", testcase_solvid2str(pool, q.elements[i]));
+		  queue_free(&q);
+		}
+	    }
+	  else if (result || writeresult)
 	    {
 	      char *myresult, *resultdiff;
+	      struct reportsolutiondata reportsolutiondata;
+	      memset(&reportsolutiondata, 0, sizeof(reportsolutiondata));
+	      if (rescallback)
+		{
+		  solv->solution_callback = reportsolutioncb;
+		  solv->solution_callback_data = &reportsolutiondata;
+		}
 	      solver_solve(solv, &job);
-	      if (!resultflags)
-		resultflags = TESTCASE_RESULT_TRANSACTION | TESTCASE_RESULT_PROBLEMS;
+	      solv->solution_callback = 0;
+	      solv->solution_callback_data = 0;
+	      if ((resultflags & ~TESTCASE_RESULT_REUSE_SOLVER) == 0)
+		resultflags |= TESTCASE_RESULT_TRANSACTION | TESTCASE_RESULT_PROBLEMS;
 	      myresult = testcase_solverresult(solv, resultflags);
+	      if (rescallback && reportsolutiondata.result)
+		{
+		  reportsolutiondata.result = solv_dupjoin(reportsolutiondata.result, myresult, 0);
+		  solv_free(myresult);
+		  myresult = reportsolutiondata.result;
+		}
 	      if (writeresult)
 		{
 		  if (*myresult)
 		    {
 		      if (writeresult > 1)
 			{
-			  char *p = myresult;
+			  const char *p;
+			  int i;
+			  
+			  printf("result ");
+			  p = "%s";
+			  for (i = 0; resultflags2str[i].str; i++)
+			    if ((resultflags & resultflags2str[i].flag) != 0)
+			      {
+			        printf(p, resultflags2str[i].str);
+			        p = ",%s";
+			      }
+			  printf(" <inline>\n");
+			  p = myresult;
 			  while (*p)
 			    {
-			      char *p2 = strchr(p, '\n');
+			      const char *p2 = strchr(p, '\n');
 			      p2 = p2 ? p2 + 1 : p + strlen(p);
-			      printf("#>%.*s", p2 - p, p);
+			      printf("#>%.*s", (int)(p2 - p), p);
 			      p = p2;
 			    }
 			}
@@ -119,15 +239,45 @@ main(int argc, char **argv)
 	    }
 	  else
 	    {
-	      if (solver_solve(solv, &job))
+	      int pcnt = solver_solve(solv, &job);
+	      if (writetestcase)
+		testcase_write(solv, writetestcase, resultflags, 0, 0);
+	      if (pcnt && solq.count)
+		{
+		  int i, taken = 0;
+		  for (i = 0; i < solq.count; i += 2)
+		    {
+		      if (solq.elements[i] > 0 && solq.elements[i] <= pcnt)
+			if (solq.elements[i + 1] > 0 && solq.elements[i + 1] <=  solver_solution_count(solv, solq.elements[i]))
+			  {
+			    printf("problem %d: taking solution %d\n", solq.elements[i], solq.elements[i + 1]);
+			    solver_take_solution(solv, solq.elements[i], solq.elements[i + 1], &job);
+			    taken = 1;
+			  }
+		    }
+		  if (taken)
+		    pcnt = solver_solve(solv, &job);
+		}
+	      if (pcnt)
 		{
-		  int problem, solution, pcnt, scnt;
-		  pcnt = solver_problem_count(solv);
+		  int problem, solution, scnt;
 		  printf("Found %d problems:\n", pcnt);
 		  for (problem = 1; problem <= pcnt; problem++)
 		    {
 		      printf("Problem %d:\n", problem);
+#if 1
 		      solver_printprobleminfo(solv, problem);
+#else
+		      {
+			Queue pq;
+			int j;
+			queue_init(&pq);
+			solver_findallproblemrules(solv, problem, &pq);
+			for (j = 0; j < pq.count; j++)
+			  solver_printproblemruleinfo(solv, pq.elements[j]);
+			queue_free(&pq);
+		      }
+#endif
 		      printf("\n");
 		      scnt = solver_solution_count(solv, problem);
 		      for (solution = 1; solution <= scnt; solution++)
@@ -147,9 +297,16 @@ main(int argc, char **argv)
 		}
 	    }
 	  queue_free(&job);
-	  solver_free(solv);
+	  if ((resultflags & TESTCASE_RESULT_REUSE_SOLVER) != 0 && !feof(fp))
+	    reusesolv = solv;
+	  else
+	    solver_free(solv);
 	}
+      if (reusesolv)
+	solver_free(reusesolv);
       pool_free(pool);
+      fclose(fp);
     }
+  queue_free(&solq);
   exit(ex);
 }