/**
* pk_backend_get_groups:
*/
PkBitfield
pk_backend_get_groups (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_GROUP_ENUM_COLLECTIONS,
/* FIXME: These depend on the Smart backends: */
PK_GROUP_ENUM_ACCESSIBILITY,
PK_GROUP_ENUM_ACCESSORIES,
PK_GROUP_ENUM_ADMIN_TOOLS,
PK_GROUP_ENUM_COMMUNICATION,
PK_GROUP_ENUM_DESKTOP_GNOME,
PK_GROUP_ENUM_DESKTOP_KDE,
PK_GROUP_ENUM_DESKTOP_OTHER,
PK_GROUP_ENUM_DESKTOP_XFCE,
PK_GROUP_ENUM_DOCUMENTATION,
PK_GROUP_ENUM_EDUCATION,
PK_GROUP_ENUM_ELECTRONICS,
PK_GROUP_ENUM_FONTS,
PK_GROUP_ENUM_GAMES,
PK_GROUP_ENUM_GRAPHICS,
PK_GROUP_ENUM_INTERNET,
PK_GROUP_ENUM_LEGACY,
PK_GROUP_ENUM_LOCALIZATION,
PK_GROUP_ENUM_MULTIMEDIA,
PK_GROUP_ENUM_NETWORK,
PK_GROUP_ENUM_OFFICE,
PK_GROUP_ENUM_OTHER,
PK_GROUP_ENUM_PROGRAMMING,
PK_GROUP_ENUM_PUBLISHING,
PK_GROUP_ENUM_SCIENCE,
PK_GROUP_ENUM_SECURITY,
PK_GROUP_ENUM_SYSTEM,
PK_GROUP_ENUM_VIRTUALIZATION,
-1);
}
PkBitfield
pk_backend_get_filters (PkBackend *self)
{
g_return_val_if_fail (self != NULL, 0);
return pk_bitfield_from_enums (PK_FILTER_ENUM_INSTALLED, -1);
}
/**
* pk_backend_get_roles:
*/
PkBitfield
pk_backend_get_roles (PkBackend *backend)
{
PkBitfield roles;
roles = pk_bitfield_from_enums (
PK_ROLE_ENUM_CANCEL,
PK_ROLE_ENUM_DEPENDS_ON,
PK_ROLE_ENUM_GET_DETAILS,
PK_ROLE_ENUM_GET_FILES,
PK_ROLE_ENUM_REQUIRED_BY,
PK_ROLE_ENUM_GET_PACKAGES,
PK_ROLE_ENUM_WHAT_PROVIDES,
PK_ROLE_ENUM_GET_UPDATES,
PK_ROLE_ENUM_GET_UPDATE_DETAIL,
PK_ROLE_ENUM_INSTALL_PACKAGES,
//PK_ROLE_ENUM_INSTALL_FILES,
//PK_ROLE_ENUM_INSTALL_SIGNATURE,
PK_ROLE_ENUM_REFRESH_CACHE,
PK_ROLE_ENUM_REMOVE_PACKAGES,
PK_ROLE_ENUM_DOWNLOAD_PACKAGES,
PK_ROLE_ENUM_RESOLVE,
PK_ROLE_ENUM_SEARCH_DETAILS,
PK_ROLE_ENUM_SEARCH_FILE,
PK_ROLE_ENUM_SEARCH_GROUP,
PK_ROLE_ENUM_SEARCH_NAME,
PK_ROLE_ENUM_UPDATE_PACKAGES,
PK_ROLE_ENUM_GET_REPO_LIST,
PK_ROLE_ENUM_REPO_ENABLE,
//PK_ROLE_ENUM_REPO_SET_DATA,
//PK_ROLE_ENUM_GET_CATEGORIES,
-1);
return roles;
}
/**
* backend_get_filters:
*/
static PkBitfield
backend_get_filters (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_FILTER_ENUM_INSTALLED,
-1);
}
/**
* pk_backend_get_groups:
*/
PkBitfield pk_backend_get_groups(PkBackend *backend)
{
return pk_bitfield_from_enums(
PK_GROUP_ENUM_ACCESSORIES,
PK_GROUP_ENUM_ADMIN_TOOLS,
PK_GROUP_ENUM_COMMUNICATION,
PK_GROUP_ENUM_DOCUMENTATION,
PK_GROUP_ENUM_DESKTOP_GNOME,
PK_GROUP_ENUM_DESKTOP_KDE,
PK_GROUP_ENUM_DESKTOP_OTHER,
PK_GROUP_ENUM_ELECTRONICS,
PK_GROUP_ENUM_FONTS,
PK_GROUP_ENUM_GAMES,
PK_GROUP_ENUM_GRAPHICS,
PK_GROUP_ENUM_INTERNET,
PK_GROUP_ENUM_LEGACY,
PK_GROUP_ENUM_LOCALIZATION,
PK_GROUP_ENUM_MULTIMEDIA,
PK_GROUP_ENUM_NETWORK,
PK_GROUP_ENUM_OTHER,
PK_GROUP_ENUM_PROGRAMMING,
PK_GROUP_ENUM_PUBLISHING,
PK_GROUP_ENUM_SCIENCE,
PK_GROUP_ENUM_SYSTEM,
-1);
}
/**
* pk_backend_get_groups:
*/
PkBitfield
pk_backend_get_groups (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_GROUP_ENUM_COLLECTIONS,
PK_GROUP_ENUM_NEWEST,
PK_GROUP_ENUM_ADMIN_TOOLS,
PK_GROUP_ENUM_DESKTOP_GNOME,
PK_GROUP_ENUM_DESKTOP_KDE,
PK_GROUP_ENUM_DESKTOP_XFCE,
PK_GROUP_ENUM_DESKTOP_OTHER,
PK_GROUP_ENUM_EDUCATION,
PK_GROUP_ENUM_FONTS,
PK_GROUP_ENUM_GAMES,
PK_GROUP_ENUM_GRAPHICS,
PK_GROUP_ENUM_INTERNET,
PK_GROUP_ENUM_LEGACY,
PK_GROUP_ENUM_LOCALIZATION,
PK_GROUP_ENUM_MULTIMEDIA,
PK_GROUP_ENUM_OFFICE,
PK_GROUP_ENUM_OTHER,
PK_GROUP_ENUM_PROGRAMMING,
PK_GROUP_ENUM_PUBLISHING,
PK_GROUP_ENUM_SERVERS,
PK_GROUP_ENUM_SYSTEM,
PK_GROUP_ENUM_VIRTUALIZATION,
-1);
}
ATF_TC_BODY(pkg_matches_filters_not_installed, tc)
{
struct pkg *local;
struct pkg *remote;
PkBitfield filter;
filter = pk_bitfield_from_enums(PK_FILTER_ENUM_NOT_INSTALLED, -1);
/* Locally installed -> reject */
local = gen_pkg(PKG_INSTALLED);
ATF_REQUIRE(local != NULL);
ATF_CHECK(!pkgutils_pkg_matches_filters(local, filter));
pkg_free(local);
remote = gen_pkg(PKG_REMOTE);
ATF_REQUIRE(remote != NULL);
/* Old version newer -> reject */
pkg_set(remote, PKG_OLD_VERSION, "1.2.3");
ATF_CHECK(pkgutils_pkg_matches_filters(remote, filter));
/* Old version the same -> accept */
pkg_set(remote, PKG_OLD_VERSION, "1.1.4");
ATF_CHECK(!pkgutils_pkg_matches_filters(remote, filter));
/* Old version older -> reject */
pkg_set(remote, PKG_OLD_VERSION, "1.0.0");
ATF_CHECK(pkgutils_pkg_matches_filters(remote, filter));
pkg_free(remote);
}
static gboolean
gs_plugin_add_sources_related (GsPlugin *plugin,
GHashTable *hash,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint i;
GsApp *app;
GsApp *app_tmp;
PkBitfield filter;
ProgressData data;
const gchar *id;
gboolean ret = TRUE;
g_autoptr(GsAppList) installed = gs_app_list_new ();
g_autoptr(PkResults) results = NULL;
g_autoptr(AsProfileTask) ptask = NULL;
data.app = NULL;
data.plugin = plugin;
data.ptask = NULL;
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"packagekit::add-sources-related");
g_assert (ptask != NULL);
filter = pk_bitfield_from_enums (PK_FILTER_ENUM_INSTALLED,
PK_FILTER_ENUM_NEWEST,
PK_FILTER_ENUM_ARCH,
PK_FILTER_ENUM_NOT_COLLECTIONS,
-1);
results = pk_client_get_packages (PK_CLIENT(priv->task),
filter,
cancellable,
gs_plugin_packagekit_progress_cb, &data,
error);
if (!gs_plugin_packagekit_results_valid (results, error))
return FALSE;
ret = gs_plugin_packagekit_add_results (plugin,
installed,
results,
error);
if (!ret)
return FALSE;
for (i = 0; i < gs_app_list_length (installed); i++) {
g_auto(GStrv) split = NULL;
app = gs_app_list_index (installed, i);
split = pk_package_id_split (gs_app_get_source_id_default (app));
if (g_str_has_prefix (split[PK_PACKAGE_ID_DATA], "installed:")) {
id = split[PK_PACKAGE_ID_DATA] + 10;
app_tmp = g_hash_table_lookup (hash, id);
if (app_tmp != NULL) {
g_debug ("found package %s from %s",
gs_app_get_source_default (app), id);
gs_app_add_related (app_tmp, app);
}
}
}
return TRUE;
}
gboolean
gs_plugin_add_sources (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
PkBitfield filter;
PkRepoDetail *rd;
ProgressData data;
const gchar *id;
guint i;
g_autoptr(GHashTable) hash = NULL;
g_autoptr(PkResults) results = NULL;
g_autoptr(GPtrArray) array = NULL;
data.app = NULL;
data.plugin = plugin;
data.ptask = NULL;
/* ask PK for the repo details */
filter = pk_bitfield_from_enums (PK_FILTER_ENUM_NOT_SOURCE,
PK_FILTER_ENUM_NOT_SUPPORTED,
-1);
results = pk_client_get_repo_list (PK_CLIENT(priv->task),
filter,
cancellable,
gs_plugin_packagekit_progress_cb, &data,
error);
if (!gs_plugin_packagekit_results_valid (results, error))
return FALSE;
hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
array = pk_results_get_repo_detail_array (results);
for (i = 0; i < array->len; i++) {
g_autoptr(GsApp) app = NULL;
rd = g_ptr_array_index (array, i);
id = pk_repo_detail_get_id (rd);
app = gs_app_new (id);
gs_app_set_management_plugin (app, gs_plugin_get_name (plugin));
gs_app_set_kind (app, AS_APP_KIND_SOURCE);
gs_app_set_state (app, pk_repo_detail_get_enabled (rd) ?
AS_APP_STATE_INSTALLED : AS_APP_STATE_AVAILABLE);
gs_app_set_name (app,
GS_APP_QUALITY_LOWEST,
pk_repo_detail_get_description (rd));
gs_app_set_summary (app,
GS_APP_QUALITY_LOWEST,
pk_repo_detail_get_description (rd));
gs_app_list_add (list, app);
g_hash_table_insert (hash,
g_strdup (id),
(gpointer) app);
}
/* get every application on the system and add it as a related package
* if it matches */
return gs_plugin_add_sources_related (plugin, hash, cancellable, error);
}
/**
* pk_backend_get_groups:
*/
PkBitfield
pk_backend_get_groups (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_GROUP_ENUM_ACCESSIBILITY,
PK_GROUP_ENUM_GAMES,
PK_GROUP_ENUM_SYSTEM,
-1);
}
/**
* pk_backend_get_filters:
*/
PkBitfield
pk_backend_get_filters (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_FILTER_ENUM_GUI,
PK_FILTER_ENUM_INSTALLED,
PK_FILTER_ENUM_DEVELOPMENT,
-1);
}
/**
* pk_backend_get_filters:
*/
PkBitfield
pk_backend_get_filters (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_FILTER_ENUM_GUI,
PK_FILTER_ENUM_INSTALLED,
PK_FILTER_ENUM_DEVELOPMENT,
PK_FILTER_ENUM_SUPPORTED,
PK_FILTER_ENUM_FREE,
PK_FILTER_ENUM_COLLECTIONS,
-1);
}
/**
* pk_backend_get_provides:
*/
PkBitfield pk_backend_get_provides(PkBackend *backend)
{
PkBitfield provides;
provides = pk_bitfield_from_enums(
PK_PROVIDES_ENUM_CODEC,
PK_PROVIDES_ENUM_MODALIAS,
PK_PROVIDES_ENUM_MIMETYPE,
PK_PROVIDES_ENUM_ANY,
-1);
return provides;
}
/**
* pk_debuginfo_install_resolve_name_to_id:
**/
static gchar *
pk_debuginfo_install_resolve_name_to_id (PkDebuginfoInstallPrivate *priv, const gchar *package_name, GError **error)
{
PkResults *results = NULL;
PkPackage *item;
gchar *package_id = NULL;
GPtrArray *list = NULL;
GError *error_local = NULL;
gchar **names;
PkError *error_code = NULL;
/* resolve takes a char** */
names = g_strsplit (package_name, ";", -1);
/* resolve */
results = pk_client_resolve (priv->client, pk_bitfield_from_enums (PK_FILTER_ENUM_NEWEST, -1), names, NULL, NULL, NULL, &error_local);
if (results == NULL) {
*error = g_error_new (1, 0, "failed to resolve: %s", error_local->message);
g_error_free (error_local);
goto out;
}
/* check error code */
error_code = pk_results_get_error_code (results);
if (error_code != NULL) {
*error = g_error_new (1, 0, "failed to resolve: %s, %s", pk_error_enum_to_string (pk_error_get_code (error_code)), pk_error_get_details (error_code));
goto out;
}
/* check we only got one match */
list = pk_results_get_package_array (results);
if (list->len == 0) {
*error = g_error_new (1, 0, "no package %s found", package_name);
goto out;
}
if (list->len > 1) {
*error = g_error_new (1, 0, "more than one package found for %s", package_name);
goto out;
}
/* get the package id */
item = g_ptr_array_index (list, 0);
package_id = g_strdup (pk_package_get_id (item));
out:
if (error_code != NULL)
g_object_unref (error_code);
if (results != NULL)
g_object_unref (results);
if (list != NULL)
g_ptr_array_unref (list);
g_strfreev (names);
return package_id;
}
/**
* backend_get_groups:
*/
static PkBitfield
backend_get_groups (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_GROUP_ENUM_COMMUNICATION,
PK_GROUP_ENUM_PROGRAMMING,
PK_GROUP_ENUM_GAMES,
PK_GROUP_ENUM_OTHER,
PK_GROUP_ENUM_INTERNET,
PK_GROUP_ENUM_REPOS,
PK_GROUP_ENUM_MAPS,
-1);
}
/**
* pk_backend_get_filters:
*/
PkBitfield
pk_backend_get_filters (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_FILTER_ENUM_GUI,
PK_FILTER_ENUM_INSTALLED,
PK_FILTER_ENUM_DEVELOPMENT,
PK_FILTER_ENUM_BASENAME,
PK_FILTER_ENUM_FREE,
PK_FILTER_ENUM_NEWEST,
PK_FILTER_ENUM_ARCH,
PK_FILTER_ENUM_APPLICATION,
-1);
}
/**
* pk_backend_get_filters:
*/
PkBitfield
pk_backend_get_filters (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_FILTER_ENUM_INSTALLED,
PK_FILTER_ENUM_NEWEST,
PK_FILTER_ENUM_ARCH,
PK_FILTER_ENUM_GUI,
PK_FILTER_ENUM_DEVELOPMENT,
PK_FILTER_ENUM_BASENAME,
PK_FILTER_ENUM_COLLECTIONS,
/* FIXME: These depend on a newer Smart API: */
PK_FILTER_ENUM_FREE,
-1);
}
/**
* pk_backend_get_filters:
*/
PkBitfield
pk_backend_get_filters (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_FILTER_ENUM_INSTALLED,
PK_FILTER_ENUM_FREE,
PK_FILTER_ENUM_NEWEST,
-1);
/*
* These filters are candidate for further add:
* PK_FILTER_ENUM_GUI (need new PROPERTIES entry)
* PK_FILTER_ENUM_ARCH (need some work, see ML)
* PK_FILTER_ENUM_SOURCE (need some work/support, see ML)
* PK_FILTER_ENUM_COLLECTIONS (need new PROPERTIES entry)
* PK_FILTER_ENUM_APPLICATION (need new PROPERTIES entry)
*/
}
/**
* pk_backend_get_filters:
*/
PkBitfield pk_backend_get_filters(PkBackend *backend)
{
PkBitfield filters;
filters = pk_bitfield_from_enums(
PK_FILTER_ENUM_GUI,
PK_FILTER_ENUM_INSTALLED,
PK_FILTER_ENUM_DEVELOPMENT,
PK_FILTER_ENUM_SUPPORTED,
PK_FILTER_ENUM_FREE,
-1);
// if we have multiArch support we add the native filter
if (APT::Configuration::getArchitectures(false).size() > 1) {
pk_bitfield_add(filters, PK_FILTER_ENUM_ARCH);
}
return filters;
}
PkBitfield pk_backend_get_groups(PkBackend *backend) {
return pk_bitfield_from_enums(PK_GROUP_ENUM_COLLECTIONS,
PK_GROUP_ENUM_SYSTEM,
PK_GROUP_ENUM_ADMIN_TOOLS,
PK_GROUP_ENUM_PROGRAMMING,
PK_GROUP_ENUM_PUBLISHING,
PK_GROUP_ENUM_DOCUMENTATION,
PK_GROUP_ENUM_DESKTOP_KDE,
PK_GROUP_ENUM_LOCALIZATION,
PK_GROUP_ENUM_NETWORK,
PK_GROUP_ENUM_DESKTOP_OTHER,
PK_GROUP_ENUM_ACCESSORIES,
PK_GROUP_ENUM_DESKTOP_XFCE,
PK_GROUP_ENUM_GAMES,
PK_GROUP_ENUM_OTHER,
PK_GROUP_ENUM_UNKNOWN,
-1);
}
/**
* pk_backend_get_roles:
*/
PkBitfield pk_backend_get_roles(PkBackend *backend)
{
PkBitfield roles;
roles = pk_bitfield_from_enums(
PK_ROLE_ENUM_CANCEL,
PK_ROLE_ENUM_DEPENDS_ON,
PK_ROLE_ENUM_GET_DETAILS,
PK_ROLE_ENUM_GET_FILES,
PK_ROLE_ENUM_REQUIRED_BY,
PK_ROLE_ENUM_GET_PACKAGES,
PK_ROLE_ENUM_WHAT_PROVIDES,
PK_ROLE_ENUM_GET_UPDATES,
PK_ROLE_ENUM_GET_UPDATE_DETAIL,
PK_ROLE_ENUM_INSTALL_PACKAGES,
PK_ROLE_ENUM_INSTALL_SIGNATURE,
PK_ROLE_ENUM_REFRESH_CACHE,
PK_ROLE_ENUM_REMOVE_PACKAGES,
PK_ROLE_ENUM_DOWNLOAD_PACKAGES,
PK_ROLE_ENUM_RESOLVE,
PK_ROLE_ENUM_SEARCH_DETAILS,
PK_ROLE_ENUM_SEARCH_FILE,
PK_ROLE_ENUM_SEARCH_GROUP,
PK_ROLE_ENUM_SEARCH_NAME,
PK_ROLE_ENUM_UPDATE_PACKAGES,
PK_ROLE_ENUM_GET_REPO_LIST,
PK_ROLE_ENUM_REPO_ENABLE,
PK_ROLE_ENUM_REPAIR_SYSTEM,
PK_ROLE_ENUM_REPO_REMOVE,
-1);
// only add GetDistroUpgrades if the binary is present
if (g_file_test(PREUPGRADE_BINARY, G_FILE_TEST_EXISTS)) {
pk_bitfield_add(roles, PK_ROLE_ENUM_GET_DISTRO_UPGRADES);
}
// only add GetDistroUpgrades if the binary is present
if (g_file_test(GDEBI_BINARY, G_FILE_TEST_EXISTS)) {
pk_bitfield_add(roles, PK_ROLE_ENUM_INSTALL_FILES);
}
return roles;
}
/**
* pk_backend_get_groups:
*/
PkBitfield
pk_backend_get_groups (PkBackend *backend)
{
return pk_bitfield_from_enums (
PK_GROUP_ENUM_ACCESSIBILITY,
PK_GROUP_ENUM_ACCESSORIES,
PK_GROUP_ENUM_ADMIN_TOOLS,
//PK_GROUP_ENUM_COMMUNICATION,
PK_GROUP_ENUM_DESKTOP_GNOME,
PK_GROUP_ENUM_DESKTOP_KDE,
PK_GROUP_ENUM_DESKTOP_OTHER,
PK_GROUP_ENUM_DESKTOP_XFCE,
//PK_GROUP_ENUM_EDUCATION,
PK_GROUP_ENUM_FONTS,
//PK_GROUP_ENUM_GAMES,
PK_GROUP_ENUM_GRAPHICS,
//PK_GROUP_ENUM_INTERNET,
//PK_GROUP_ENUM_LEGACY,
PK_GROUP_ENUM_LOCALIZATION,
//PK_GROUP_ENUM_MAPS,
PK_GROUP_ENUM_MULTIMEDIA,
PK_GROUP_ENUM_NETWORK,
PK_GROUP_ENUM_OFFICE,
PK_GROUP_ENUM_OTHER,
//PK_GROUP_ENUM_POWER_MANAGEMENT,
PK_GROUP_ENUM_PROGRAMMING,
//PK_GROUP_ENUM_PUBLISHING,
PK_GROUP_ENUM_REPOS,
//PK_GROUP_ENUM_SECURITY,
//PK_GROUP_ENUM_SERVERS,
PK_GROUP_ENUM_SYSTEM,
//PK_GROUP_ENUM_VIRTUALIZATION,
//PK_GROUP_ENUM_SCIENCE,
//PK_GROUP_ENUM_DOCUMENTATION,
//PK_GROUP_ENUM_ELECTRONICS,
//PK_GROUP_ENUM_COLLECTIONS,
//PK_GROUP_ENUM_VENDOR,
//PK_GROUP_ENUM_NEWEST,
//PK_GROUP_ENUM_UNKNOWN,
-1);
}
gboolean
gs_plugin_url_to_app (GsPlugin *plugin,
GsAppList *list,
const gchar *url,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autofree gchar *scheme = NULL;
g_autofree gchar *path = NULL;
const gchar *id = NULL;
const gchar * const *id_like = NULL;
g_auto(GStrv) package_ids = NULL;
g_autoptr(PkResults) results = NULL;
g_autoptr(GsApp) app = NULL;
g_autoptr(GsOsRelease) os_release = NULL;
g_autoptr(GPtrArray) packages = NULL;
g_autoptr(GPtrArray) details = NULL;
g_autoptr(GsPackagekitHelper) helper = gs_packagekit_helper_new (plugin);
path = gs_utils_get_url_path (url);
/* only do this for apt:// on debian or debian-like distros */
os_release = gs_os_release_new (error);
if (os_release == NULL) {
g_prefix_error (error, "failed to determine OS information:");
return FALSE;
} else {
id = gs_os_release_get_id (os_release);
id_like = gs_os_release_get_id_like (os_release);
scheme = gs_utils_get_url_scheme (url);
if (!(g_strcmp0 (scheme, "apt") == 0 &&
(g_strcmp0 (id, "debian") == 0 ||
g_strv_contains (id_like, "debian")))) {
return TRUE;
}
}
app = gs_app_new (NULL);
gs_plugin_packagekit_set_packaging_format (plugin, app);
gs_app_add_source (app, path);
gs_app_set_kind (app, AS_APP_KIND_GENERIC);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_PACKAGE);
package_ids = g_new0 (gchar *, 2);
package_ids[0] = g_strdup (path);
g_mutex_lock (&priv->client_mutex);
results = pk_client_resolve (priv->client,
pk_bitfield_from_enums (PK_FILTER_ENUM_NEWEST, PK_FILTER_ENUM_ARCH, -1),
package_ids,
cancellable,
gs_packagekit_helper_cb, helper,
error);
g_mutex_unlock (&priv->client_mutex);
if (!gs_plugin_packagekit_results_valid (results, error)) {
g_prefix_error (error, "failed to resolve package_ids: ");
return FALSE;
}
/* get results */
packages = pk_results_get_package_array (results);
details = pk_results_get_details_array (results);
if (packages->len >= 1) {
if (gs_app_get_local_file (app) != NULL)
return TRUE;
gs_plugin_packagekit_resolve_packages_app (plugin, packages, app);
gs_plugin_packagekit_refine_details_app (plugin, details, app);
gs_app_list_add (list, app);
} else {
g_warning ("no results returned");
}
return TRUE;
}
void
pk_bitfield_test (gpointer user_data)
{
EggTest *test = (EggTest *) user_data;
gchar *text;
PkBitfield filter;
gint value;
PkBitfield values;
if (!egg_test_start (test, "PkBitfield"))
return;
/************************************************************/
egg_test_title (test, "check we can convert filter bitfield to text (none)");
text = pk_filter_bitfield_to_text (pk_bitfield_value (PK_FILTER_ENUM_NONE));
if (g_strcmp0 (text, "none") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "text was %s", text);
g_free (text);
/************************************************************/
egg_test_title (test, "check we can invert a bit 1 -> 0");
values = pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT) | pk_bitfield_value (PK_FILTER_ENUM_NOT_NEWEST);
pk_bitfield_invert (values, PK_FILTER_ENUM_NOT_DEVELOPMENT);
if (values == pk_bitfield_value (PK_FILTER_ENUM_NOT_NEWEST))
egg_test_success (test, NULL);
else
egg_test_failed (test, "values were %" PK_BITFIELD_FORMAT, values);
/************************************************************/
egg_test_title (test, "check we can invert a bit 0 -> 1");
values = 0;
pk_bitfield_invert (values, PK_FILTER_ENUM_NOT_DEVELOPMENT);
if (values == pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT))
egg_test_success (test, NULL);
else
egg_test_failed (test, "values were %" PK_BITFIELD_FORMAT, values);
/************************************************************/
egg_test_title (test, "check we can convert filter bitfield to text (single)");
text = pk_filter_bitfield_to_text (pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT));
if (g_strcmp0 (text, "~devel") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "text was %s", text);
g_free (text);
/************************************************************/
egg_test_title (test, "check we can convert filter bitfield to text (plural)");
text = pk_filter_bitfield_to_text (pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT) |
pk_bitfield_value (PK_FILTER_ENUM_GUI) |
pk_bitfield_value (PK_FILTER_ENUM_NEWEST));
if (g_strcmp0 (text, "~devel;gui;newest") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "text was %s", text);
g_free (text);
/************************************************************/
egg_test_title (test, "check we can convert filter text to bitfield (none)");
filter = pk_filter_bitfield_from_text ("none");
if (filter == pk_bitfield_value (PK_FILTER_ENUM_NONE))
egg_test_success (test, NULL);
else
egg_test_failed (test, "filter was %" PK_BITFIELD_FORMAT, filter);
/************************************************************/
egg_test_title (test, "check we can convert filter text to bitfield (single)");
filter = pk_filter_bitfield_from_text ("~devel");
if (filter == pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT))
egg_test_success (test, NULL);
else
egg_test_failed (test, "filter was %" PK_BITFIELD_FORMAT, filter);
/************************************************************/
egg_test_title (test, "check we can convert filter text to bitfield (plural)");
filter = pk_filter_bitfield_from_text ("~devel;gui;newest");
if (filter == (pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT) |
pk_bitfield_value (PK_FILTER_ENUM_GUI) |
pk_bitfield_value (PK_FILTER_ENUM_NEWEST)))
egg_test_success (test, NULL);
else
egg_test_failed (test, "filter was %" PK_BITFIELD_FORMAT, filter);
/************************************************************/
egg_test_title (test, "check we can add / remove bitfield");
filter = pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT) |
pk_bitfield_value (PK_FILTER_ENUM_GUI) |
pk_bitfield_value (PK_FILTER_ENUM_NEWEST);
pk_bitfield_add (filter, PK_FILTER_ENUM_NOT_FREE);
pk_bitfield_remove (filter, PK_FILTER_ENUM_NOT_DEVELOPMENT);
text = pk_filter_bitfield_to_text (filter);
if (g_strcmp0 (text, "gui;~free;newest") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "text was %s", text);
g_free (text);
/************************************************************/
egg_test_title (test, "check we can test enum presence");
filter = pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT) |
pk_bitfield_value (PK_FILTER_ENUM_GUI) |
pk_bitfield_value (PK_FILTER_ENUM_NEWEST);
if (pk_bitfield_contain (filter, PK_FILTER_ENUM_NOT_DEVELOPMENT))
egg_test_success (test, NULL);
else
egg_test_failed (test, "wrong boolean");
/************************************************************/
egg_test_title (test, "check we can test enum false-presence");
if (!pk_bitfield_contain (filter, PK_FILTER_ENUM_FREE))
egg_test_success (test, NULL);
else
egg_test_failed (test, "wrong boolean");
/************************************************************/
egg_test_title (test, "check we can add / remove bitfield to nothing");
filter = pk_bitfield_value (PK_FILTER_ENUM_NOT_DEVELOPMENT);
pk_bitfield_remove (filter, PK_FILTER_ENUM_NOT_DEVELOPMENT);
text = pk_filter_bitfield_to_text (filter);
if (g_strcmp0 (text, "none") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "text was %s", text);
g_free (text);
/************************************************************/
egg_test_title (test, "role bitfield from enums (unknown)");
values = pk_bitfield_from_enums (PK_ROLE_ENUM_UNKNOWN, -1);
if (values == pk_bitfield_value (PK_ROLE_ENUM_UNKNOWN))
egg_test_success (test, NULL);
else
egg_test_failed (test, "returned bitfield %" PK_BITFIELD_FORMAT, values);
/************************************************************/
egg_test_title (test, "role bitfield from enums (random)");
values = pk_bitfield_from_enums (PK_ROLE_ENUM_SEARCH_GROUP, PK_ROLE_ENUM_SEARCH_DETAILS, -1);
if (values == (pk_bitfield_value (PK_ROLE_ENUM_SEARCH_DETAILS) |
pk_bitfield_value (PK_ROLE_ENUM_SEARCH_GROUP)))
egg_test_success (test, NULL);
else
egg_test_failed (test, "returned bitfield %" PK_BITFIELD_FORMAT, values);
/************************************************************/
egg_test_title (test, "group bitfield from enums (unknown)");
values = pk_bitfield_from_enums (PK_GROUP_ENUM_UNKNOWN, -1);
if (values == pk_bitfield_value (PK_GROUP_ENUM_UNKNOWN))
egg_test_success (test, NULL);
else
egg_test_failed (test, "returned bitfield %" PK_BITFIELD_FORMAT, values);
/************************************************************/
egg_test_title (test, "group bitfield from enums (random)");
values = pk_bitfield_from_enums (PK_GROUP_ENUM_ACCESSIBILITY, -1);
if (values == (pk_bitfield_value (PK_GROUP_ENUM_ACCESSIBILITY)))
egg_test_success (test, NULL);
else
egg_test_failed (test, "returned bitfield %" PK_BITFIELD_FORMAT, values);
/************************************************************/
egg_test_title (test, "group bitfield to text (unknown)");
values = pk_bitfield_from_enums (PK_GROUP_ENUM_UNKNOWN, -1);
text = pk_group_bitfield_to_text (values);
if (g_strcmp0 (text, "unknown") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "returned bitfield text %s (%" PK_BITFIELD_FORMAT ")", text, values);
g_free (text);
/************************************************************/
egg_test_title (test, "group bitfield to text (first and last)");
values = pk_bitfield_from_enums (PK_GROUP_ENUM_ACCESSIBILITY, PK_GROUP_ENUM_UNKNOWN, -1);
text = pk_group_bitfield_to_text (values);
if (g_strcmp0 (text, "unknown;accessibility") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "returned bitfield text %s (%" PK_BITFIELD_FORMAT ")", text, values);
g_free (text);
/************************************************************/
egg_test_title (test, "group bitfield to text (random)");
values = pk_bitfield_from_enums (PK_GROUP_ENUM_UNKNOWN, PK_GROUP_ENUM_REPOS, -1);
text = pk_group_bitfield_to_text (values);
if (g_strcmp0 (text, "unknown;repos") == 0)
egg_test_success (test, NULL);
else
egg_test_failed (test, "returned bitfield text %s (%" PK_BITFIELD_FORMAT ")", text, values);
g_free (text);
/************************************************************/
egg_test_title (test, "priority check missing");
values = pk_bitfield_value (PK_ROLE_ENUM_SEARCH_DETAILS) |
pk_bitfield_value (PK_ROLE_ENUM_SEARCH_GROUP);
value = pk_bitfield_contain_priority (values, PK_ROLE_ENUM_SEARCH_FILE, -1);
if (value == -1)
egg_test_success (test, NULL);
else
egg_test_failed (test, "returned priority %i when should be missing", value);
/************************************************************/
egg_test_title (test, "priority check first");
value = pk_bitfield_contain_priority (values, PK_ROLE_ENUM_SEARCH_GROUP, -1);
if (value == PK_ROLE_ENUM_SEARCH_GROUP)
egg_test_success (test, NULL);
else
egg_test_failed (test, "returned wrong value; %i", value);
/************************************************************/
egg_test_title (test, "priority check second, correct");
value = pk_bitfield_contain_priority (values, PK_ROLE_ENUM_SEARCH_FILE, PK_ROLE_ENUM_SEARCH_GROUP, -1);
if (value == PK_ROLE_ENUM_SEARCH_GROUP)
egg_test_success (test, NULL);
else
egg_test_failed (test, "returned wrong value; %i", value);
egg_test_end (test);
}
