Mercurialrazor / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | revisions | annotate | diff | raw
src/test-driver.c
author Richard Hughes <richard@hughsie.com>
Mon Jun 30 08:51:26 2008 +0100 (2008-06-30)
changeset 302 9b71b537d175
parent 284 6e19775d8930
child 306 cd3954499086
permissions -rw-r--r--
convert razor_package_get_details() and razor_package_iterator_next() to varargs

The functions for getting package details about a package were limited to a few
things, when in the future we will want to support much more about a package.
The iterator was also limited to name,version,arch when most of the time we
didn't need all this data. 
     1 /*

     2  * Copyright (C) 2008  Kristian Høgsberg <krh@redhat.com>

     3  * Copyright (C) 2008  Red Hat, Inc

     4  *

     5  * This program is free software; you can redistribute it and/or modify

     6  * it under the terms of the GNU General Public License as published by

     7  * the Free Software Foundation; either version 2 of the License, or

     8  * (at your option) any later version.

     9  *

    10  * This program is distributed in the hope that it will be useful,

    11  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    13  * GNU General Public License for more details.

    14  *

    15  * You should have received a copy of the GNU General Public License along

    16  * with this program; if not, write to the Free Software Foundation, Inc.,

    17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

    18  */

    19 

    20 #include <stdio.h>

    21 #include <string.h>

    22 #include <stdarg.h>

    23 #include <unistd.h>

    24 #include <fcntl.h>

    25 #include <errno.h>

    26 #include <expat.h>

    27 

    28 #include "razor.h"

    29 

    30 #define XML_BUFFER_SIZE 4096

    31 

    32 static void

    33 parse_xml_file(const char *filename,

    34 	       XML_StartElementHandler start,

    35 	       XML_EndElementHandler end,

    36 	       void *data)

    37 {

    38 	XML_Parser parser;

    39 	char *buffer;

    40 	int fd, len, err;

    41 

    42 	parser = XML_ParserCreate(NULL);

    43 	XML_SetElementHandler(parser, start, end);

    44 	XML_SetUserData(parser, data);

    45 

    46 	fd = open(filename, O_RDONLY);

    47 	if (fd < 0) {

    48 		fprintf(stderr, "failed to open %s: %m\n", filename);

    49 		exit(-1);

    50 	}

    51 

    52 	while (1) {

    53 		buffer = XML_GetBuffer(parser, XML_BUFFER_SIZE);

    54 		len = read(fd, buffer, XML_BUFFER_SIZE);

    55 		if (len == 0)

    56 			break;

    57 		err = XML_ParseBuffer(parser, len, len == 0);

    58 		if (err == XML_STATUS_ERROR) {

    59 			fprintf(stderr, "parse error at line %lu:\n%s\n",

    60 				XML_GetCurrentLineNumber(parser),

    61 				XML_ErrorString(XML_GetErrorCode(parser)));

    62 			exit(-1);

    63 		}

    64 	}

    65 

    66 	if (fd < 0) {

    67 		fprintf(stderr, "read: %m\n");

    68 		exit(-1);

    69 	}

    70 

    71 	close(fd);

    72 }

    73 

    74 struct test_context {

    75 	struct razor_set *system_set, *repo_set, *result_set;

    76 

    77 	struct razor_importer *importer;

    78 	struct razor_set **importer_set;

    79 

    80 	struct razor_transaction *trans;

    81 

    82 	char *install_pkgs[3], *remove_pkgs[3];

    83 	int n_install_pkgs, n_remove_pkgs;

    84 

    85 	int unsat;

    86 	int in_result;

    87 

    88 	int debug, errors;

    89 };

    90 

    91 static void

    92 get_atts(const char **atts, ...)

    93 {

    94 	va_list ap;

    95 	const char *name, **ptr;

    96 	int i;

    97 

    98 	va_start(ap, atts);

    99 	while (name = va_arg(ap, const char *), name != NULL) {

   100 		ptr = va_arg(ap, const char **);

   101 		*ptr = NULL;

   102 		for (i = 0; atts[i]; i += 2) {

   103 			if (strcmp(atts[i], name) == 0)

   104 				*ptr = atts[i + 1];

   105 		}

   106 	}

   107 	va_end(ap);

   108 }

   109 

   110 static enum razor_property_flags

   111 parse_relation (const char *rel_str)

   112 {

   113 	if (!rel_str)

   114 		return -1;

   115 	if (rel_str[0] == 'L')

   116 		return rel_str[1] == 'E' ? RAZOR_PROPERTY_LESS | RAZOR_PROPERTY_EQUAL : RAZOR_PROPERTY_LESS;

   117 	else if (rel_str[0] == 'G')

   118 		return rel_str[1] == 'E' ? RAZOR_PROPERTY_GREATER | RAZOR_PROPERTY_EQUAL : RAZOR_PROPERTY_GREATER;

   119 	else if (rel_str[0] == 'E' || rel_str[1] == 'Q')

   120 		return RAZOR_PROPERTY_EQUAL;

   121 	else

   122 		return -1;

   123 }

   124 

   125 static void

   126 start_test(struct test_context *ctx, const char **atts)

   127 {

   128 	const char *name = NULL;

   129 

   130 	get_atts(atts, "name", &name, NULL);

   131 	if (!name) {

   132 		fprintf(stderr, "Test with no name\n");

   133 		exit(1);

   134 	}

   135 	printf("%s\n", name);

   136 }

   137 

   138 static void

   139 end_test(struct test_context *ctx)

   140 {

   141 	if (ctx->system_set) {

   142 		razor_set_destroy(ctx->system_set);

   143 		ctx->system_set = NULL;

   144 	}

   145 	if (ctx->repo_set) {

   146 		razor_set_destroy(ctx->repo_set);

   147 		ctx->repo_set = NULL;

   148 	}

   149 	if (ctx->result_set) {

   150 		razor_set_destroy(ctx->result_set);

   151 		ctx->result_set = NULL;

   152 	}

   153 	if (ctx->trans) {

   154 		razor_transaction_destroy(ctx->trans);

   155 		ctx->trans = NULL;

   156 	}

   157 }

   158 

   159 static void

   160 start_set(struct test_context *ctx, const char **atts)

   161 {

   162 	const char *name = NULL;

   163 

   164 	ctx->importer = razor_importer_create();

   165 	get_atts(atts, "name", &name, NULL);

   166 	if (!name)

   167 		ctx->importer_set = &ctx->result_set;

   168 	else if (!strcmp(name, "system"))

   169 		ctx->importer_set = &ctx->system_set;

   170 	else if (!strcmp(name, "repo"))

   171 		ctx->importer_set = &ctx->repo_set;

   172 	else {

   173 		fprintf(stderr, "  bad set name '%s'\n", name);

   174 		exit(1);

   175 	}

   176 }

   177 

   178 static void

   179 end_set(struct test_context *ctx)

   180 {

   181 	*ctx->importer_set = razor_importer_finish(ctx->importer);

   182 	ctx->importer = NULL;

   183 }

   184 

   185 static void

   186 start_package(struct test_context *ctx, const char **atts)

   187 {

   188 	const char *name = NULL, *version = NULL, *arch = NULL;

   189 

   190 	get_atts(atts, "name", &name,

   191 		 "version", &version,

   192 		 "arch", &arch,

   193 		 NULL);

   194 

   195 	if (!name) {

   196 		fprintf(stderr, "  package with no name\n");

   197 		exit(1);

   198 	}

   199 

   200 	razor_importer_begin_package(ctx->importer, name, version, arch);

   201 	razor_importer_add_property(ctx->importer, name,

   202 				    RAZOR_PROPERTY_EQUAL | RAZOR_PROPERTY_PROVIDES,

   203 				    version);

   204 }

   205 

   206 static void

   207 end_package(struct test_context *ctx)

   208 {

   209 	razor_importer_finish_package(ctx->importer);

   210 }

   211 

   212 static void

   213 add_property(struct test_context *ctx, enum razor_property_flags type, const char *name, enum razor_property_flags rel, const char *version)

   214 {

   215 	razor_importer_add_property(ctx->importer, name,

   216 				    rel | type, version);

   217 }

   218 

   219 static const char*

   220 razor_property_flags_relation_to_string(enum razor_property_flags rel)

   221 {

   222 	if (rel == RAZOR_PROPERTY_LESS)

   223 		return "<";

   224 	if (rel == (RAZOR_PROPERTY_EQUAL | RAZOR_PROPERTY_LESS))

   225 		return "<=";

   226 	if (rel == RAZOR_PROPERTY_EQUAL)

   227 		return "=";

   228 	if (rel == (RAZOR_PROPERTY_EQUAL | RAZOR_PROPERTY_GREATER))

   229 		return ">=";

   230 	if (rel == RAZOR_PROPERTY_GREATER)

   231 		return ">";

   232 

   233 	return "";

   234 }

   235 

   236 static void

   237 check_unsatisfiable_property(struct test_context *ctx,

   238 			     enum razor_property_flags type,

   239 			     const char *name,

   240 			     enum razor_property_flags rel,

   241 			     const char *version)

   242 {

   243 	if (!version)

   244 		version = "";

   245 

   246 	if (razor_transaction_unsatisfied_property(ctx->trans,

   247 						   name, rel | type, version))

   248 		return;

   249 

   250 	fprintf(stderr, "  didn't get unsatisfiable '%s %s %s'\n",

   251 		name, razor_property_flags_relation_to_string(rel), version);

   252 	ctx->errors++;

   253 }

   254 

   255 static void

   256 start_property(struct test_context *ctx, enum razor_property_flags type, const char **atts)

   257 {

   258 	const char *name = NULL, *rel_str = NULL, *version = NULL;

   259 	enum razor_property_flags rel;

   260 

   261 	get_atts(atts, "name", &name, "relation", &rel_str, "version", &version, NULL);

   262 	if (name == NULL) {

   263 		fprintf(stderr, "  no name specified for property\n");

   264 		exit(1);

   265 	}

   266 	if (version) {

   267 		rel = parse_relation(rel_str);

   268 		if (rel == -1) {

   269 			fprintf(stderr, "  bad or missing version relation for property %s\n", name);

   270 			exit(1);

   271 		}

   272 	} else

   273 		rel = RAZOR_PROPERTY_EQUAL;

   274 

   275 	if (ctx->unsat)

   276 		check_unsatisfiable_property(ctx, type, name, rel, version);

   277 	else

   278 		add_property(ctx, type, name, rel, version);

   279 }

   280 

   281 static void

   282 start_transaction(struct test_context *ctx, const char **atts)

   283 {

   284 	ctx->n_install_pkgs = 0;

   285 	ctx->n_remove_pkgs = 0;

   286 }

   287 

   288 static void

   289 end_transaction(struct test_context *ctx)

   290 {

   291 	struct razor_package *pkg;

   292 	int errors, i;

   293 

   294 	ctx->trans = razor_transaction_create(ctx->system_set, ctx->repo_set);

   295 	for (i = 0; i < ctx->n_install_pkgs; i++) {

   296 		pkg = razor_set_get_package(ctx->repo_set,

   297 					    ctx->install_pkgs[i]);

   298 		razor_transaction_install_package(ctx->trans, pkg);

   299 	}

   300 	for (i = 0; i < ctx->n_remove_pkgs; i++) {

   301 		pkg = razor_set_get_package(ctx->system_set,

   302 					    ctx->remove_pkgs[i]);

   303 		if (!pkg)

   304 			pkg = razor_set_get_package(ctx->repo_set,

   305 						    ctx->remove_pkgs[i]);

   306 

   307 		razor_transaction_remove_package(ctx->trans, pkg);

   308 	}

   309 

   310 	razor_transaction_resolve(ctx->trans);

   311 	errors = razor_transaction_describe(ctx->trans);

   312 	printf("\n");

   313 

   314 	while (ctx->n_install_pkgs--)

   315 		free(ctx->install_pkgs[ctx->n_install_pkgs]);

   316 	while (ctx->n_remove_pkgs--)

   317 		free(ctx->remove_pkgs[ctx->n_remove_pkgs]);

   318 

   319 	if (!errors) {

   320 		struct razor_set *new;

   321 		new = razor_transaction_finish(ctx->trans);

   322 		ctx->trans = NULL;

   323 		ctx->system_set = new;

   324 	}

   325 }

   326 

   327 static void

   328 start_install_or_update(struct test_context *ctx, const char **atts)

   329 {

   330 	const char *name = NULL;

   331 

   332 	get_atts(atts, "name", &name, NULL);

   333 	if (!name) {

   334 		fprintf(stderr, "  install/update with no name\n");

   335 		exit(1);

   336 	}

   337 

   338 	ctx->install_pkgs[ctx->n_install_pkgs++] = strdup(name);

   339 }

   340 

   341 static void

   342 start_remove(struct test_context *ctx, const char **atts)

   343 {

   344 	const char *name = NULL;

   345 

   346 	get_atts(atts, "name", &name, NULL);

   347 	if (!name) {

   348 		fprintf(stderr, "  remove with no name\n");

   349 		exit(1);

   350 	}

   351 

   352 	ctx->remove_pkgs[ctx->n_remove_pkgs++] = strdup(name);

   353 }

   354 

   355 static void

   356 start_result(struct test_context *ctx, const char **atts)

   357 {

   358 	ctx->in_result = 1;

   359 }

   360 

   361 static void

   362 diff_callback(enum razor_diff_action action,

   363 	      struct razor_package *package,

   364 	      const char *name,

   365 	      const char *version,

   366 	      const char *arch,

   367 	      void *data)

   368 {

   369 	struct test_context *ctx = data;

   370 

   371 	ctx->errors++;

   372 	if (action == RAZOR_DIFF_ACTION_REMOVE) {

   373 		fprintf(stderr, "  result set should not contain %s %s\n",

   374 			name, version);

   375 	} else {

   376 		fprintf(stderr, "  result set should contain %s %s\n",

   377 			name, version);

   378 	}

   379 }

   380 

   381 static void

   382 end_result(struct test_context *ctx)

   383 {

   384 	ctx->in_result = 0;

   385 

   386 	if (ctx->result_set) {

   387 		if (!ctx->system_set)

   388 			ctx->system_set = razor_set_create();

   389 		razor_set_diff(ctx->system_set, ctx->result_set,

   390 			       diff_callback, ctx);

   391 	}

   392 }

   393 

   394 static void

   395 start_unsatisfiable(struct test_context *ctx, const char **atts)

   396 {

   397 	if (ctx->result_set) {

   398 		fprintf(stderr, "Expected to fail, but didn't\n");

   399 		exit(1);

   400 	}

   401 

   402 	ctx->unsat = 1;

   403 }

   404 

   405 static void

   406 end_unsatisfiable(struct test_context *ctx)

   407 {

   408 	ctx->unsat = 0;

   409 }

   410 

   411 static void

   412 start_test_element(void *data, const char *element, const char **atts)

   413 {

   414 	struct test_context *ctx = data;

   415 

   416 	if (strcmp(element, "tests") == 0) {

   417 		;

   418 	} else if (strcmp(element, "test") == 0) {

   419 		start_test(ctx, atts);

   420 	} else if (strcmp(element, "set") == 0) {

   421 		start_set(ctx, atts);

   422 	} else if (strcmp(element, "transaction") == 0) {

   423 		start_transaction(ctx, atts);

   424 	} else if (strcmp(element, "install") == 0) {

   425 		start_install_or_update(ctx, atts);

   426 	} else if (strcmp(element, "install") == 0) {

   427 		start_install_or_update(ctx, atts);

   428 	} else if (strcmp(element, "remove") == 0) {

   429 		start_remove(ctx, atts);

   430 	} else if (strcmp(element, "result") == 0) {

   431 		start_result(ctx, atts);

   432 	} else if (strcmp(element, "unsatisfiable") == 0) {

   433 		start_unsatisfiable(ctx, atts);

   434 	} else if (strcmp(element, "package") == 0) {

   435 		start_package(ctx, atts);

   436 	} else if (strcmp(element, "requires") == 0) {

   437 		start_property(ctx, RAZOR_PROPERTY_REQUIRES, atts);

   438 	} else if (strcmp(element, "provides") == 0) {

   439 		start_property(ctx, RAZOR_PROPERTY_PROVIDES, atts);

   440 	} else if (strcmp(element, "conflicts") == 0) {

   441 		start_property(ctx, RAZOR_PROPERTY_CONFLICTS, atts);

   442 	} else if (strcmp(element, "obsoletes") == 0) {

   443 		start_property(ctx, RAZOR_PROPERTY_OBSOLETES, atts);

   444 	} else {

   445 		fprintf(stderr, "Unrecognized element '%s'\n", element);

   446 		exit(1);

   447 	}

   448 }

   449 

   450 static void

   451 end_test_element (void *data, const char *element)

   452 {

   453 	struct test_context *ctx = data;

   454 

   455 	if (strcmp(element, "test") == 0) {

   456 		end_test(ctx);

   457 	} else if (strcmp(element, "set") == 0) {

   458 		end_set(ctx);

   459 	} else if (strcmp(element, "package") == 0) {

   460 		end_package(ctx);

   461 	} else if (strcmp(element, "transaction") == 0) {

   462 		end_transaction(ctx);

   463 	} else if (strcmp(element, "result") == 0) {

   464 		end_result(ctx);

   465 	} else if (strcmp(element, "unsatisfiable") == 0) {

   466 		end_unsatisfiable(ctx);

   467 	}

   468 }

   469 

   470 int main(int argc, char *argv[])

   471 {

   472 	struct test_context ctx;

   473 	const char *test_file;

   474 

   475 	memset(&ctx, 0, sizeof ctx);

   476 

   477 	if (argc > 3) {

   478 		fprintf(stderr, "usage: %s [-d] [TESTS-FILE]\n", argv[0]);

   479 		exit(-1);

   480 	}

   481 

   482 	if (argc >= 2 && !strcmp (argv[1], "-d")) {

   483 		ctx.debug = 1;

   484 		argc--;

   485 		argv++;

   486 	}

   487 	if (argc == 2)

   488 		test_file = argv[1];

   489 	else

   490 		test_file = "test.xml";

   491 

   492 	parse_xml_file(test_file, start_test_element, end_test_element, &ctx);

   493 

   494 	if (ctx.errors) {

   495 		fprintf(stderr, "\n%d errors\n", ctx.errors);

   496 		return 1;

   497 	} else

   498 		return 0;

   499 }
razor