diff --git a/t/unit/dependency-resolver/compare-build-order.t b/t/unit/dependency-resolver/compare-build-order.t
index 951ae3e..a6a3a11 100644
--- a/t/unit/dependency-resolver/compare-build-order.t
+++ b/t/unit/dependency-resolver/compare-build-order.t
@@ -1,78 +1,101 @@
 use 5.014;
 use strict;
 use warnings;
 
 # Test comparison operation for sorting modules into build order
 
 use Test::More;
 
 use ksb::DependencyResolver;
 
 my $graph1 = {
     'a' => {
         votes => {
             'b' => 1,
             'd' => 1
         },
         module => {
             name => 'a',
         },
     },
     'b' => {
         votes => {},
         module => {
             name => 'b',
         },
     },
     'c' => {
         votes => {
             'd' => 1
         },
         module => {
             name => 'c',
         },
     },
     'd' => {
         votes => {},
         module => {
             name => 'd',
         },
     },
+
     'e' => {  # Here to test sorting by rc-file order
         votes => {
             'b' => 1,
             'd' => 1,
         },
         module => {
             name => 'e',
+            '#create-id' => 2,
+        },
+    },
+    'f' => {  # Identical to 'e' except it's simulated earlier in rc-file
+        votes => {
+            'b' => 1,
+            'd' => 1,
+        },
+        module => {
+            name => 'f',
             '#create-id' => 1,
         },
     },
 };
 
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'a', 'a'),  0, "'a' should be sorted at the same position as itself");
+# Test that tests are symmetric e.g. a > b => b < a. This permits us to only manually
+# test one pair of these tests now that the test matrix is growing.
+for my $l ('a'..'f') {
+    for my $r ('a'..'f') {
+        my $res = ksb::DependencyResolver::_compareBuildOrder($graph1, $l, $r);
+
+        if ($l eq $r) {
+            is($res, 0, "'$l' should be sorted at the same position as itself");
+        }
+        else {
+            my $expected = -$res; # The check that abs($res) == 1 logically follows with later tests
+            is(ksb::DependencyResolver::_compareBuildOrder($graph1, $r, $l), $expected,
+                "'$l' cmp '$r' is opposite of '$r' cmp '$l'");
+        }
+    }
+}
+
 is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'a', 'b'), -1, "'a' should be sorted before 'b' by dependency ordering");
 is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'a', 'c'), -1, "'a' should be sorted before 'c' by vote ordering");
 is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'a', 'd'), -1, "'a' should be sorted before 'd' by dependency ordering");
-# e doesn't depend on a, has same number of votes, but should still lose to a despite lexicographically being after 'a'
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'a', 'e'), -1, "'a' should be sorted before 'e' by rc-file ordering");
+is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'a', 'e'), -1, "'a' should be sorted before 'e' by lexicographic ordering");
+is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'a', 'f'), -1, "'a' should be sorted before 'f' by lexicographic ordering");
 
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'b', 'a'),  1, "'b' should be sorted after 'a' by dependency ordering");
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'b', 'b'),  0, "'b' should be sorted at the same position as itself");
 is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'b', 'c'),  1, "'b' should be sorted after 'c' by vote ordering");
 is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'b', 'd'), -1, "'b' should be sorted before 'd' by lexicographic ordering");
 is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'b', 'e'),  1, "'b' should be sorted after 'e' by dependency ordering");
+is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'b', 'f'),  1, "'b' should be sorted after 'f' by dependency ordering");
 
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'c', 'a'),  1, "'c' should be sorted after 'a' by vote ordering");
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'c', 'b'), -1, "'c' should be sorted before 'b' by vote ordering");
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'c', 'c'),  0, "'c' should be sorted at the same position as itself");
 is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'c', 'd'), -1, "'c' should be sorted before 'd' by dependency ordering");
 is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'c', 'e'),  1, "'c' should be sorted after 'e' by vote ordering");
+is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'c', 'f'),  1, "'c' should be sorted after 'f' by vote ordering");
 
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'd', 'a'),  1, "'d' should be sorted after 'a' by dependency ordering");
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'd', 'b'),  1, "'d' should be sorted after 'b' by lexicographic ordering");
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'd', 'c'),  1, "'d' should be sorted after 'c' by dependency ordering");
-is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'd', 'd'),  0, "'d' should be sorted at the same position as itself");
 is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'd', 'e'),  1, "'d' should be sorted after 'e' by dependency ordering");
+is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'd', 'f'),  1, "'d' should be sorted after 'f' by dependency ordering");
+
+is(ksb::DependencyResolver::_compareBuildOrder($graph1, 'e', 'f'),  1, "'e' should be sorted after 'f' by rc-file ordering");
 
 done_testing();
diff --git a/t/unit/dependency-resolver/sort-build-order.t b/t/unit/dependency-resolver/sort-build-order.t
index 8287f7a..a02c3d7 100644
--- a/t/unit/dependency-resolver/sort-build-order.t
+++ b/t/unit/dependency-resolver/sort-build-order.t
@@ -1,95 +1,96 @@
 use 5.014;
 use strict;
 use warnings;
 
 # Test sorting modules into build order
 
 use Test::More;
 
 use ksb::DependencyResolver;
 
 my $graph1 = {
     'a' => {
         votes => {
             'b' => 1,
             'd' => 1
         },
         build => 1,
         module => {
             name => 'a',
             '#create-id' => 1,
         },
     },
     'b' => {
         votes => {},
         build => 1,
         module => {
             name => 'b',
             '#create-id' => 1,
         },
     },
     'c' => {
         votes => {
             'd' => 1
         },
         build => 1,
         module => {
             name => 'c',
             '#create-id' => 1,
         },
     },
     'd' => {
         votes => {},
         build => 1,
         module => {
             name => 'd',
             '#create-id' => 1,
         },
     },
     'e' => {
         votes => {},
         build => 1,
         module => {
             name => 'e',
             '#create-id' => 2, # Should come after everything else
         },
     },
 };
 
 
-my @expected1 = ('a', 'c', 'b', 'd', 'e');
-my @actual1 = map { $_->{name} } ksb::DependencyResolver::sortModulesIntoBuildOrder($graph1);
+my @expected1 = map { $graph1->{$_}->{module} } ('a', 'c', 'b', 'd', 'e');
+my @actual1   = ksb::DependencyResolver::sortModulesIntoBuildOrder($graph1);
 
 is_deeply(\@actual1, \@expected1, "should sort modules into the proper build order");
 
 # use some random key strokes for names:
 # unlikely to yield keys in equivalent order as $graph1: key order *should not matter*
 my $graph2 = {
     'avdnrvrl' => $graph1->{c},
     'lexical1' => $graph1->{b},
     'lexicla3' => $graph1->{e},
     'nllfmvrb' => $graph1->{a},
     'lexical2' => $graph1->{d},
 };
 
-my @expected2 = ('a', 'c', 'b', 'd', 'e');
-my @actual2 = map { $_->{name} } ksb::DependencyResolver::sortModulesIntoBuildOrder($graph2);
+# corresponds to same order as the test above
+my @expected2 = map { $graph2->{$_}->{module} } qw(nllfmvrb avdnrvrl lexical1 lexical2 lexicla3);
+my @actual2   = ksb::DependencyResolver::sortModulesIntoBuildOrder($graph2);
 
 is_deeply(\@actual2, \@expected2, "key order should not matter for build order");
 
 my $graph3 = {
     'a' => $graph1->{a},
     'b' => $graph1->{b},
     'c' => $graph1->{c},
     'd' => $graph1->{d},
     'e' => $graph1->{e},
 };
 $graph3->{a}->{build} = 0;
 $graph3->{b}->{module} = undef; # Empty module blocks should be treated as build == 0
 
-my @expected3 = ('c', 'd', 'e');
-my @actual3 = map { $_->{name} } ksb::DependencyResolver::sortModulesIntoBuildOrder($graph3);
+my @expected3 = map { $graph3->{$_}->{module} } ('c', 'd', 'e');
+my @actual3   = ksb::DependencyResolver::sortModulesIntoBuildOrder($graph3);
 
 is_deeply(\@actual3, \@expected3, "modules that are not to be built should be omitted");
 
 done_testing();