Rewrite test_metis.py to test exposed functions

nxmetis/tests/test_metis.py

@@ -1,6 +1,9 @@
 import itertools
 import nose.tools
 
+import networkx as nx
+
+import nxmetis
 from nxmetis import exceptions
 from nxmetis import _metis
 from nxmetis import types
@@ -17,59 +20,25 @@ def make_cycle(n):
 
 class TestMetis(object):
 
-    def test_node_nd(self):
-        n = 16
-        xadj, adjncy = make_cycle(n)
-        perm, iperm = _metis.node_nd(xadj, adjncy)
-        nose.tools.assert_equal(set(perm), set(range(n)))
-        nose.tools.assert_equal(abs(perm[-1] - perm[-2]), n // 2)
-        nose.tools.ok_(set(range(min(perm[-2:]) + 1, max(perm[-2:]))) in
-                       (set(perm[0:n // 2 - 1]), set(perm[n // 2 - 1:-2])))
-        nose.tools.ok_(all(i == perm[iperm[i]] for i in range(n)))
+    def setUp(self):
+        node_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
+                     1, 2, 3, 4, 5, 6]
+        self.G = nx.Graph()
+        self.G.add_edges_from(list(itertools.combinations(node_list, 2)))
 
-    def test_selfloops(self):
-        n = 16
-        xadj = list(range(0, 3 * n + 1, 3))
-        adjncy = list(
-            itertools.chain.from_iterable(
-                zip(itertools.chain([n - 1], range(n - 1)),
-                    range(n),
-                    itertools.chain(range(1, n), [0]))))
-        perm, iperm = _metis.node_nd(xadj, adjncy)
-        nose.tools.assert_equal(set(perm), set(range(n)))
-        nose.tools.assert_equal(abs(perm[-1] - perm[-2]), n // 2)
-        nose.tools.ok_(set(range(min(perm[-2:]) + 1, max(perm[-2:]))) in
-                       (set(perm[0:n // 2 - 1]), set(perm[n // 2 - 1:-2])))
-        nose.tools.ok_(all(i == perm[iperm[i]] for i in range(n)))
+    def test_node_nd_unweighted(self):
+        node_ordering = nxmetis.node_nested_dissection(self.G)
+        nose.tools.assert_equal(sorted(self.G), sorted(node_ordering))
 
     def test_part_graph(self):
-        n = 16
-        xadj, adjncy = make_cycle(n)
-        for recursive in (False, True):
-            objval, part = _metis.part_graph(
-                xadj, adjncy, 2, recursive=recursive)
-            nose.tools.assert_equal(objval, 2)
-            nose.tools.assert_equal(set(part), set(range(2)))
-            it = itertools.dropwhile(lambda x: x == 0, itertools.cycle(part))
-            nose.tools.assert_equal(
-                list(itertools.takewhile(lambda x: x == 1, it)), [1] * (n // 2))
+        partitioning = (96, [[1, 'c', 'b', 'j'], ['e', 'd', 'g', 'f'],
+                        ['i', 'h', 3, 6], ['a', 2, 4, 5]])
+        nose.tools.assert_equal(nxmetis.partition(self.G, 4), partitioning)
 
     def test_compute_vertex_separator(self):
-        n = 16
-        xadj, adjncy = make_cycle(n)
-        sepsize, part = _metis.compute_vertex_separator(xadj, adjncy)
-        nose.tools.assert_equal(sepsize, 2)
-        nose.tools.assert_equal(len(part), n)
-        part1, part2, sep = (list(filter(lambda i: part[i] == k, range(n)))
-                             for k in range(3))
-        nose.tools.assert_equal(sorted(part1 + part2 + sep), list(range(n)))
-        nose.tools.assert_equal(len(sep), 2)
-        nose.tools.assert_equal(abs(sep[1] - sep[0]), n // 2)
-        nose.tools.assert_equal(
-            sorted(map(sorted, [part1, part2])),
-            sorted(map(sorted,
-                       [[(sep[0] + i) % n for i in range(1, n // 2)],
-                        [(sep[1] + i) % n for i in range(1, n // 2)]])))
+        bisection = ([1, 'c', 'e', 'g', 'f', 'h', 4],
+                     ['a', 'b', 'd', 'i', 'j', 2, 3, 6, 5], [])
+        nose.tools.assert_equal(nxmetis.vertex_separator(self.G), bisection)
 
     def test_MetisOptions(self):
         n = 16