END_TEST
START_TEST(test_goal_install_selector_err)
{
// Test that using the hy_goal_*_selector() methods returns an error for
// selectors invalid in this context.
HySelector sltr;
HyGoal goal = hy_goal_create(test_globals.sack);
sltr = hy_selector_create(test_globals.sack);
hy_selector_set(sltr, HY_PKG_ARCH, HY_EQ, "i586");
fail_unless(hy_goal_install_selector(goal, sltr));
fail_unless(hy_get_errno() == HY_E_SELECTOR);
hy_selector_free(sltr);
sltr = hy_selector_create(test_globals.sack);
hy_selector_set(sltr, HY_PKG_NAME, HY_GT, "semolina");
fail_unless(hy_get_errno() == HY_E_SELECTOR);
hy_selector_free(sltr);
sltr = hy_selector_create(test_globals.sack);
fail_unless(hy_selector_set(sltr, HY_REPO_NAME, HY_EQ, HY_SYSTEM_REPO_NAME));
hy_selector_free(sltr);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_sack_create)
{
fail_unless(hy_get_errno() == 0);
HySack sack = hy_sack_create(test_globals.tmpdir, NULL, NULL,
HY_MAKE_CACHE_DIR);
fail_if(sack == NULL, NULL);
fail_if(sack_pool(sack) == NULL, NULL);
hy_sack_free(sack);
sack = hy_sack_create(test_globals.tmpdir, "", NULL, HY_MAKE_CACHE_DIR);
fail_unless(sack == NULL);
fail_unless(hy_get_errno() == HY_E_ARCH);
}
static int
parse_cpu_flags(int *flags, const char *section)
{
char *cpuinfo = read_whole_file("/proc/cpuinfo");
if (cpuinfo == NULL)
return hy_get_errno();
char *features = strstr(cpuinfo, section);
if (features != NULL) {
char *saveptr;
features = strtok_r(features, "\n", &saveptr);
char *tok = strtok_r(features, " ", &saveptr);
while (tok) {
if (!strcmp(tok, "neon"))
*flags |= ARM_NEON;
else if (!strcmp(tok, "vfpv3"))
*flags |= ARM_VFP3;
else if (!strcmp(tok, "vfp"))
*flags |= ARM_VFP;
tok = strtok_r(NULL, " ", &saveptr);
}
}
solv_free(cpuinfo);
return 0;
}
END_TEST
START_TEST(test_goal_verify)
{
HySack sack = test_globals.sack;
HyGoal goal = hy_goal_create(sack);
fail_unless(hy_goal_run_flags(goal, HY_VERIFY));
fail_unless(hy_goal_list_installs(goal) == NULL);
fail_unless(hy_get_errno() == HY_E_NO_SOLUTION);
fail_unless(hy_goal_count_problems(goal) == 2);
char *expected;
char *problem;
problem = hy_goal_describe_problem(goal, 0);
expected = "nothing provides missing-dep needed by missing-1-0.x86_64";
fail_if(strncmp(problem, expected, strlen(expected)));
hy_free(problem);
problem = hy_goal_describe_problem(goal, 1);
expected = "package conflict-1-0.x86_64 conflicts with ok provided by ok-1-0.x86_64";
fail_if(strncmp(problem, expected, strlen(expected)));
hy_free(problem);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_list_err)
{
HyGoal goal = hy_goal_create(test_globals.sack);
fail_unless(hy_goal_list_installs(goal) == NULL);
fail_unless(hy_get_errno() == HY_E_OP);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_load_repo_err)
{
HySack sack = hy_sack_create(test_globals.tmpdir, NULL, NULL, NULL,
HY_MAKE_CACHE_DIR);
HyRepo repo = hy_repo_create("crabalocker");
hy_repo_set_string(repo, HY_REPO_MD_FN, "/non/existing");
fail_unless(hy_sack_load_repo(sack, repo, 0) == HY_E_FAILED);
fail_unless(hy_get_errno() == HY_E_IO);
hy_repo_free(repo);
hy_sack_free(sack);
}
static PyObject *
op_ret2exc(int ret)
{
if (!ret)
Py_RETURN_NONE;
switch (hy_get_errno()) {
case HY_E_SELECTOR:
PyErr_SetString(HyExc_Value,
"Ill-formed Selector used for the operation.");
return NULL;
case HY_E_ARCH:
PyErr_SetString(HyExc_Arch, "Used arch is unknown.");
return NULL;
case HY_E_VALIDATION:
PyErr_SetString(HyExc_Validation, "The validation check has failed.");
return NULL;
default:
PyErr_SetString(HyExc_Exception, "Goal operation failed.");
return NULL;
}
}
END_TEST
START_TEST(test_goal_describe_problem)
{
HySack sack = test_globals.sack;
HyPackage pkg = get_latest_pkg(sack, "hello");
HyGoal goal = hy_goal_create(sack);
hy_goal_install(goal, pkg);
fail_unless(hy_goal_run(goal));
fail_unless(hy_goal_list_installs(goal) == NULL);
fail_unless(hy_get_errno() == HY_E_NO_SOLUTION);
fail_unless(hy_goal_count_problems(goal) > 0);
char *problem = hy_goal_describe_problem(goal, 0);
const char *expected = "nothing provides goodbye";
fail_if(strncmp(problem, expected, strlen(expected)));
hy_free(problem);
hy_package_free(pkg);
hy_goal_free(goal);
}
static PyObject *
list_generic(_GoalObject *self, HyPackageList (*func)(HyGoal))
{
HyPackageList plist = func(self->goal);
PyObject *list;
if (!plist) {
switch (hy_get_errno()) {
case HY_E_OP:
PyErr_SetString(HyExc_Value, "Goal has not been run yet.");
break;
case HY_E_NO_SOLUTION:
PyErr_SetString(HyExc_Runtime, "Goal has not find a solution.");
break;
default:
assert(0);
}
return NULL;
}
list = packagelist_to_pylist(plist, self->sack);
hy_packagelist_free(plist);
return list;
}
/**
* hif_sack_add_source:
*/
gboolean
hif_sack_add_source (HySack sack,
HifSource *src,
guint permissible_cache_age,
HifSackAddFlags flags,
HifState *state,
GError **error)
{
gboolean ret = TRUE;
GError *error_local = NULL;
gint rc;
HifState *state_local;
int flags_hy = HY_BUILD_CACHE;
/* set state */
ret = hif_state_set_steps (state, error,
5, /* check repo */
95, /* load solv */
-1);
if (!ret)
return FALSE;
/* check repo */
state_local = hif_state_get_child (state);
ret = hif_source_check (src,
permissible_cache_age,
state_local,
&error_local);
if (!ret) {
g_debug ("failed to check, attempting update: %s",
error_local->message);
g_clear_error (&error_local);
hif_state_reset (state_local);
ret = hif_source_update (src,
HIF_SOURCE_UPDATE_FLAG_FORCE,
state_local,
&error_local);
if (!ret) {
if (g_error_matches (error_local,
HIF_ERROR,
HIF_ERROR_CANNOT_FETCH_SOURCE)) {
g_warning ("Skipping refresh of %s: %s",
hif_source_get_id (src),
error_local->message);
g_error_free (error_local);
return TRUE;
}
g_propagate_error (error, error_local);
return FALSE;
}
}
/* done */
if (!hif_state_done (state, error))
return FALSE;
/* only load what's required */
if ((flags & HIF_SACK_ADD_FLAG_FILELISTS) > 0)
flags_hy |= HY_LOAD_FILELISTS;
if ((flags & HIF_SACK_ADD_FLAG_UPDATEINFO) > 0)
flags_hy |= HY_LOAD_UPDATEINFO;
/* load solv */
g_debug ("Loading repo %s", hif_source_get_id (src));
hif_state_action_start (state, HIF_STATE_ACTION_LOADING_CACHE, NULL);
rc = hy_sack_load_yum_repo (sack, hif_source_get_repo (src), flags_hy);
if (rc == HY_E_FAILED)
rc = hy_get_errno ();
if (!hif_rc_to_gerror (rc, error)) {
g_prefix_error (error, "Failed to load repo %s: ",
hif_source_get_id (src));
return FALSE;
}
/* done */
return hif_state_done (state, error);
}
uint32_t
TDNFTransAddDowngradePkgs(
PTDNFRPMTS pTS,
PTDNF pTdnf
)
{
uint32_t dwError = 0;
int i = 0;
HyPackage hPkg = NULL;
HyPackageList hPkgList = NULL;
HyPackage hInstalledPkg = NULL;
hPkgList = hy_goal_list_downgrades(pTdnf->hGoal);
if(!hPkgList)
{
dwError = ERROR_TDNF_NO_DATA;
BAIL_ON_TDNF_ERROR(dwError);
}
for(i = 0; (hPkg = hy_packagelist_get(hPkgList, i)) != NULL; ++i)
{
dwError = TDNFTransAddInstallPkg(pTS, pTdnf, hPkg, 0);
BAIL_ON_TDNF_ERROR(dwError);
//Downgrade is a removal of existing and installing old.
const char* pszName = NULL;
pszName = hy_package_get_name(hPkg);
if(IsNullOrEmptyString(pszName))
{
dwError = hy_get_errno();
if(dwError == 0)
{
dwError = HY_E_FAILED;
}
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
}
dwError = TDNFFindInstalledPkgByName(pTdnf->hSack, pszName, &hInstalledPkg);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFTransAddErasePkg(pTS, hInstalledPkg);
BAIL_ON_TDNF_ERROR(dwError);
hy_package_free(hInstalledPkg);
hInstalledPkg = NULL;
}
cleanup:
if(hInstalledPkg)
{
hy_package_free(hInstalledPkg);
}
if(hPkgList)
{
hy_packagelist_free(hPkgList);
}
return dwError;
error:
if(dwError == ERROR_TDNF_NO_DATA)
{
dwError = 0;
}
goto cleanup;
}
