586 lines
27 KiB
C++
586 lines
27 KiB
C++
/* vim: set sw=4 sts=4 et foldmethod=syntax : */
|
|
|
|
/*
|
|
* Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011 Ciaran McCreesh
|
|
*
|
|
* This file is part of the Paludis package manager. Paludis is free software;
|
|
* you can redistribute it and/or modify it under the terms of the GNU General
|
|
* Public License version 2, as published by the Free Software Foundation.
|
|
*
|
|
* Paludis is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* this program; if not, write to the Free Software Foundation, Inc., 59 Temple
|
|
* Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <paludis/dep_spec.hh>
|
|
#include <paludis/user_dep_spec.hh>
|
|
#include <paludis/match_package.hh>
|
|
#include <paludis/version_requirements.hh>
|
|
|
|
#include <paludis/util/clone-impl.hh>
|
|
#include <paludis/util/sequence.hh>
|
|
#include <paludis/util/wrapped_forward_iterator.hh>
|
|
#include <paludis/util/iterator_funcs.hh>
|
|
#include <paludis/util/options.hh>
|
|
#include <paludis/util/indirect_iterator-impl.hh>
|
|
#include <paludis/util/make_named_values.hh>
|
|
#include <paludis/util/stringify.hh>
|
|
#include <paludis/util/join.hh>
|
|
|
|
#include <paludis/environments/test/test_environment.hh>
|
|
|
|
#include <paludis/repositories/fake/fake_repository.hh>
|
|
#include <paludis/repositories/fake/fake_installed_repository.hh>
|
|
#include <paludis/repositories/fake/fake_package_id.hh>
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
using namespace paludis;
|
|
|
|
namespace
|
|
{
|
|
std::string dump_version_requirement(const VersionRequirement & v)
|
|
{
|
|
return stringify(v.version_operator()) + stringify(v.version_spec());
|
|
}
|
|
|
|
class UserDepSpecTest :
|
|
public testing::Test
|
|
{
|
|
protected:
|
|
void check_spec(
|
|
const PackageDepSpec & spec,
|
|
const std::string & package,
|
|
const std::string & category_name_part,
|
|
const std::string & package_name_part,
|
|
const std::string & version_requirements,
|
|
const std::string & version_requirement_mode,
|
|
const std::string & slot_requirement,
|
|
const std::string & in_repository,
|
|
const std::string & from_repository,
|
|
const std::string & additional_requirement,
|
|
const std::string & installed_at_path = "",
|
|
const std::string & installable_to_path_f = "",
|
|
const bool installable_to_path_s = false
|
|
);
|
|
};
|
|
}
|
|
|
|
void
|
|
UserDepSpecTest::check_spec(
|
|
const PackageDepSpec & spec,
|
|
const std::string & package,
|
|
const std::string & category_name_part,
|
|
const std::string & package_name_part,
|
|
const std::string & version_requirements,
|
|
const std::string & version_requirement_mode,
|
|
const std::string & slot_requirement,
|
|
const std::string & in_repository,
|
|
const std::string & from_repository,
|
|
const std::string & additional_requirement,
|
|
const std::string & installed_at_path,
|
|
const std::string & installable_to_path_f,
|
|
const bool installable_to_path_s)
|
|
{
|
|
|
|
if (package.empty())
|
|
EXPECT_TRUE(! spec.package_ptr());
|
|
else
|
|
{
|
|
EXPECT_TRUE(bool(spec.package_ptr()));
|
|
EXPECT_EQ(package, stringify(*spec.package_ptr()));
|
|
}
|
|
|
|
if (category_name_part.empty())
|
|
EXPECT_TRUE(! spec.category_name_part_ptr());
|
|
else
|
|
{
|
|
EXPECT_TRUE(bool(spec.category_name_part_ptr()));
|
|
EXPECT_EQ(category_name_part, stringify(*spec.category_name_part_ptr()));
|
|
}
|
|
|
|
if (package_name_part.empty())
|
|
EXPECT_TRUE(! spec.package_name_part_ptr());
|
|
else
|
|
{
|
|
EXPECT_TRUE(bool(spec.package_name_part_ptr()));
|
|
EXPECT_EQ(package_name_part, stringify(*spec.package_name_part_ptr()));
|
|
}
|
|
|
|
if (! version_requirement_mode.empty())
|
|
EXPECT_EQ(version_requirement_mode, stringify(spec.version_requirements_mode()));
|
|
|
|
if (version_requirements.empty())
|
|
EXPECT_TRUE((! spec.version_requirements_ptr()) || spec.version_requirements_ptr()->empty());
|
|
else
|
|
{
|
|
EXPECT_TRUE(bool(spec.version_requirements_ptr()));
|
|
EXPECT_EQ(version_requirements, stringify(join(
|
|
spec.version_requirements_ptr()->begin(), spec.version_requirements_ptr()->end(), ", ", &dump_version_requirement)));
|
|
}
|
|
|
|
if (slot_requirement.empty())
|
|
EXPECT_TRUE(! spec.slot_requirement_ptr());
|
|
else
|
|
{
|
|
EXPECT_TRUE(bool(spec.slot_requirement_ptr()));
|
|
EXPECT_EQ(slot_requirement, stringify(*spec.slot_requirement_ptr()));
|
|
}
|
|
|
|
if (from_repository.empty())
|
|
EXPECT_TRUE(! spec.from_repository_ptr());
|
|
else
|
|
{
|
|
EXPECT_TRUE(bool(spec.from_repository_ptr()));
|
|
EXPECT_EQ(from_repository, stringify(*spec.from_repository_ptr()));
|
|
}
|
|
|
|
if (in_repository.empty())
|
|
EXPECT_TRUE(! spec.in_repository_ptr());
|
|
else
|
|
{
|
|
EXPECT_TRUE(bool(spec.in_repository_ptr()));
|
|
EXPECT_EQ(in_repository, stringify(*spec.in_repository_ptr()));
|
|
}
|
|
|
|
if (additional_requirement.empty())
|
|
EXPECT_TRUE((! spec.additional_requirements_ptr()) || spec.additional_requirements_ptr()->empty());
|
|
else
|
|
{
|
|
EXPECT_TRUE(bool(spec.additional_requirements_ptr()));
|
|
EXPECT_EQ(additional_requirement, stringify(join(
|
|
indirect_iterator(spec.additional_requirements_ptr()->begin()),
|
|
indirect_iterator(spec.additional_requirements_ptr()->end()), ", ")));
|
|
}
|
|
|
|
if (installed_at_path.empty())
|
|
EXPECT_TRUE(! spec.installed_at_path_ptr());
|
|
else
|
|
{
|
|
EXPECT_TRUE(bool(spec.installed_at_path_ptr()));
|
|
EXPECT_EQ(installed_at_path, stringify(*spec.installed_at_path_ptr()));
|
|
}
|
|
|
|
if (installable_to_path_f.empty())
|
|
EXPECT_TRUE(! spec.installable_to_path_ptr());
|
|
else
|
|
{
|
|
EXPECT_TRUE(bool(spec.installable_to_path_ptr()));
|
|
EXPECT_EQ(installable_to_path_f, stringify(spec.installable_to_path_ptr()->path()));
|
|
EXPECT_EQ(installable_to_path_s, spec.installable_to_path_ptr()->include_masked());
|
|
}
|
|
|
|
}
|
|
|
|
TEST_F(UserDepSpecTest, Parsing)
|
|
{
|
|
TestEnvironment env;
|
|
|
|
PackageDepSpec a(parse_user_package_dep_spec("foo/bar", &env, { }));
|
|
check_spec(a, "foo/bar", "", "", "", "", "", "", "", "");
|
|
|
|
PackageDepSpec b(parse_user_package_dep_spec(">=foo/bar-1.2.3", &env, { }));
|
|
check_spec(b, "foo/bar", "", "", ">=1.2.3", "", "", "", "", "");
|
|
|
|
PackageDepSpec c(parse_user_package_dep_spec("foo/bar:baz", &env, { }));
|
|
check_spec(c, "foo/bar", "", "", "", "", ":baz", "", "", "");
|
|
|
|
PackageDepSpec d(parse_user_package_dep_spec("=foo/bar-1.2*:1.2.1", &env, { }));
|
|
check_spec(d, "foo/bar", "", "", "=*1.2", "", ":1.2.1", "", "", "");
|
|
|
|
PackageDepSpec e(parse_user_package_dep_spec("foo/bar:1.2.1", &env, { }));
|
|
check_spec(e, "foo/bar", "", "", "", "", ":1.2.1", "", "", "");
|
|
|
|
PackageDepSpec f(parse_user_package_dep_spec("foo/bar:0", &env, { }));
|
|
check_spec(f, "foo/bar", "", "", "", "", ":0", "", "", "");
|
|
|
|
PackageDepSpec g(parse_user_package_dep_spec("foo/bar-100dpi", &env, { }));
|
|
check_spec(g, "foo/bar-100dpi", "", "", "", "", "", "", "", "");
|
|
|
|
PackageDepSpec h(parse_user_package_dep_spec(">=foo/bar-100dpi-1.23", &env, { }));
|
|
check_spec(h, "foo/bar-100dpi", "", "", ">=1.23", "", "", "", "", "");
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("", &env, { }), PackageDepSpecError);
|
|
EXPECT_THROW(parse_user_package_dep_spec("=foo/bar-1.2[=1.3]", &env, { }), PackageDepSpecError);
|
|
|
|
PackageDepSpec i(parse_user_package_dep_spec("foo/bar[one][-two]", &env, { }));
|
|
check_spec(i, "foo/bar", "", "", "", "", "", "", "", "[-two], [one]");
|
|
|
|
PackageDepSpec j(parse_user_package_dep_spec("=foo/bar-scm-r3", &env, { }));
|
|
check_spec(j, "foo/bar", "", "", "=scm-r3", "", "", "", "", "");
|
|
|
|
PackageDepSpec k(parse_user_package_dep_spec("=foo/bar-scm", &env, { }));
|
|
check_spec(k, "foo/bar", "", "", "=scm", "", "", "", "", "");
|
|
|
|
PackageDepSpec l(parse_user_package_dep_spec("foo/bar[one][-two][>=1.2&<2.0]", &env, { }));
|
|
check_spec(l, "foo/bar", "", "", ">=1.2, <2.0", "and", "", "", "", "[-two], [one]");
|
|
|
|
PackageDepSpec m(parse_user_package_dep_spec("foo/bar[=1.2|=1.3*|~1.4]", &env, { }));
|
|
check_spec(m, "foo/bar", "", "", "=1.2, =*1.3, ~1.4", "or", "", "", "", "");
|
|
|
|
PackageDepSpec n(parse_user_package_dep_spec("=foo/bar--1.2.3", &env, { }));
|
|
check_spec(n, "foo/bar-", "", "", "=1.2.3", "", "", "", "", "");
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("=foo/bar--", &env, { }), PackageDepSpecError);
|
|
|
|
PackageDepSpec o(parse_user_package_dep_spec("=foo/bar---1.2.3", &env, { }));
|
|
check_spec(o, "foo/bar--", "", "", "=1.2.3", "", "", "", "", "");
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("=foo/bar[.foo]", &env, { }), PackageDepSpecError);
|
|
|
|
PackageDepSpec p(parse_user_package_dep_spec("foo/bar[.key=value]", &env, { }));
|
|
check_spec(p, "foo/bar", "", "", "", "", "", "", "", "[.key=value]");
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("=foo/bar[.foo?q]", &env, { }), PackageDepSpecError);
|
|
|
|
PackageDepSpec q(parse_user_package_dep_spec("foo/bar[.foo?]", &env, { }));
|
|
check_spec(q, "foo/bar", "", "", "", "", "", "", "", "[.foo?]");
|
|
|
|
PackageDepSpec r(parse_user_package_dep_spec("foo/bar[.$short_description=value]", &env, { }));
|
|
check_spec(r, "foo/bar", "", "", "", "", "", "", "", "[.$short_description=value]");
|
|
|
|
PackageDepSpec s(parse_user_package_dep_spec("foo/bar[.key!=value]", &env, { }));
|
|
check_spec(s, "foo/bar", "", "", "", "", "", "", "", "[.key!=value]");
|
|
|
|
PackageDepSpec t(parse_user_package_dep_spec("foo/bar[.$short_description!=value]", &env, { }));
|
|
check_spec(t, "foo/bar", "", "", "", "", "", "", "", "[.$short_description!=value]");
|
|
}
|
|
|
|
TEST_F(UserDepSpecTest, Unspecified)
|
|
{
|
|
TestEnvironment env;
|
|
|
|
PackageDepSpec a(parse_user_package_dep_spec("*/*", &env, { updso_allow_wildcards }));
|
|
check_spec(a, "", "", "", "", "", "", "", "", "");
|
|
|
|
PackageDepSpec b(parse_user_package_dep_spec("foo/*", &env, { updso_allow_wildcards }));
|
|
check_spec(b, "", "foo", "", "", "", "", "", "", "");
|
|
|
|
PackageDepSpec c(parse_user_package_dep_spec("*/foo", &env, { updso_allow_wildcards }));
|
|
check_spec(c, "", "", "foo", "", "", "", "", "", "");
|
|
|
|
PackageDepSpec d(parse_user_package_dep_spec("~*/*-0", &env, { updso_allow_wildcards }));
|
|
check_spec(d, "", "", "", "~0", "", "", "", "", "");
|
|
|
|
PackageDepSpec e(parse_user_package_dep_spec(">=foo/*-1.23", &env, { updso_allow_wildcards }));
|
|
check_spec(e, "", "foo", "", ">=1.23", "", "", "", "", "");
|
|
|
|
PackageDepSpec f(parse_user_package_dep_spec("=*/foo-1*", &env, { updso_allow_wildcards }));
|
|
check_spec(f, "", "", "foo", "=*1", "", "", "", "", "");
|
|
}
|
|
|
|
TEST_F(UserDepSpecTest, Repos)
|
|
{
|
|
TestEnvironment env;
|
|
|
|
PackageDepSpec a(parse_user_package_dep_spec("cat/pkg::repo",
|
|
&env, { updso_allow_wildcards }));
|
|
check_spec(a, "cat/pkg", "", "", "", "", "", "repo", "", "");
|
|
|
|
PackageDepSpec b(parse_user_package_dep_spec("cat/pkg::->repo",
|
|
&env, { updso_allow_wildcards }));
|
|
check_spec(b, "cat/pkg", "", "", "", "", "", "repo", "", "");
|
|
|
|
PackageDepSpec c(parse_user_package_dep_spec("cat/pkg::repo->",
|
|
&env, { updso_allow_wildcards }));
|
|
check_spec(c, "cat/pkg", "", "", "", "", "", "", "repo", "");
|
|
|
|
PackageDepSpec d(parse_user_package_dep_spec("cat/pkg::r1->r2",
|
|
&env, { updso_allow_wildcards }));
|
|
check_spec(d, "cat/pkg", "", "", "", "", "", "r2", "r1", "");
|
|
|
|
PackageDepSpec e(parse_user_package_dep_spec("cat/pkg::/",
|
|
&env, { updso_allow_wildcards }));
|
|
check_spec(e, "cat/pkg", "", "", "", "", "", "", "", "", "/");
|
|
|
|
PackageDepSpec f(parse_user_package_dep_spec("cat/pkg::/path",
|
|
&env, { updso_allow_wildcards }));
|
|
check_spec(f, "cat/pkg", "", "", "", "", "", "", "", "", "/path");
|
|
|
|
PackageDepSpec g(parse_user_package_dep_spec("cat/pkg::/?",
|
|
&env, { updso_allow_wildcards }));
|
|
check_spec(g, "cat/pkg", "", "", "", "", "", "", "", "", "", "/", false);
|
|
|
|
PackageDepSpec h(parse_user_package_dep_spec("cat/pkg::/path?",
|
|
&env, { updso_allow_wildcards }));
|
|
check_spec(h, "cat/pkg", "", "", "", "", "", "", "", "", "", "/path", false);
|
|
|
|
PackageDepSpec i(parse_user_package_dep_spec("cat/pkg::/??",
|
|
&env, { updso_allow_wildcards }));
|
|
check_spec(i, "cat/pkg", "", "", "", "", "", "", "", "", "", "/", true);
|
|
|
|
PackageDepSpec j(parse_user_package_dep_spec("cat/pkg::/path??",
|
|
&env, { updso_allow_wildcards }));
|
|
check_spec(j, "cat/pkg", "", "", "", "", "", "", "", "", "", "/path", true);
|
|
}
|
|
|
|
TEST_F(UserDepSpecTest, Disambiguation)
|
|
{
|
|
TestEnvironment env;
|
|
std::shared_ptr<FakeRepository> fake(std::make_shared<FakeRepository>(make_named_values<FakeRepositoryParams>(
|
|
n::environment() = &env,
|
|
n::name() = RepositoryName("fake"))));
|
|
std::shared_ptr<FakeInstalledRepository> fake_inst(std::make_shared<FakeInstalledRepository>(
|
|
make_named_values<FakeInstalledRepositoryParams>(
|
|
n::environment() = &env,
|
|
n::name() = RepositoryName("fake_inst"),
|
|
n::suitable_destination() = true,
|
|
n::supports_uninstall() = true
|
|
)));
|
|
env.add_repository(1, fake);
|
|
env.add_repository(2, fake_inst);
|
|
fake->add_version("cat", "pkg1", "1");
|
|
fake->add_version("cat", "pkg2", "1");
|
|
fake->add_version("dog", "pkg2", "1");
|
|
fake->add_version("cat", "pkg3", "1");
|
|
fake_inst->add_version("dog", "pkg3", "1");
|
|
|
|
PackageDepSpec a(parse_user_package_dep_spec("pkg1", &env, { }));
|
|
check_spec(a, "cat/pkg1", "", "", "", "", "", "", "", "");
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("pkg2", &env, { }), AmbiguousPackageNameError);
|
|
PackageDepSpec b(parse_user_package_dep_spec("pkg3", &env, { }));
|
|
check_spec(b, "dog/pkg3", "", "", "", "", "", "", "", "");
|
|
|
|
PackageDepSpec c(parse_user_package_dep_spec("pkg3", &env, { }, filter::SupportsAction<InstallAction>()));
|
|
check_spec(c, "cat/pkg3", "", "", "", "", "", "", "", "");
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("pkg4", &env, { }), NoSuchPackageError);
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("pkg5", &env, { updso_no_disambiguation }), PackageDepSpecError);
|
|
|
|
PackageDepSpec d(parse_user_package_dep_spec("=pkg1-1", &env, { }));
|
|
EXPECT_EQ("=cat/pkg1-1", stringify(d));
|
|
EXPECT_THROW(parse_user_package_dep_spec("=pkg1-42", &env, { }), NoSuchPackageError);
|
|
|
|
PackageDepSpec e(parse_user_package_dep_spec("=pkg1-1:0", &env, { }));
|
|
EXPECT_EQ("=cat/pkg1-1:0", stringify(e));
|
|
EXPECT_THROW(parse_user_package_dep_spec("=pkg1-42:0", &env, { }), NoSuchPackageError);
|
|
|
|
PackageDepSpec f(parse_user_package_dep_spec("pkg1:0", &env, { }));
|
|
EXPECT_EQ("cat/pkg1:0", stringify(f));
|
|
|
|
PackageDepSpec g(parse_user_package_dep_spec("pkg1[-foo]", &env, { }));
|
|
EXPECT_EQ("cat/pkg1[-foo]", stringify(g));
|
|
EXPECT_THROW(parse_user_package_dep_spec("pkg1[foo]", &env, { }), NoSuchPackageError);
|
|
|
|
PackageDepSpec h(parse_user_package_dep_spec("pkg1[=1]", &env, { }));
|
|
EXPECT_EQ("=cat/pkg1-1", stringify(h));
|
|
EXPECT_THROW(parse_user_package_dep_spec("pkg1[=42]", &env, { }), NoSuchPackageError);
|
|
|
|
PackageDepSpec i(parse_user_package_dep_spec("pkg1::fake", &env, { }));
|
|
EXPECT_EQ("cat/pkg1::fake", stringify(i));
|
|
}
|
|
|
|
TEST(UserPackageDepSpec, Sets)
|
|
{
|
|
TestEnvironment env;
|
|
std::shared_ptr<FakeRepository> fake(std::make_shared<FakeRepository>(make_named_values<FakeRepositoryParams>(
|
|
n::environment() = &env,
|
|
n::name() = RepositoryName("fake"))));
|
|
env.add_repository(1, fake);
|
|
fake->add_version("cat", "world", "1");
|
|
fake->add_version("cat", "moon", "1");
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("world", &env, { updso_throw_if_set }), GotASetNotAPackageDepSpec);
|
|
EXPECT_THROW(parse_user_package_dep_spec("system", &env, { updso_throw_if_set }), GotASetNotAPackageDepSpec);
|
|
PackageDepSpec a(parse_user_package_dep_spec("moon", &env, { updso_throw_if_set }));
|
|
EXPECT_EQ("cat/moon", stringify(a));
|
|
EXPECT_THROW(parse_user_package_dep_spec("mars", &env, { updso_throw_if_set }), NoSuchPackageError);
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("world", &env, { updso_no_disambiguation, updso_throw_if_set }), GotASetNotAPackageDepSpec);
|
|
EXPECT_THROW(parse_user_package_dep_spec("system", &env, { updso_no_disambiguation, updso_throw_if_set }), GotASetNotAPackageDepSpec);
|
|
EXPECT_THROW(parse_user_package_dep_spec("moon", &env, { updso_no_disambiguation, updso_throw_if_set }), GotASetNotAPackageDepSpec);
|
|
EXPECT_THROW(parse_user_package_dep_spec("mars", &env, { updso_no_disambiguation, updso_throw_if_set }), GotASetNotAPackageDepSpec);
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("=world-123", &env, { updso_no_disambiguation, updso_throw_if_set }), PackageDepSpecError);
|
|
EXPECT_THROW(parse_user_package_dep_spec("world*", &env, { updso_no_disambiguation, updso_throw_if_set }), GotASetNotAPackageDepSpec);
|
|
EXPECT_THROW(parse_user_package_dep_spec("world**", &env, { updso_no_disambiguation, updso_throw_if_set }), PackageDepSpecError);
|
|
|
|
EXPECT_THROW(parse_user_package_dep_spec("system", &env, { }), NoSuchPackageError);
|
|
}
|
|
|
|
TEST_F(UserDepSpecTest, Keys)
|
|
{
|
|
TestEnvironment env;
|
|
std::shared_ptr<FakeRepository> fake(std::make_shared<FakeRepository>(make_named_values<FakeRepositoryParams>(
|
|
n::environment() = &env,
|
|
n::name() = RepositoryName("fake"))));
|
|
env.add_repository(1, fake);
|
|
|
|
std::shared_ptr<FakePackageID> pkg1(fake->add_version("cat", "pkg1", "1"));
|
|
pkg1->keywords_key()->set_from_string("~a ~b");
|
|
std::shared_ptr<FakePackageID> pkg2(fake->add_version("cat", "pkg1", "2"));
|
|
pkg2->keywords_key()->set_from_string("~a ~c");
|
|
std::shared_ptr<FakePackageID> pkg3(fake->add_version("cat", "pkg1", "3"));
|
|
pkg3->keywords_key()->set_from_string("~d");
|
|
|
|
PackageDepSpec a(parse_user_package_dep_spec("cat/pkg1[.KEYWORDS<~a]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, a, pkg1, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, a, pkg2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, a, pkg3, nullptr, { }));
|
|
|
|
PackageDepSpec b(parse_user_package_dep_spec("cat/pkg1[.KEYWORDS<~b]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, b, pkg1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, b, pkg2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, b, pkg3, nullptr, { }));
|
|
|
|
PackageDepSpec c(parse_user_package_dep_spec("cat/pkg1[.KEYWORDS<~c]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, c, pkg1, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, c, pkg2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, c, pkg3, nullptr, { }));
|
|
|
|
PackageDepSpec d(parse_user_package_dep_spec("cat/pkg1[.KEYWORDS>~a]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, d, pkg1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, d, pkg2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, d, pkg3, nullptr, { }));
|
|
|
|
PackageDepSpec e(parse_user_package_dep_spec("cat/pkg1[.KEYWORDS=~d]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, e, pkg1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, e, pkg2, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, e, pkg3, nullptr, { }));
|
|
|
|
PackageDepSpec f(parse_user_package_dep_spec("cat/pkg1[.KEYWORDS=~a ~c]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, f, pkg1, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, f, pkg2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, f, pkg3, nullptr, { }));
|
|
|
|
PackageDepSpec g(parse_user_package_dep_spec("cat/pkg1[.HITCHHIKER=42]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, g, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec h(parse_user_package_dep_spec("cat/pkg1[.HITCHHIKER<41]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, h, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec i(parse_user_package_dep_spec("cat/pkg1[.HITCHHIKER<42]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, i, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec j(parse_user_package_dep_spec("cat/pkg1[.HITCHHIKER<43]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, j, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec k(parse_user_package_dep_spec("cat/pkg1[.HITCHHIKER>42]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, k, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec l(parse_user_package_dep_spec("cat/pkg1[.HITCHHIKER>41]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, l, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec m(parse_user_package_dep_spec("cat/pkg1[.HITCHHIKER?]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, m, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec n(parse_user_package_dep_spec("cat/pkg1[.SPOON?]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, n, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec o(parse_user_package_dep_spec("cat/pkg1[.$keywords<~a]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, o, pkg1, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, o, pkg2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, o, pkg3, nullptr, { }));
|
|
|
|
PackageDepSpec p(parse_user_package_dep_spec("cat/pkg1[.::$format=fake]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, p, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec q(parse_user_package_dep_spec("cat/pkg1[.::$format=e]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, q, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec r(parse_user_package_dep_spec("cat/pkg1[.::format=fake]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, r, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec s(parse_user_package_dep_spec("cat/pkg1[.::format=e]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, s, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec t(parse_user_package_dep_spec("cat/pkg1[.HITCHHIKER!=42]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, t, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec u(parse_user_package_dep_spec("cat/pkg1[.::$format!=fake]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, u, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec v(parse_user_package_dep_spec("cat/pkg1[.::$format!=e]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, v, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec w(parse_user_package_dep_spec("cat/pkg1[.::format!=fake]", &env, { }));
|
|
EXPECT_TRUE(! match_package(env, w, pkg1, nullptr, { }));
|
|
|
|
PackageDepSpec x(parse_user_package_dep_spec("cat/pkg1[.::format!=e]", &env, { }));
|
|
EXPECT_TRUE(match_package(env, x, pkg1, nullptr, { }));
|
|
}
|
|
|
|
TEST_F(UserDepSpecTest, Exclude)
|
|
{
|
|
TestEnvironment env;
|
|
std::shared_ptr<FakeRepository> repo1(std::make_shared<FakeRepository>(make_named_values<FakeRepositoryParams>(
|
|
n::environment() = &env,
|
|
n::name() = RepositoryName("repo1"))));
|
|
env.add_repository(1, repo1);
|
|
|
|
std::shared_ptr<FakeRepository> repo2(std::make_shared<FakeRepository>(make_named_values<FakeRepositoryParams>(
|
|
n::environment() = &env,
|
|
n::name() = RepositoryName("repo2"))));
|
|
env.add_repository(1, repo2);
|
|
|
|
std::shared_ptr<FakePackageID> cat1_pkg1_repo1(repo1->add_version("cat1", "pkg1", "1"));
|
|
std::shared_ptr<FakePackageID> cat1_pkg2_repo1(repo1->add_version("cat1", "pkg2", "1"));
|
|
std::shared_ptr<FakePackageID> cat2_pkg1_repo1(repo1->add_version("cat2", "pkg1", "1"));
|
|
std::shared_ptr<FakePackageID> cat2_pkg2_repo1(repo1->add_version("cat2", "pkg2", "1"));
|
|
|
|
std::shared_ptr<FakePackageID> cat1_pkg1_repo2(repo2->add_version("cat1", "pkg1", "2"));
|
|
std::shared_ptr<FakePackageID> cat1_pkg2_repo2(repo2->add_version("cat1", "pkg2", "2"));
|
|
std::shared_ptr<FakePackageID> cat2_pkg1_repo2(repo2->add_version("cat2", "pkg1", "2"));
|
|
std::shared_ptr<FakePackageID> cat2_pkg2_repo2(repo2->add_version("cat2", "pkg2", "2"));
|
|
|
|
{
|
|
PackageDepSpec spec(parse_user_package_dep_spec("cat1/*[.!exclude=*/pkg1]", &env, { updso_allow_wildcards }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat1_pkg1_repo1, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, spec, cat1_pkg2_repo1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg1_repo1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg2_repo1, nullptr, { }));
|
|
|
|
EXPECT_TRUE(! match_package(env, spec, cat1_pkg1_repo2, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, spec, cat1_pkg2_repo2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg1_repo2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg2_repo2, nullptr, { }));
|
|
}
|
|
|
|
{
|
|
PackageDepSpec spec(parse_user_package_dep_spec("*/*[.!exclude=*/pkg1][.!exclude=*/*::repo1]", &env, { updso_allow_wildcards }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat1_pkg1_repo1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat1_pkg2_repo1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg1_repo1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg2_repo1, nullptr, { }));
|
|
|
|
EXPECT_TRUE(! match_package(env, spec, cat1_pkg1_repo2, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, spec, cat1_pkg2_repo2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg1_repo2, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, spec, cat2_pkg2_repo2, nullptr, { }));
|
|
}
|
|
|
|
{
|
|
PackageDepSpec spec(parse_user_package_dep_spec("cat1/*[.!exclude=>*/pkg1-1]", &env, { updso_allow_wildcards }));
|
|
EXPECT_TRUE(match_package(env, spec, cat1_pkg1_repo1, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, spec, cat1_pkg2_repo1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg1_repo1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg2_repo1, nullptr, { }));
|
|
|
|
EXPECT_TRUE(! match_package(env, spec, cat1_pkg1_repo2, nullptr, { }));
|
|
EXPECT_TRUE(match_package(env, spec, cat1_pkg2_repo2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg1_repo2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg2_repo2, nullptr, { }));
|
|
}
|
|
|
|
{
|
|
PackageDepSpec spec(parse_user_package_dep_spec("*/*[.!exclude=*/*]", &env, { updso_allow_wildcards }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat1_pkg1_repo1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat1_pkg2_repo1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg1_repo1, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg2_repo1, nullptr, { }));
|
|
|
|
EXPECT_TRUE(! match_package(env, spec, cat1_pkg1_repo2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat1_pkg2_repo2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg1_repo2, nullptr, { }));
|
|
EXPECT_TRUE(! match_package(env, spec, cat2_pkg2_repo2, nullptr, { }));
|
|
}
|
|
}
|
|
|