[Aptitude-svn-commit] r3853 - in branches/aptitude-0.3/aptitude: .
tests
Daniel Burrows
dburrows at costa.debian.org
Mon Aug 15 23:05:34 UTC 2005
Author: dburrows
Date: Mon Aug 15 23:05:30 2005
New Revision: 3853
Modified:
branches/aptitude-0.3/aptitude/ChangeLog
branches/aptitude-0.3/aptitude/tests/test_resolver.cc
Log:
Strengthen the action test; add tests for solution comparison.
Modified: branches/aptitude-0.3/aptitude/ChangeLog
==============================================================================
--- branches/aptitude-0.3/aptitude/ChangeLog (original)
+++ branches/aptitude-0.3/aptitude/ChangeLog Mon Aug 15 23:05:30 2005
@@ -1,5 +1,10 @@
2005-08-15 Daniel Burrows <dburrows at debian.org>
+ * tests/test_resolver.cc:
+
+ Add a test case for solution comparison; add more test cases to
+ action comparison.
+
* tests/Makefile.am, tests/test_resolver.cc:
Add a first iteration of a real test case for the resolver.
Modified: branches/aptitude-0.3/aptitude/tests/test_resolver.cc
==============================================================================
--- branches/aptitude-0.3/aptitude/tests/test_resolver.cc (original)
+++ branches/aptitude-0.3/aptitude/tests/test_resolver.cc Mon Aug 15 23:05:30 2005
@@ -43,11 +43,33 @@
DEP a v3 -> < > \
]";
+// Done this way so meaningful line numbers are generated.
+#define assertEquivalent(x1, x2) \
+do { \
+ CPPUNIT_ASSERT(x1 == x2); \
+ CPPUNIT_ASSERT(x2 == x1); \
+ CPPUNIT_ASSERT(!(x1 != x2)); \
+ CPPUNIT_ASSERT(!(x2 != x1)); \
+ CPPUNIT_ASSERT(!(x1 < x2)); \
+ CPPUNIT_ASSERT(!(x2 < x1)); \
+} while(0)
+
+#define assertInequivalent(x1, x2) \
+do { \
+ CPPUNIT_ASSERT(x1 != x2); \
+ CPPUNIT_ASSERT(x2 != x1); \
+ CPPUNIT_ASSERT(!(x1 == x2)); \
+ CPPUNIT_ASSERT(!(x2 == x1)); \
+ CPPUNIT_ASSERT(x1 < x2 || x2 < x1); \
+ CPPUNIT_ASSERT(!(x1 < x2 && x2 < x1)); \
+} while(0)
+
class ResolverTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(ResolverTest);
CPPUNIT_TEST(testActionCompare);
+ CPPUNIT_TEST(testSolutionCompare);
CPPUNIT_TEST_SUITE_END();
@@ -59,26 +81,6 @@
return parse_universe(in);
}
- /** Assert that two actions are equal. */
- static void assertActionsEqual(const dummy_solution::action &a1,
- const dummy_solution::action &a2)
- {
- CPPUNIT_ASSERT(a1 == a2);
- CPPUNIT_ASSERT(!(a1 != a2));
- CPPUNIT_ASSERT(!(a1 < a2));
- CPPUNIT_ASSERT(!(a2 < a1));
- }
-
- /** Assert that two actions are inequal. */
- static void assertActionsInequal(const dummy_solution::action &a1,
- const dummy_solution::action &a2)
- {
- CPPUNIT_ASSERT(a1 != a2);
- CPPUNIT_ASSERT(!(a1 == a2));
- CPPUNIT_ASSERT(a1 < a2 || a2 < a1);
- CPPUNIT_ASSERT(!(a1 < a2 && a2 < a1));
- }
-
/** Test that the comparison operators on actions work. */
void testActionCompare()
{
@@ -97,20 +99,145 @@
dummy_solution::action a2(u.find_package("a").version_from_name("v1"),
d2, 21);
- assertActionsEqual(a1, a2);
+ assertEquivalent(a1, a1);
+ assertEquivalent(a1, a2);
dummy_solution::action a3(u.find_package("a").version_from_name("v2"),
d1, 49);
- assertActionsInequal(a1, a3);
- assertActionsInequal(a2, a3);
+ assertEquivalent(a2, a2);
+ assertEquivalent(a3, a3);
+
+ assertInequivalent(a1, a3);
+ assertInequivalent(a2, a3);
dummy_solution::action a4(u.find_package("c").version_from_name("v3"),
d2, 21);
- assertActionsInequal(a1, a4);
- assertActionsInequal(a2, a4);
- assertActionsInequal(a3, a4);
+ assertEquivalent(a4, a4);
+ assertInequivalent(a1, a4);
+ assertInequivalent(a2, a4);
+ assertInequivalent(a3, a4);
+ }
+
+ /** Tests that the comparison operations on solutions work. */
+ void testSolutionCompare()
+ {
+ dummy_universe_ref u = parseUniverse(dummy_universe_1);
+
+ // Grab two arbitrary deps.
+ dummy_universe::dep_iterator di = u.deps_begin();
+ CPPUNIT_ASSERT(!di.end());
+ dummy_universe::dep d1 = *di;
+ ++di;
+ CPPUNIT_ASSERT(!di.end());
+ dummy_universe::dep d2 = *di;
+
+ std::set<dummy_universe::dep> u_broken;
+ for(dummy_universe::broken_dep_iterator bi = u.broken_begin();
+ !bi.end(); ++bi)
+ u_broken.insert(*bi);
+
+ dummy_solution::action a1(u.find_package("a").version_from_name("v1"),
+ d1, 49);
+ dummy_solution::action a2(u.find_package("a").version_from_name("v1"),
+ d2, 21);
+ dummy_solution::action a3(u.find_package("a").version_from_name("v2"),
+ d1, 49);
+
+ dummy_solution::action a4(u.find_package("c").version_from_name("v3"),
+ d2, 21);
+
+
+ // Generate some meaningless solutions to check that equivalency
+ // is correctly calculated according to the version mappings and
+ // the set of unsolved soft deps.
+ dummy_solution s0(u_broken, 0);
+ dummy_solution s1(&a1, &a1+1, s0,
+ (dummy_universe::dep *) 0,
+ (dummy_universe::dep *) 0,
+ s1.get_broken(),
+ dummy_end_iterator<dummy_universe::version>(),
+ 0, 0);
+ dummy_solution s2(&a2, &a2+1, s0,
+ (dummy_universe::dep *) 0,
+ (dummy_universe::dep *) 0,
+ s1.get_broken(),
+ dummy_end_iterator<dummy_universe::version>(),
+ 0, 0);
+ dummy_solution s3(&a3, &a3+1, s0,
+ (dummy_universe::dep *) 0,
+ (dummy_universe::dep *) 0,
+ s1.get_broken(),
+ dummy_end_iterator<dummy_universe::version>(),
+ 0, 0);
+ dummy_solution s4(&a4, &a4+1, s0,
+ (dummy_universe::dep *) 0,
+ (dummy_universe::dep *) 0,
+ s1.get_broken(),
+ dummy_end_iterator<dummy_universe::version>(),
+ 0, 0);
+
+ // the following two should be equal.
+ dummy_solution s5(&a3, &a3+1, s1,
+ (dummy_universe::dep *) 0,
+ (dummy_universe::dep *) 0,
+ s1.get_broken(),
+ dummy_end_iterator<dummy_universe::version>(),
+ 0, 0);
+ dummy_solution s6(&a1, &a1+1, s3,
+ (dummy_universe::dep *) 0,
+ (dummy_universe::dep *) 0,
+ s1.get_broken(),
+ dummy_end_iterator<dummy_universe::version>(),
+ 0, 0);
+
+ // and this should not equal any other solution.
+ dummy_solution s7(s0, d1, 0, 0);
+
+ assertEquivalent(s0, s0);
+ assertInequivalent(s0, s1);
+ assertInequivalent(s0, s2);
+ assertInequivalent(s0, s3);
+ assertInequivalent(s0, s4);
+ assertInequivalent(s0, s5);
+ assertInequivalent(s0, s6);
+ assertInequivalent(s0, s7);
+
+ assertEquivalent(s1, s1);
+ assertInequivalent(s1, s2);
+ assertInequivalent(s1, s3);
+ assertInequivalent(s1, s4);
+ assertInequivalent(s1, s5);
+ assertInequivalent(s1, s6);
+ assertInequivalent(s1, s7);
+
+ assertEquivalent(s2, s2);
+ assertInequivalent(s2, s3);
+ assertInequivalent(s2, s4);
+ assertInequivalent(s2, s5);
+ assertInequivalent(s2, s6);
+ assertInequivalent(s2, s7);
+
+ assertEquivalent(s3, s3);
+ assertInequivalent(s3, s4);
+ assertInequivalent(s3, s5);
+ assertInequivalent(s3, s6);
+ assertInequivalent(s3, s7);
+
+ assertEquivalent(s4, s4);
+ assertInequivalent(s4, s5);
+ assertInequivalent(s4, s6);
+ assertInequivalent(s4, s7);
+
+ assertEquivalent(s5, s5);
+ assertEquivalent(s5, s6);
+ assertInequivalent(s5, s7);
+
+ assertEquivalent(s6, s6);
+ assertInequivalent(s6, s7);
+
+ assertEquivalent(s7, s7);
}
};
More information about the Aptitude-svn-commit
mailing list