// test_resolver_hints.cc -*-c++-*-
//
// Copyright (C) 2009-2010 Daniel Burrows
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// This program 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; see the file COPYING. If not, write to
// the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
//
// A test of the resolver-hint structure.
#include <generic/apt/aptitude_resolver.h>
#include <generic/problemresolver/cost.h>
#include <generic/problemresolver/cost_limits.h>
#include <cppunit/extensions/HelperMacros.h>
#include <boost/lexical_cast.hpp>
using namespace aptitude::matching;
namespace
{
typedef aptitude_resolver::hint hint;
struct test
{
// A string version of the hint.
std::string text;
// The resolver hint.
aptitude_resolver::hint h;
test(const std::string &_text, const hint &_h)
: text(_text), h(_h)
{
}
};
const test resolver_tests[] =
{
test("40 g++", hint::make_tweak_score(pattern::make_exact_name("g++"),
hint::version_selection::make_inst(),
40)),
test("-143 aptitude <4.3.0", hint::make_tweak_score(pattern::make_exact_name("aptitude"),
hint::version_selection::make_version(hint::version_selection::less_than, "4.3.0"),
-143)),
test("+621 ?section(games) /unstable", hint::make_tweak_score(pattern::make_section("games"),
hint::version_selection::make_archive("unstable"),
621)),
test("reject libc6 <=0.5.0", hint::make_reject(pattern::make_exact_name("libc6"),
hint::version_selection::make_version(hint::version_selection::less_than_or_equal_to,
"0.5.0"))),
test("approve entropy =0", hint::make_mandate(pattern::make_exact_name("entropy"),
hint::version_selection::make_version(hint::version_selection::equal_to,
"0"))),
test("approve entropy 1", hint::make_mandate(pattern::make_exact_name("entropy"),
hint::version_selection::make_version(hint::version_selection::equal_to,
"1"))),
test("reject aptitude :UNINST", hint::make_reject(pattern::make_exact_name("aptitude"),
hint::version_selection::make_uninst())),
test("+29387 xmonad >=5.4.3.2.1", hint::make_tweak_score(pattern::make_exact_name("xmonad"),
hint::version_selection::make_version(hint::version_selection::greater_than_or_equal_to, "5.4.3.2.1"),
29387)),
test("approve dc >1", hint::make_mandate(pattern::make_exact_name("dc"),
hint::version_selection::make_version(hint::version_selection::greater_than, "1"))),
test("reject ?task(desktop) <>4.0", hint::make_reject(pattern::make_task("desktop"),
hint::version_selection::make_version(hint::version_selection::not_equal_to, "4.0"))),
test("increase-tier-to 100 wesnoth <5.0.0",
hint::make_raise_cost_component(pattern::make_exact_name("wesnoth"),
hint::version_selection::make_version(hint::version_selection::less_than, "5.0.0"),
"safety",
100)),
test("increase-tier-to maximum xroach",
hint::make_raise_cost_component(pattern::make_exact_name("xroach"),
hint::version_selection::make_inst(),
"safety",
INT_MAX)),
test("increase-tier-to conflict xroach",
hint::make_discard(pattern::make_exact_name("xroach"),
hint::version_selection::make_inst())),
test("increase-tier-to discard bob",
hint::make_discard(pattern::make_exact_name("bob"),
hint::version_selection::make_inst())),
test("increase-tier-to 800 xroach",
hint::make_raise_cost_component(pattern::make_exact_name("xroach"),
hint::version_selection::make_inst(),
"safety",
800)),
test("add-to-cost-component nadaComponent 45 nada",
hint::make_add_to_cost_component(pattern::make_exact_name("nada"),
hint::version_selection::make_inst(),
"nadaComponent",
45)),
test("raise-cost-component albertComponent 299 albert",
hint::make_raise_cost_component(pattern::make_exact_name("albert"),
hint::version_selection::make_inst(),
"albertComponent",
299)),
test("discard albert",
hint::make_discard(pattern::make_exact_name("albert"),
hint::version_selection::make_inst())),
test("discard xyzzy /unstable",
hint::make_discard(pattern::make_exact_name("xyzzy"),
hint::version_selection::make_archive("unstable"))),
};
const int num_resolver_tests =
sizeof(resolver_tests) / sizeof(resolver_tests[0]);
}
class ResolverHintsTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(ResolverHintsTest);
CPPUNIT_TEST(testHintParse);
CPPUNIT_TEST(testHintCopy);
CPPUNIT_TEST(testHintOrdering);
CPPUNIT_TEST_SUITE_END();
public:
void testHintParse()
{
for(int i = 0; i < num_resolver_tests; ++i)
{
// \todo When we have an operator<< to write out hints, we
// should use ASSERT_EQUAL to get better messages.
const test &t(resolver_tests[i]);
hint h;
CPPUNIT_ASSERT_MESSAGE("Parsing " + t.text, hint::parse(t.text, h));
CPPUNIT_ASSERT_MESSAGE("Checking " + t.text + ": " +
boost::lexical_cast<std::string>(h) +
" == " + boost::lexical_cast<std::string>(t.h),
h == t.h);
}
// Try some failure cases too.
hint dummy;
CPPUNIT_ASSERT(!hint::parse("", dummy));
CPPUNIT_ASSERT(!hint::parse("823", dummy));
CPPUNIT_ASSERT(!hint::parse("badact target", dummy));
CPPUNIT_ASSERT(!hint::parse("approve ?version(423 1234)", dummy));
CPPUNIT_ASSERT(!hint::parse("approve ?version(3425", dummy));
}
void testHintCopy()
{
for(int i = 0; i < num_resolver_tests; ++i)
{
hint h(resolver_tests[i].h);
CPPUNIT_ASSERT_MESSAGE("Testing copy constructor: ", h == resolver_tests[i].h);
hint h2;
h2 = resolver_tests[i].h;
CPPUNIT_ASSERT_MESSAGE("Testing operator=: ", h2 == resolver_tests[i].h);
CPPUNIT_ASSERT_MESSAGE("Testing operator= and copy constructor: ", h == h2);
}
}
void testHintOrdering()
{
// Brute-force verification of the axioms of a total ordering.
// Uses the fact that all the hints in the test array are
// different.
for(int i = 0; i < num_resolver_tests; ++i)
for(int j = 0; j < num_resolver_tests; ++j)
{
const hint &hi(resolver_tests[i].h);
const hint &hj(resolver_tests[j].h);
// Test consistency with .compare().
int cmp = hi.compare(hj);
if(cmp < 0)
{
CPPUNIT_ASSERT(hi < hj);
CPPUNIT_ASSERT(hi <= hj);
CPPUNIT_ASSERT(!(hi == hj));
CPPUNIT_ASSERT(hi != hj);
CPPUNIT_ASSERT(!(hi >= hj));
CPPUNIT_ASSERT(!(hi > hj));
}
else if(cmp == 0)
{
CPPUNIT_ASSERT(!(hi < hj));
CPPUNIT_ASSERT(hi <= hj);
CPPUNIT_ASSERT(hi == hj);
CPPUNIT_ASSERT(!(hi != hj));
CPPUNIT_ASSERT(hi >= hj);
CPPUNIT_ASSERT(!(hi > hj));
}
else // if(cmp > 0)
{
CPPUNIT_ASSERT(!(hi < hj));
CPPUNIT_ASSERT(!(hi <= hj));
CPPUNIT_ASSERT(!(hi == hj));
CPPUNIT_ASSERT(hi != hj);
CPPUNIT_ASSERT(hi >= hj);
CPPUNIT_ASSERT(hi > hj);
}
// Check that identity comparisons work (x == x' <=> x is x').
//
// Check that for all x, x <= x and x >= x, and also !(x<x)
// and !(x>x).
if(i == j)
{
CPPUNIT_ASSERT(hi == hj);
CPPUNIT_ASSERT(hi >= hj);
CPPUNIT_ASSERT(hi <= hj);
CPPUNIT_ASSERT(!(hi != hj));
CPPUNIT_ASSERT(!(hi < hj));
CPPUNIT_ASSERT(!(hi > hj));
}
else
{
CPPUNIT_ASSERT(hi != hj);
CPPUNIT_ASSERT(!(hi == hj));
CPPUNIT_ASSERT(hi > hj ||
hi < hj);
if(hi > hj)
{
CPPUNIT_ASSERT(hi >= hj);
CPPUNIT_ASSERT(!(hi < hj));
CPPUNIT_ASSERT(!(hi <= hj));
}
if(hi < hj)
{
CPPUNIT_ASSERT(hi <= hj);
CPPUNIT_ASSERT(!(hi > hj));
CPPUNIT_ASSERT(!(hi >= hj));
}
}
for(int k = 0; k < num_resolver_tests; ++k)
{
const hint &hk(resolver_tests[k].h);
// Test transitivity -- testing both or-equal and not-equal
// variants might be excessive?
if(hi <= hj && hj <= hk)
CPPUNIT_ASSERT(hi <= hk);
if(hi < hj && hj < hk)
CPPUNIT_ASSERT(hi < hk);
if(hi >= hj && hj >= hk)
CPPUNIT_ASSERT(hi >= hk);
if(hi > hj && hj > hk)
CPPUNIT_ASSERT(hi > hk);
}
}
}
};
CPPUNIT_TEST_SUITE_REGISTRATION(ResolverHintsTest);