Rev 4933: Change all of the compiled_foo to compiled_foo_feature in http://bazaar.launchpad.net/~jameinel/bzr/2.1.0rc1-module-available

John Arbash Meinel john at arbash-meinel.com
Tue Dec 22 15:50:52 GMT 2009


At http://bazaar.launchpad.net/~jameinel/bzr/2.1.0rc1-module-available

------------------------------------------------------------
revno: 4933
revision-id: john at arbash-meinel.com-20091222155040-g78hejkqvzplsoo1
parent: john at arbash-meinel.com-20091222153920-2bvhqy7r9khumy1u
committer: John Arbash Meinel <john at arbash-meinel.com>
branch nick: 2.1.0rc1-module-available
timestamp: Tue 2009-12-22 09:50:40 -0600
message:
  Change all of the compiled_foo to compiled_foo_feature
-------------- next part --------------
=== modified file 'bzrlib/tests/test__annotator.py'
--- a/bzrlib/tests/test__annotator.py	2009-12-21 17:36:02 +0000
+++ b/bzrlib/tests/test__annotator.py	2009-12-22 15:50:40 +0000
@@ -32,19 +32,20 @@
         ('python', {'module': _annotator_py}),
     ]
     suite = loader.suiteClass()
-    if compiled_annotator.available():
-        scenarios.append(('C', {'module': compiled_annotator.module}))
+    if compiled_annotator_feature.available():
+        scenarios.append(('C', {'module': compiled_annotator_feature.module}))
     else:
         # the compiled module isn't available, so we add a failing test
         class FailWithoutFeature(tests.TestCase):
             def test_fail(self):
-                self.requireFeature(compiled_annotator)
+                self.requireFeature(compiled_annotator_feature)
         suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
     result = tests.multiply_tests(standard_tests, scenarios, suite)
     return result
 
 
-compiled_annotator = tests.ModuleAvailableFeature('bzrlib._annotator_pyx')
+compiled_annotator_feature = tests.ModuleAvailableFeature(
+                                'bzrlib._annotator_pyx')
 
 
 class TestAnnotator(tests.TestCaseWithMemoryTransport):

=== modified file 'bzrlib/tests/test__chk_map.py'
--- a/bzrlib/tests/test__chk_map.py	2009-12-21 17:36:11 +0000
+++ b/bzrlib/tests/test__chk_map.py	2009-12-22 15:50:40 +0000
@@ -29,19 +29,19 @@
     suite = loader.suiteClass()
     import bzrlib._chk_map_py as py_module
     scenarios = [('python', {'module': py_module})]
-    if compiled_chkmap.available():
-        scenarios.append(('C', {'module': compiled_chkmap.module}))
+    if compiled_chkmap_feature.available():
+        scenarios.append(('C', {'module': compiled_chkmap_feature.module}))
     else:
         # the compiled module isn't available, so we add a failing test
         class FailWithoutFeature(tests.TestCase):
             def test_fail(self):
-                self.requireFeature(compiled_chkmap)
+                self.requireFeature(compiled_chkmap_feature)
         suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
     tests.multiply_tests(standard_tests, scenarios, suite)
     return suite
 
 
-compiled_chkmap = tests.ModuleAvailableFeature('bzrlib._chk_map_pyx')
+compiled_chkmap_feature = tests.ModuleAvailableFeature('bzrlib._chk_map_pyx')
 
 
 class TestSearchKeys(tests.TestCase):

=== modified file 'bzrlib/tests/test__chunks_to_lines.py'
--- a/bzrlib/tests/test__chunks_to_lines.py	2009-12-21 17:38:05 +0000
+++ b/bzrlib/tests/test__chunks_to_lines.py	2009-12-22 15:50:40 +0000
@@ -24,19 +24,20 @@
     # parameterize all tests in this module
     import bzrlib._chunks_to_lines_py as py_module
     scenarios = [('python', {'module': py_module})]
-    if compiled_chunkstolines.available():
-        scenarios.append(('C', {'module': compiled_chunkstolines.module}))
+    if compiled_chunkstolines_feature.available():
+        scenarios.append(('C', {'module':
+                                compiled_chunkstolines_feature.module}))
     else:
         # the compiled module isn't available, so we add a failing test
         class FailWithoutFeature(tests.TestCase):
             def test_fail(self):
-                self.requireFeature(compiled_chunkstolines)
+                self.requireFeature(compiled_chunkstolines_feature)
         standard_tests.addTest(FailWithoutFeature("test_fail"))
     return tests.multiply_tests(standard_tests, scenarios, loader.suiteClass())
 
 
-compiled_chunkstolines = tests.ModuleAvailableFeature(
-                            'bzrlib._chunks_to_lines_pyx')
+compiled_chunkstolines_feature = tests.ModuleAvailableFeature(
+                                    'bzrlib._chunks_to_lines_pyx')
 
 
 class TestChunksToLines(tests.TestCase):

=== modified file 'bzrlib/tests/test__dirstate_helpers.py'
--- a/bzrlib/tests/test__dirstate_helpers.py	2009-12-21 17:51:17 +0000
+++ b/bzrlib/tests/test__dirstate_helpers.py	2009-12-22 15:50:40 +0000
@@ -38,7 +38,7 @@
     has_dirstate_helpers_pyx = False
 
 
-compiled_dirstate_helpers = tests.ModuleAvailableFeature(
+compiled_dirstate_helpers_feature = tests.ModuleAvailableFeature(
                                 'bzrlib._dirstate_helpers_pyx')
 
 
@@ -51,8 +51,8 @@
 
     ue_scenarios = [('dirstate_Python',
                      {'update_entry': dirstate.py_update_entry})]
-    if compiled_dirstate_helpers.available():
-        update_entry = compiled_dirstate_helpers.module.update_entry
+    if compiled_dirstate_helpers_feature.available():
+        update_entry = compiled_dirstate_helpers_feature.module.update_entry
         pyrex_scenario = ('dirstate_Pyrex', {'update_entry': update_entry})
         ue_scenarios.append(pyrex_scenario)
     process_entry_tests, remaining_tests = tests.split_suite_by_condition(
@@ -64,8 +64,8 @@
 
     pe_scenarios = [('dirstate_Python',
                      {'_process_entry': dirstate.ProcessEntryPython})]
-    if compiled_dirstate_helpers.available():
-        process_entry = compiled_dirstate_helpers.module.ProcessEntryC
+    if compiled_dirstate_helpers_feature.available():
+        process_entry = compiled_dirstate_helpers_feature.module.ProcessEntryC
         pyrex_scenario = ('dirstate_Pyrex', {'_process_entry': process_entry})
         pe_scenarios.append(pyrex_scenario)
     process_entry_tests, remaining_tests = tests.split_suite_by_condition(
@@ -253,7 +253,7 @@
 class TestCompiledBisectPathLeft(TestBisectPathLeft):
     """Run all Bisect Path tests against _bisect_path_lect"""
 
-    _test_needs_features = [compiled_dirstate_helpers]
+    _test_needs_features = [compiled_dirstate_helpers_feature]
 
     def get_bisect_path(self):
         from bzrlib._dirstate_helpers_pyx import _bisect_path_left
@@ -274,7 +274,7 @@
 class TestCompiledBisectPathRight(TestBisectPathRight):
     """Run all Bisect Path tests against _bisect_path_right"""
 
-    _test_needs_features = [compiled_dirstate_helpers]
+    _test_needs_features = [compiled_dirstate_helpers_feature]
 
     def get_bisect_path(self):
         from bzrlib._dirstate_helpers_pyx import _bisect_path_right
@@ -386,7 +386,7 @@
     compiled version.
     """
 
-    _test_needs_features = [compiled_dirstate_helpers]
+    _test_needs_features = [compiled_dirstate_helpers_feature]
 
     def get_bisect_dirblock(self):
         from bzrlib._dirstate_helpers_pyx import bisect_dirblock
@@ -508,7 +508,7 @@
 class TestCompiledCmpByDirs(TestCmpByDirs):
     """Test the pyrex implementation of cmp_by_dirs"""
 
-    _test_needs_features = [compiled_dirstate_helpers]
+    _test_needs_features = [compiled_dirstate_helpers_feature]
 
     def get_cmp_by_dirs(self):
         from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
@@ -659,7 +659,7 @@
 class TestCompiledCmpPathByDirblock(TestCmpPathByDirblock):
     """Test the pyrex implementation of _cmp_path_by_dirblock"""
 
-    _test_needs_features = [compiled_dirstate_helpers]
+    _test_needs_features = [compiled_dirstate_helpers_feature]
 
     def get_cmp_by_dirs(self):
         from bzrlib._dirstate_helpers_pyx import _cmp_path_by_dirblock
@@ -669,7 +669,7 @@
 class TestMemRChr(tests.TestCase):
     """Test memrchr functionality"""
 
-    _test_needs_features = [compiled_dirstate_helpers]
+    _test_needs_features = [compiled_dirstate_helpers_feature]
 
     def assertMemRChr(self, expected, s, c):
         from bzrlib._dirstate_helpers_pyx import _py_memrchr
@@ -757,7 +757,7 @@
 class TestCompiledReadDirblocks(TestReadDirblocks):
     """Test the pyrex implementation of _read_dirblocks"""
 
-    _test_needs_features = [compiled_dirstate_helpers]
+    _test_needs_features = [compiled_dirstate_helpers_feature]
 
     def get_read_dirblocks(self):
         from bzrlib._dirstate_helpers_pyx import _read_dirblocks
@@ -773,49 +773,49 @@
     """
 
     def test_bisect_dirblock(self):
-        if compiled_dirstate_helpers.available():
+        if compiled_dirstate_helpers_feature.available():
             from bzrlib._dirstate_helpers_pyx import bisect_dirblock
         else:
             from bzrlib._dirstate_helpers_py import bisect_dirblock
         self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
 
     def test__bisect_path_left(self):
-        if compiled_dirstate_helpers.available():
+        if compiled_dirstate_helpers_feature.available():
             from bzrlib._dirstate_helpers_pyx import _bisect_path_left
         else:
             from bzrlib._dirstate_helpers_py import _bisect_path_left
         self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
 
     def test__bisect_path_right(self):
-        if compiled_dirstate_helpers.available():
+        if compiled_dirstate_helpers_feature.available():
             from bzrlib._dirstate_helpers_pyx import _bisect_path_right
         else:
             from bzrlib._dirstate_helpers_py import _bisect_path_right
         self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
 
     def test_cmp_by_dirs(self):
-        if compiled_dirstate_helpers.available():
+        if compiled_dirstate_helpers_feature.available():
             from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
         else:
             from bzrlib._dirstate_helpers_py import cmp_by_dirs
         self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
 
     def test__read_dirblocks(self):
-        if compiled_dirstate_helpers.available():
+        if compiled_dirstate_helpers_feature.available():
             from bzrlib._dirstate_helpers_pyx import _read_dirblocks
         else:
             from bzrlib._dirstate_helpers_py import _read_dirblocks
         self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
 
     def test_update_entry(self):
-        if compiled_dirstate_helpers.available():
+        if compiled_dirstate_helpers_feature.available():
             from bzrlib._dirstate_helpers_pyx import update_entry
         else:
             from bzrlib.dirstate import update_entry
         self.assertIs(update_entry, dirstate.update_entry)
 
     def test_process_entry(self):
-        if compiled_dirstate_helpers.available():
+        if compiled_dirstate_helpers_feature.available():
             from bzrlib._dirstate_helpers_pyx import ProcessEntryC
             self.assertIs(ProcessEntryC, dirstate._process_entry)
         else:

=== modified file 'bzrlib/tests/test__groupcompress.py'
--- a/bzrlib/tests/test__groupcompress.py	2009-12-21 18:00:02 +0000
+++ b/bzrlib/tests/test__groupcompress.py	2009-12-22 15:50:40 +0000
@@ -32,15 +32,16 @@
     scenarios = [
         ('python', {'_gc_module': _groupcompress_py}),
         ]
-    if compiled_groupcompress.available():
+    if compiled_groupcompress_feature.available():
+        gc_module = compiled_groupcompress_feature.module
         scenarios.append(('C',
-            {'_gc_module': compiled_groupcompress.module}))
+            {'_gc_module': gc_module}))
         two_way_scenarios.extend([
-            ('CC', {'make_delta': compiled_groupcompress.module.make_delta,
-                    'apply_delta': compiled_groupcompress.module.apply_delta}),
+            ('CC', {'make_delta': gc_module.make_delta,
+                    'apply_delta': gc_module.apply_delta}),
             ('PC', {'make_delta': _groupcompress_py.make_delta,
-                    'apply_delta': compiled_groupcompress.module.apply_delta}),
-            ('CP', {'make_delta': compiled_groupcompress.module.make_delta,
+                    'apply_delta': gc_module.apply_delta}),
+            ('CP', {'make_delta': gc_module.make_delta,
                     'apply_delta': _groupcompress_py.apply_delta}),
             ])
     to_adapt, result = tests.split_suite_by_condition(
@@ -53,8 +54,8 @@
     return result
 
 
-compiled_groupcompress = tests.ModuleAvailableFeature(
-                            'bzrlib._groupcompress_pyx')
+compiled_groupcompress_feature = tests.ModuleAvailableFeature(
+                                    'bzrlib._groupcompress_pyx')
 
 _text1 = """\
 This is a bit
@@ -250,8 +251,8 @@
         # This test isn't multiplied, because we only have DeltaIndex for the
         # compiled form
         # We call this here, because _test_needs_features happens after setUp
-        self.requireFeature(compiled_groupcompress)
-        self._gc_module = compiled_groupcompress.module
+        self.requireFeature(compiled_groupcompress_feature)
+        self._gc_module = compiled_groupcompress_feature.module
 
     def test_repr(self):
         di = self._gc_module.DeltaIndex('test text\n')

=== modified file 'bzrlib/tests/test__known_graph.py'
--- a/bzrlib/tests/test__known_graph.py	2009-12-21 19:19:04 +0000
+++ b/bzrlib/tests/test__known_graph.py	2009-12-22 15:50:40 +0000
@@ -37,17 +37,17 @@
         ('python-nocache', {'module': _known_graph_py, 'do_cache': False}),
     ]
     suite = loader.suiteClass()
-    if compiled_known_graph.available():
-        scenarios.append(('C', {'module': compiled_known_graph.module,
+    if compiled_known_graph_feature.available():
+        scenarios.append(('C', {'module': compiled_known_graph_feature.module,
                                 'do_cache': True}))
         caching_scenarios.append(
-            ('C-nocache', {'module': compiled_known_graph.module,
+            ('C-nocache', {'module': compiled_known_graph_feature.module,
                            'do_cache': False}))
     else:
         # the compiled module isn't available, so we add a failing test
         class FailWithoutFeature(tests.TestCase):
             def test_fail(self):
-                self.requireFeature(compiled_known_graph)
+                self.requireFeature(compiled_known_graph_feature)
         suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
     # TestKnownGraphHeads needs to be permutated with and without caching.
     # All other TestKnownGraph tests only need to be tested across module
@@ -59,7 +59,8 @@
     return suite
 
 
-compiled_known_graph = tests.ModuleAvailableFeature('bzrlib._known_graph_pyx')
+compiled_known_graph_feature = tests.ModuleAvailableFeature(
+                                    'bzrlib._known_graph_pyx')
 
 
 #  a

=== modified file 'bzrlib/tests/test__rio.py'
--- a/bzrlib/tests/test__rio.py	2009-12-21 19:20:03 +0000
+++ b/bzrlib/tests/test__rio.py	2009-12-22 15:50:40 +0000
@@ -27,19 +27,19 @@
     suite = loader.suiteClass()
     import bzrlib._rio_py as py_module
     scenarios = [('python', {'module': py_module})]
-    if compiled_rio.available():
-        scenarios.append(('C', {'module': compiled_rio.module}))
+    if compiled_rio_feature.available():
+        scenarios.append(('C', {'module': compiled_rio_feature.module}))
     else:
         # the compiled module isn't available, so we add a failing test
         class FailWithoutFeature(tests.TestCase):
             def test_fail(self):
-                self.requireFeature(compiled_rio)
+                self.requireFeature(compiled_rio_feature)
         suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
     tests.multiply_tests(standard_tests, scenarios, suite)
     return suite
 
 
-compiled_rio = tests.ModuleAvailableFeature('bzrlib._rio_pyx')
+compiled_rio_feature = tests.ModuleAvailableFeature('bzrlib._rio_pyx')
 
 
 class TestValidTag(tests.TestCase):

=== modified file 'bzrlib/tests/test__simple_set.py'
--- a/bzrlib/tests/test__simple_set.py	2009-12-21 19:21:10 +0000
+++ b/bzrlib/tests/test__simple_set.py	2009-12-22 15:50:40 +0000
@@ -77,12 +77,13 @@
 
 # Even though this is an extension, we don't permute the tests for a python
 # version. As the plain python version is just a dict or set
-compiled_simpleset = tests.ModuleAvailableFeature('bzrlib._simple_set_pyx')
+compiled_simpleset_feature = tests.ModuleAvailableFeature(
+                                'bzrlib._simple_set_pyx')
 
 
 class TestSimpleSet(tests.TestCase):
 
-    _test_needs_features = [compiled_simpleset]
+    _test_needs_features = [compiled_simpleset_feature]
     module = _simple_set_pyx
 
     def assertIn(self, obj, container):

=== modified file 'bzrlib/tests/test__static_tuple.py'
--- a/bzrlib/tests/test__static_tuple.py	2009-12-21 19:17:10 +0000
+++ b/bzrlib/tests/test__static_tuple.py	2009-12-22 15:50:40 +0000
@@ -36,19 +36,21 @@
         ('python', {'module': _static_tuple_py}),
     ]
     suite = loader.suiteClass()
-    if compiled_static_tuple.available():
-        scenarios.append(('C', {'module': compiled_static_tuple.module}))
+    if compiled_static_tuple_feature.available():
+        scenarios.append(('C', {'module':
+                                compiled_static_tuple_feature.module}))
     else:
         # the compiled module isn't available, so we add a failing test
         class FailWithoutFeature(tests.TestCase):
             def test_fail(self):
-                self.requireFeature(compiled_static_tuple)
+                self.requireFeature(compiled_static_tuple_feature)
         suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
     result = tests.multiply_tests(standard_tests, scenarios, suite)
     return result
 
 
-compiled_static_tuple = tests.ModuleAvailableFeature('bzrlib._static_tuple_c')
+compiled_static_tuple_feature = tests.ModuleAvailableFeature(
+                                    'bzrlib._static_tuple_c')
 
 
 class _Meliae(tests.Feature):
@@ -628,7 +630,7 @@
         # Make sure the right implementation is available from
         # bzrlib.static_tuple.StaticTuple.
         if self.module is _static_tuple_py:
-            if compiled_static_tuple.available():
+            if compiled_static_tuple_feature.available():
                 # We will be using the C version
                 return
         self.assertIs(static_tuple.StaticTuple,

=== modified file 'bzrlib/tests/test_bencode.py'
--- a/bzrlib/tests/test_bencode.py	2009-12-21 19:41:38 +0000
+++ b/bzrlib/tests/test_bencode.py	2009-12-22 15:50:40 +0000
@@ -23,19 +23,19 @@
     suite = loader.suiteClass()
     import bzrlib.util._bencode_py as py_module
     scenarios = [('python', {'bencode': py_module})]
-    if compiled_bencode.available():
-        scenarios.append(('C', {'bencode': compiled_bencode.module}))
+    if compiled_bencode_feature.available():
+        scenarios.append(('C', {'bencode': compiled_bencode_feature.module}))
     else:
         # the compiled module isn't available, so we add a failing test
         class FailWithoutFeature(tests.TestCase):
             def test_fail(self):
-                self.requireFeature(compiled_bencode)
+                self.requireFeature(compiled_bencode_feature)
         suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
     tests.multiply_tests(standard_tests, scenarios, suite)
     return suite
 
 
-compiled_bencode = tests.ModuleAvailableFeature('bzrlib._bencode_pyx')
+compiled_bencode_feature = tests.ModuleAvailableFeature('bzrlib._bencode_pyx')
 
 
 class TestBencodeDecode(tests.TestCase):

=== modified file 'bzrlib/tests/test_btree_index.py'
--- a/bzrlib/tests/test_btree_index.py	2009-12-21 19:43:51 +0000
+++ b/bzrlib/tests/test_btree_index.py	2009-12-22 15:50:40 +0000
@@ -43,13 +43,14 @@
         condition_isinstance(TestBTreeNodes))
     import bzrlib._btree_serializer_py as py_module
     scenarios = [('python', {'parse_btree': py_module})]
-    if compiled_btreeparser.available():
-        scenarios.append(('C', {'parse_btree': compiled_btreeparser.module}))
+    if compiled_btreeparser_feature.available():
+        scenarios.append(('C', {'parse_btree':
+                                compiled_btreeparser_feature.module}))
     return multiply_tests(node_tests, scenarios, others)
 
 
-compiled_btreeparser = tests.ModuleAvailableFeature(
-                            'bzrlib._btree_serializer_pyx')
+compiled_btreeparser_feature = tests.ModuleAvailableFeature(
+                                'bzrlib._btree_serializer_pyx')
 
 
 class BTreeTestCase(TestCaseWithTransport):
@@ -1280,7 +1281,7 @@
     def test_exists(self):
         # This is just to let the user know if they don't have the feature
         # available
-        self.requireFeature(compiled_btreeparser)
+        self.requireFeature(compiled_btreeparser_feature)
 
 
 class TestMultiBisectRight(tests.TestCase):

=== modified file 'bzrlib/tests/test_diff.py'
--- a/bzrlib/tests/test_diff.py	2009-12-21 19:41:38 +0000
+++ b/bzrlib/tests/test_diff.py	2009-12-22 15:50:40 +0000
@@ -63,7 +63,8 @@
 AttribFeature = _AttribFeature()
 
 
-compiled_patiencediff = tests.ModuleAvailableFeature('bzrlib._patiencediff_c')
+compiled_patiencediff_feature = tests.ModuleAvailableFeature(
+                                    'bzrlib._patiencediff_c')
 
 
 def udiff_lines(old, new, allow_binary=False):
@@ -1144,7 +1145,7 @@
 
 class TestPatienceDiffLib_c(TestPatienceDiffLib):
 
-    _test_needs_features = [compiled_patiencediff]
+    _test_needs_features = [compiled_patiencediff_feature]
 
     def setUp(self):
         super(TestPatienceDiffLib_c, self).setUp()
@@ -1240,7 +1241,7 @@
 
 class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
 
-    _test_needs_features = [compiled_patiencediff]
+    _test_needs_features = [compiled_patiencediff_feature]
 
     def setUp(self):
         super(TestPatienceDiffLibFiles_c, self).setUp()
@@ -1252,7 +1253,7 @@
 class TestUsingCompiledIfAvailable(TestCase):
 
     def test_PatienceSequenceMatcher(self):
-        if compiled_patiencediff.available():
+        if compiled_patiencediff_feature.available():
             from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
             self.assertIs(PatienceSequenceMatcher_c,
                           bzrlib.patiencediff.PatienceSequenceMatcher)
@@ -1262,7 +1263,7 @@
                           bzrlib.patiencediff.PatienceSequenceMatcher)
 
     def test_unique_lcs(self):
-        if compiled_patiencediff.available():
+        if compiled_patiencediff_feature.available():
             from bzrlib._patiencediff_c import unique_lcs_c
             self.assertIs(unique_lcs_c,
                           bzrlib.patiencediff.unique_lcs)
@@ -1272,7 +1273,7 @@
                           bzrlib.patiencediff.unique_lcs)
 
     def test_recurse_matches(self):
-        if compiled_patiencediff.available():
+        if compiled_patiencediff_feature.available():
             from bzrlib._patiencediff_c import recurse_matches_c
             self.assertIs(recurse_matches_c,
                           bzrlib.patiencediff.recurse_matches)

=== modified file 'bzrlib/tests/test_knit.py'
--- a/bzrlib/tests/test_knit.py	2009-12-21 19:45:52 +0000
+++ b/bzrlib/tests/test_knit.py	2009-12-22 15:50:40 +0000
@@ -69,7 +69,8 @@
     )
 
 
-compiled_knit = tests.ModuleAvailableFeature('bzrlib._knit_load_data_pyx')
+compiled_knit_feature = tests.ModuleAvailableFeature(
+                            'bzrlib._knit_load_data_pyx')
 
 
 class KnitContentTestsMixin(object):
@@ -1296,7 +1297,7 @@
 
 class LowLevelKnitIndexTests_c(LowLevelKnitIndexTests):
 
-    _test_needs_features = [compiled_knit]
+    _test_needs_features = [compiled_knit_feature]
 
     def get_knit_index(self, transport, name, mode):
         mapper = ConstantMapper(name)

=== modified file 'bzrlib/tests/test_osutils.py'
--- a/bzrlib/tests/test_osutils.py	2009-12-21 17:38:05 +0000
+++ b/bzrlib/tests/test_osutils.py	2009-12-22 15:50:40 +0000
@@ -53,7 +53,7 @@
 
 UTF8DirReaderFeature = _UTF8DirReaderFeature()
 
-TermIOSFeature = tests.ModuleAvailableFeature('termios')
+term_ios_feature = tests.ModuleAvailableFeature('termios')
 
 
 def _already_unicode(s):
@@ -1987,8 +1987,8 @@
         self.assertEqual(None, osutils.terminal_width())
 
     def test_no_TIOCGWINSZ(self):
-        self.requireFeature(TermIOSFeature)
-        termios = TermIOSFeature.module
+        self.requireFeature(term_ios_feature)
+        termios = term_ios_feature.module
         # bug 63539 is about a termios without TIOCGWINSZ attribute
         try:
             orig = termios.TIOCGWINSZ



More information about the bazaar-commits mailing list