Rev 4537: Cleanup imports. in file:///home/vila/src/bzr/experimental/revno-full-graph/

[Vincent Ladeuil]

At file:///home/vila/src/bzr/experimental/revno-full-graph/

------------------------------------------------------------
revno: 4537
revision-id: v.ladeuil+lp at free.fr-20090716132624-2km3f6jqr7zi3klr
parent: pqm at pqm.ubuntu.com-20090714173313-3p3ytzlfuc3y2bm6
committer: Vincent Ladeuil <v.ladeuil+lp at free.fr>
branch nick: revno-full-graph
timestamp: Thu 2009-07-16 15:26:24 +0200
message:
  Cleanup imports.
-------------- next part --------------
=== modified file 'bzrlib/tests/test_tsort.py'
--- a/bzrlib/tests/test_tsort.py	2009-03-23 14:59:43 +0000
+++ b/bzrlib/tests/test_tsort.py	2009-07-16 13:26:24 +0000
@@ -17,27 +17,28 @@
 
 """Tests for topological sort."""
 
-
-from bzrlib.tests import TestCase
-from bzrlib.tsort import topo_sort, TopoSorter, MergeSorter, merge_sort
-from bzrlib.errors import GraphCycleError
-from bzrlib.revision import NULL_REVISION
-
-
-class TopoSortTests(TestCase):
+from bzrlib import (
+    errors,
+    tests,
+    tsort,
+    revision,
+    )
+
+
+class TopoSortTests(tests.TestCase):
 
     def assertSortAndIterate(self, graph, result_list):
         """Check that sorting and iter_topo_order on graph works."""
-        self.assertEquals(result_list, topo_sort(graph))
+        self.assertEquals(result_list, tsort.topo_sort(graph))
         self.assertEqual(result_list,
-                         list(TopoSorter(graph).iter_topo_order()))
+                         list(tsort.TopoSorter(graph).iter_topo_order()))
 
     def assertSortAndIterateRaise(self, exception_type, graph):
         """Try both iterating and topo_sorting graph and expect an exception."""
-        self.assertRaises(exception_type, topo_sort, graph)
+        self.assertRaises(exception_type, tsort.topo_sort, graph)
         self.assertRaises(exception_type,
                           list,
-                          TopoSorter(graph).iter_topo_order())
+                          tsort.TopoSorter(graph).iter_topo_order())
 
     def test_tsort_empty(self):
         """TopoSort empty list"""
@@ -49,13 +50,13 @@
 
     def test_tsort_cycle(self):
         """TopoSort traps graph with cycles"""
-        self.assertSortAndIterateRaise(GraphCycleError,
+        self.assertSortAndIterateRaise(errors.GraphCycleError,
                                        {0: [1],
                                         1: [0]}.items())
 
     def test_tsort_cycle_2(self):
         """TopoSort traps graph with longer cycle"""
-        self.assertSortAndIterateRaise(GraphCycleError,
+        self.assertSortAndIterateRaise(errors.GraphCycleError,
                                        {0: [1],
                                         1: [2],
                                         2: [0]}.items())
@@ -93,35 +94,33 @@
                                    [1, 0])
 
 
-class MergeSortTests(TestCase):
+class MergeSortTests(tests.TestCase):
 
     def assertSortAndIterate(self, graph, branch_tip, result_list,
-            generate_revno, mainline_revisions=None):
+                             generate_revno, mainline_revisions=None):
         """Check that merge based sorting and iter_topo_order on graph works."""
-        value = merge_sort(graph, branch_tip,
-                           mainline_revisions=mainline_revisions,
-                           generate_revno=generate_revno)
+        value = tsort.merge_sort(graph, branch_tip,
+                                 mainline_revisions=mainline_revisions,
+                                 generate_revno=generate_revno)
         if result_list != value:
             import pprint
             self.assertEqualDiff(pprint.pformat(result_list),
                                  pprint.pformat(value))
-        self.assertEquals(result_list,
-            merge_sort(graph, branch_tip, mainline_revisions=mainline_revisions,
-                generate_revno=generate_revno))
-        self.assertEqual(result_list,
-            list(MergeSorter(
-                graph,
-                branch_tip,
-                mainline_revisions=mainline_revisions,
-                generate_revno=generate_revno,
-                ).iter_topo_order()))
+        self.assertEquals(result_list, value)
+        self.assertEqual(result_list, list(
+                tsort.MergeSorter(
+                    graph,
+                    branch_tip,
+                    mainline_revisions=mainline_revisions,
+                    generate_revno=generate_revno,
+                    ).iter_topo_order()))
 
     def test_merge_sort_empty(self):
         # sorting of an emptygraph does not error
         self.assertSortAndIterate({}, None, [], False)
         self.assertSortAndIterate({}, None, [], True)
-        self.assertSortAndIterate({}, NULL_REVISION, [], False)
-        self.assertSortAndIterate({}, NULL_REVISION, [], True)
+        self.assertSortAndIterate({}, revision.NULL_REVISION, [], False)
+        self.assertSortAndIterate({}, revision.NULL_REVISION, [], True)
 
     def test_merge_sort_not_empty_no_tip(self):
         # merge sorting of a branch starting with None should result