TEST(database, list_packages){
char* argz=0;
size_t argz_len=0;
TEST_ASSERT_EQUAL(SQLITE_ROW,list_packages(&argz,&argz_len,"Gcc"));
char* entry=0;
entry=argz_next(argz,argz_len,entry);
TEST_ASSERT_EQUAL_STRING(package.name, entry);
entry=argz_next(argz,argz_len,entry);
TEST_ASSERT_EQUAL_STRING(package.description, entry);
entry=argz_next(argz,argz_len,entry);
TEST_ASSERT_EQUAL(package.version, parse_version(entry));
}
static int
command_list_file_packages(int argc, const char *argv[])
{
struct razor_set *set;
struct razor_package_iterator *pi;
set = razor_root_open_read_only(install_root);
if (set == NULL)
return 1;
pi = razor_package_iterator_create_for_file(set, argv[0]);
list_packages(pi, 0);
razor_package_iterator_destroy(pi);
razor_set_destroy(set);
return 0;
}
static int
list_property_packages(const char *ref_name,
const char *ref_version,
uint32_t type)
{
struct razor_set *set;
struct razor_property *property;
struct razor_property_iterator *prop_iter;
struct razor_package_iterator *pkg_iter;
const char *name, *version;
uint32_t flags;
if (ref_name == NULL)
return 0;
set = razor_root_open_read_only(install_root);
if (set == NULL)
return 1;
prop_iter = razor_property_iterator_create(set, NULL);
while (razor_property_iterator_next(prop_iter, &property,
&name, &flags, &version)) {
if (strcmp(ref_name, name) != 0)
continue;
if (ref_version &&
(flags & RAZOR_PROPERTY_RELATION_MASK) == RAZOR_PROPERTY_EQUAL &&
strcmp(ref_version, version) != 0)
continue;
if ((flags & RAZOR_PROPERTY_TYPE_MASK) != type)
continue;
pkg_iter =
razor_package_iterator_create_for_property(set,
property);
list_packages(pkg_iter, 0);
razor_package_iterator_destroy(pkg_iter);
}
razor_property_iterator_destroy(prop_iter);
razor_set_destroy(set);
return 0;
}
static int
command_list(int argc, const char *argv[])
{
struct razor_package_iterator *pi;
struct razor_set *set;
uint32_t flags = 0;
int i = 0;
if (i < argc && strcmp(argv[i], "--only-names") == 0) {
flags |= LIST_PACKAGES_ONLY_NAMES;
i++;
}
set = razor_root_open_read_only(install_root);
if (set == NULL)
return 1;
pi = create_iterator_from_argv(set, argc - i, argv + i);
list_packages(pi, flags);
razor_package_iterator_destroy(pi);
razor_set_destroy(set);
return 0;
}
static int bee_dep_list(int argc, char *argv[])
{
int c, i, opt_count, help, files, packages, count,
depending_on, required_by, removable, provider_of,
not_cached, broken;
struct hash *graph;
char *name;
struct option long_options[] = {
{"help", 0, &help, 1},
{"files", 0, &files, 1},
{"packages", 0, &packages, 1},
{"count", 0, &count, 1},
{"depending-on", 0, &depending_on, 1},
{"required-by", 0, &required_by, 1},
{"removable", 0, &removable, 1},
{"provider-of", 0, &provider_of, 1},
{"not-cached", 0, ¬_cached, 1},
{"broken", 0, &broken, 1},
{0, 0, 0, 0}
};
opt_count = help = files = packages = provider_of =
count = depending_on = required_by = removable = not_cached =
broken = 0;
while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
switch (c) {
case '?':
usage_list();
return 1;
default:
opt_count++;
}
}
if (help) {
usage_list();
return 0;
}
if (!opt_count && optind != argc) {
fprintf(stderr, "bee-dep: too many arguments\n");
return 1;
}
if (!opt_count)
packages = 1;
if (opt_count > 1 && !count) {
fprintf(stderr, "bee-dep: too many options specified\n");
return 1;
}
if (packages) {
graph = get_cache();
if (count)
printf("%d\n", count_packages(graph));
else
list_packages(graph);
hash_free(graph);
return 0;
}
if (broken && optind < argc) {
fprintf(stderr, "bee-dep: too many arguments\n");
return 1;
}
if (optind == argc && !broken) {
fprintf(stderr, "bee-dep: arguments needed\n");
return 1;
}
if (count && (depending_on || required_by))
fprintf(stderr, "bee-dep: ignoring option --count\n");
graph = get_cache();
for (i = optind; i < argc; i++) {
name = argv[i];
if (optind < argc - 1)
printf("%s:\n", name);
if (files) {
if (count) {
c = count_files(graph, name);
if (c < 0) {
hash_free(graph);
return 1;
}
printf("%d\n", c);
} else if (list_files(graph, name)) {
hash_free(graph);
return 1;
}
}
if (removable) {
if (count) {
c = count_removable(graph, name);
if (c < 0) {
hash_free(graph);
return 1;
}
printf("%d\n", c);
} else if (print_removable(graph, name)) {
hash_free(graph);
return 1;
}
}
if (depending_on && print_neededby(graph, name)) {
hash_free(graph);
return 1;
}
if (required_by && print_needs(graph, name)) {
hash_free(graph);
return 1;
}
if (provider_of) {
if (count) {
c = count_providers(graph, name);
if (c < 0) {
hash_free(graph);
return 1;
}
printf("%d\n", c);
} else if (print_providers(graph, name)) {
hash_free(graph);
return 1;
}
}
if (not_cached) {
c = print_not_cached(graph, name, !count);
if (c < 0) {
hash_free(graph);
return 1;
}
if (count)
printf("%d\n", c);
}
}
if (broken) {
c = print_broken(graph, !count);
if (c < 0) {
hash_free(graph);
return 1;
}
if (count)
printf("%d\n", c);
}
hash_free(graph);
return 0;
}
