13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""Tests for the compiled dirstate helpers."""
23
22
from bzrlib import (
29
27
from bzrlib.tests import (
35
from bzrlib import _dirstate_helpers_pyx
36
has_dirstate_helpers_pyx = True
38
has_dirstate_helpers_pyx = False
41
compiled_dirstate_helpers_feature = tests.ModuleAvailableFeature(
42
'bzrlib._dirstate_helpers_pyx')
45
def load_tests(basic_tests, module, loader):
46
# FIXME: we should also parametrize against SHA1Provider !
47
suite = loader.suiteClass()
48
remaining_tests = basic_tests
50
dir_reader_scenarios = test_osutils.dir_reader_scenarios()
52
ue_scenarios = [('dirstate_Python',
53
{'update_entry': dirstate.py_update_entry})]
54
if compiled_dirstate_helpers_feature.available():
55
update_entry = compiled_dirstate_helpers_feature.module.update_entry
56
pyrex_scenario = ('dirstate_Pyrex', {'update_entry': update_entry})
57
ue_scenarios.append(pyrex_scenario)
58
process_entry_tests, remaining_tests = tests.split_suite_by_condition(
59
remaining_tests, tests.condition_isinstance(TestUpdateEntry))
60
tests.multiply_tests(process_entry_tests,
61
tests.multiply_scenarios(dir_reader_scenarios,
65
pe_scenarios = [('dirstate_Python',
66
{'_process_entry': dirstate.ProcessEntryPython})]
67
if compiled_dirstate_helpers_feature.available():
68
process_entry = compiled_dirstate_helpers_feature.module.ProcessEntryC
69
pyrex_scenario = ('dirstate_Pyrex', {'_process_entry': process_entry})
70
pe_scenarios.append(pyrex_scenario)
71
process_entry_tests, remaining_tests = tests.split_suite_by_condition(
72
remaining_tests, tests.condition_isinstance(TestProcessEntry))
73
tests.multiply_tests(process_entry_tests,
74
tests.multiply_scenarios(dir_reader_scenarios,
78
dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
79
remaining_tests, tests.condition_isinstance(
80
test_dirstate.TestCaseWithDirState))
81
tests.multiply_tests(dir_reader_tests, dir_reader_scenarios, suite)
82
suite.addTest(remaining_tests)
30
from bzrlib.tests import test_dirstate
33
class _CompiledDirstateHelpersFeature(tests.Feature):
36
import bzrlib._dirstate_helpers_c
41
def feature_name(self):
42
return 'bzrlib._dirstate_helpers_c'
44
CompiledDirstateHelpersFeature = _CompiledDirstateHelpersFeature()
87
47
class TestBisectPathMixin(object):
242
202
class TestBisectPathLeft(tests.TestCase, TestBisectPathMixin):
243
"""Run all Bisect Path tests against _bisect_path_left."""
203
"""Run all Bisect Path tests against _bisect_path_left_py."""
245
205
def get_bisect_path(self):
246
from bzrlib._dirstate_helpers_py import _bisect_path_left
247
return _bisect_path_left
206
from bzrlib._dirstate_helpers_py import _bisect_path_left_py
207
return _bisect_path_left_py
249
209
def get_bisect(self):
250
210
return bisect.bisect_left, 0
253
213
class TestCompiledBisectPathLeft(TestBisectPathLeft):
254
"""Run all Bisect Path tests against _bisect_path_lect"""
214
"""Run all Bisect Path tests against _bisect_path_right_c"""
256
_test_needs_features = [compiled_dirstate_helpers_feature]
216
_test_needs_features = [CompiledDirstateHelpersFeature]
258
218
def get_bisect_path(self):
259
from bzrlib._dirstate_helpers_pyx import _bisect_path_left
260
return _bisect_path_left
219
from bzrlib._dirstate_helpers_c import _bisect_path_left_c
220
return _bisect_path_left_c
263
223
class TestBisectPathRight(tests.TestCase, TestBisectPathMixin):
264
"""Run all Bisect Path tests against _bisect_path_right"""
224
"""Run all Bisect Path tests against _bisect_path_right_py"""
266
226
def get_bisect_path(self):
267
from bzrlib._dirstate_helpers_py import _bisect_path_right
268
return _bisect_path_right
227
from bzrlib._dirstate_helpers_py import _bisect_path_right_py
228
return _bisect_path_right_py
270
230
def get_bisect(self):
271
231
return bisect.bisect_right, -1
274
234
class TestCompiledBisectPathRight(TestBisectPathRight):
275
"""Run all Bisect Path tests against _bisect_path_right"""
235
"""Run all Bisect Path tests against _bisect_path_right_c"""
277
_test_needs_features = [compiled_dirstate_helpers_feature]
237
_test_needs_features = [CompiledDirstateHelpersFeature]
279
239
def get_bisect_path(self):
280
from bzrlib._dirstate_helpers_pyx import _bisect_path_right
281
return _bisect_path_right
240
from bzrlib._dirstate_helpers_c import _bisect_path_right_c
241
return _bisect_path_right_c
284
244
class TestBisectDirblock(tests.TestCase):
659
619
class TestCompiledCmpPathByDirblock(TestCmpPathByDirblock):
660
620
"""Test the pyrex implementation of _cmp_path_by_dirblock"""
662
_test_needs_features = [compiled_dirstate_helpers_feature]
622
_test_needs_features = [CompiledDirstateHelpersFeature]
664
624
def get_cmp_by_dirs(self):
665
from bzrlib._dirstate_helpers_pyx import _cmp_path_by_dirblock
666
return _cmp_path_by_dirblock
625
from bzrlib._dirstate_helpers_c import _cmp_path_by_dirblock_c
626
return _cmp_path_by_dirblock_c
669
629
class TestMemRChr(tests.TestCase):
670
630
"""Test memrchr functionality"""
672
_test_needs_features = [compiled_dirstate_helpers_feature]
632
_test_needs_features = [CompiledDirstateHelpersFeature]
674
634
def assertMemRChr(self, expected, s, c):
675
from bzrlib._dirstate_helpers_pyx import _py_memrchr
635
from bzrlib._dirstate_helpers_c import _py_memrchr
676
636
self.assertEqual(expected, _py_memrchr(s, c))
678
638
def test_missing(self):
757
713
class TestCompiledReadDirblocks(TestReadDirblocks):
758
714
"""Test the pyrex implementation of _read_dirblocks"""
760
_test_needs_features = [compiled_dirstate_helpers_feature]
716
_test_needs_features = [CompiledDirstateHelpersFeature]
762
718
def get_read_dirblocks(self):
763
from bzrlib._dirstate_helpers_pyx import _read_dirblocks
764
return _read_dirblocks
719
from bzrlib._dirstate_helpers_c import _read_dirblocks_c
720
return _read_dirblocks_c
767
723
class TestUsingCompiledIfAvailable(tests.TestCase):
768
724
"""Check that any compiled functions that are available are the default.
770
726
It is possible to have typos, etc in the import line, such that
771
_dirstate_helpers_pyx is actually available, but the compiled functions are
727
_dirstate_helpers_c is actually available, but the compiled functions are
775
731
def test_bisect_dirblock(self):
776
if compiled_dirstate_helpers_feature.available():
777
from bzrlib._dirstate_helpers_pyx import bisect_dirblock
732
if CompiledDirstateHelpersFeature.available():
733
from bzrlib._dirstate_helpers_c import bisect_dirblock_c
734
self.assertIs(bisect_dirblock_c, dirstate.bisect_dirblock)
779
from bzrlib._dirstate_helpers_py import bisect_dirblock
780
self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
736
from bzrlib._dirstate_helpers_py import bisect_dirblock_py
737
self.assertIs(bisect_dirblock_py, dirstate.bisect_dirblock)
782
739
def test__bisect_path_left(self):
783
if compiled_dirstate_helpers_feature.available():
784
from bzrlib._dirstate_helpers_pyx import _bisect_path_left
740
if CompiledDirstateHelpersFeature.available():
741
from bzrlib._dirstate_helpers_c import _bisect_path_left_c
742
self.assertIs(_bisect_path_left_c, dirstate._bisect_path_left)
786
from bzrlib._dirstate_helpers_py import _bisect_path_left
787
self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
744
from bzrlib._dirstate_helpers_py import _bisect_path_left_py
745
self.assertIs(_bisect_path_left_py, dirstate._bisect_path_left)
789
747
def test__bisect_path_right(self):
790
if compiled_dirstate_helpers_feature.available():
791
from bzrlib._dirstate_helpers_pyx import _bisect_path_right
748
if CompiledDirstateHelpersFeature.available():
749
from bzrlib._dirstate_helpers_c import _bisect_path_right_c
750
self.assertIs(_bisect_path_right_c, dirstate._bisect_path_right)
793
from bzrlib._dirstate_helpers_py import _bisect_path_right
794
self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
752
from bzrlib._dirstate_helpers_py import _bisect_path_right_py
753
self.assertIs(_bisect_path_right_py, dirstate._bisect_path_right)
796
755
def test_cmp_by_dirs(self):
797
if compiled_dirstate_helpers_feature.available():
798
from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
756
if CompiledDirstateHelpersFeature.available():
757
from bzrlib._dirstate_helpers_c import cmp_by_dirs_c
758
self.assertIs(cmp_by_dirs_c, dirstate.cmp_by_dirs)
800
from bzrlib._dirstate_helpers_py import cmp_by_dirs
801
self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
760
from bzrlib._dirstate_helpers_py import cmp_by_dirs_py
761
self.assertIs(cmp_by_dirs_py, dirstate.cmp_by_dirs)
803
763
def test__read_dirblocks(self):
804
if compiled_dirstate_helpers_feature.available():
805
from bzrlib._dirstate_helpers_pyx import _read_dirblocks
764
if CompiledDirstateHelpersFeature.available():
765
from bzrlib._dirstate_helpers_c import _read_dirblocks_c
766
self.assertIs(_read_dirblocks_c, dirstate._read_dirblocks)
807
from bzrlib._dirstate_helpers_py import _read_dirblocks
808
self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
768
from bzrlib._dirstate_helpers_py import _read_dirblocks_py
769
self.assertIs(_read_dirblocks_py, dirstate._read_dirblocks)
810
771
def test_update_entry(self):
811
if compiled_dirstate_helpers_feature.available():
812
from bzrlib._dirstate_helpers_pyx import update_entry
772
if CompiledDirstateHelpersFeature.available():
773
from bzrlib._dirstate_helpers_c import update_entry
774
self.assertIs(update_entry, dirstate.update_entry)
814
from bzrlib.dirstate import update_entry
815
self.assertIs(update_entry, dirstate.update_entry)
776
from bzrlib.dirstate import py_update_entry
777
self.assertIs(py_update_entry, dirstate.py_update_entry)
817
779
def test_process_entry(self):
818
if compiled_dirstate_helpers_feature.available():
819
from bzrlib._dirstate_helpers_pyx import ProcessEntryC
780
if CompiledDirstateHelpersFeature.available():
781
from bzrlib._dirstate_helpers_c import ProcessEntryC
820
782
self.assertIs(ProcessEntryC, dirstate._process_entry)
822
784
from bzrlib.dirstate import ProcessEntryPython
826
788
class TestUpdateEntry(test_dirstate.TestCaseWithDirState):
827
789
"""Test the DirState.update_entry functions"""
833
super(TestUpdateEntry, self).setUp()
834
self.overrideAttr(dirstate, 'update_entry', self.update_entry)
836
791
def get_state_with_a(self):
837
792
"""Create a DirState tracking a single object named 'a'"""
838
793
state = test_dirstate.InstrumentedDirState.initialize('dirstate')
839
794
self.addCleanup(state.unlock)
840
795
state.add('a', 'a-id', 'file', None, '')
841
796
entry = state._get_entry(0, path_utf8='a')
797
self.set_update_entry()
842
798
return state, entry
844
def test_observed_sha1_cachable(self):
845
state, entry = self.get_state_with_a()
846
atime = time.time() - 10
847
self.build_tree(['a'])
848
statvalue = os.lstat('a')
849
statvalue = test_dirstate._FakeStat(statvalue.st_size, atime, atime,
850
statvalue.st_dev, statvalue.st_ino, statvalue.st_mode)
851
state._observed_sha1(entry, "foo", statvalue)
852
self.assertEqual('foo', entry[1][0][1])
853
packed_stat = dirstate.pack_stat(statvalue)
854
self.assertEqual(packed_stat, entry[1][0][4])
856
def test_observed_sha1_not_cachable(self):
857
state, entry = self.get_state_with_a()
858
oldval = entry[1][0][1]
859
oldstat = entry[1][0][4]
860
self.build_tree(['a'])
861
statvalue = os.lstat('a')
862
state._observed_sha1(entry, "foo", statvalue)
863
self.assertEqual(oldval, entry[1][0][1])
864
self.assertEqual(oldstat, entry[1][0][4])
800
def set_update_entry(self):
801
self.update_entry = dirstate.py_update_entry
866
803
def test_update_entry(self):
867
state, _ = self.get_state_with_a()
868
tree = self.make_branch_and_tree('tree')
870
empty_revid = tree.commit('empty')
871
self.build_tree(['tree/a'])
872
tree.add(['a'], ['a-id'])
873
with_a_id = tree.commit('with_a')
874
self.addCleanup(tree.unlock)
875
state.set_parent_trees(
876
[(empty_revid, tree.branch.repository.revision_tree(empty_revid))],
878
entry = state._get_entry(0, path_utf8='a')
804
state, entry = self.get_state_with_a()
879
805
self.build_tree(['a'])
880
806
# Add one where we don't provide the stat or sha already
881
807
self.assertEqual(('', 'a', 'a-id'), entry[0])
882
self.assertEqual(('f', '', 0, False, dirstate.DirState.NULLSTAT),
808
self.assertEqual([('f', '', 0, False, dirstate.DirState.NULLSTAT)],
884
810
# Flush the buffers to disk
886
812
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
890
816
packed_stat = dirstate.pack_stat(stat_value)
891
817
link_or_sha1 = self.update_entry(state, entry, abspath='a',
892
818
stat_value=stat_value)
893
self.assertEqual(None, link_or_sha1)
819
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
895
# The dirblock entry should not have cached the file's sha1 (too new)
896
self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
822
# The dirblock entry should not cache the file's sha1
823
self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
898
825
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
899
826
state._dirblock_state)
900
827
mode = stat_value.st_mode
901
self.assertEqual([('is_exec', mode, False)], state._log)
828
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False)], state._log)
904
831
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
908
835
# so we will re-read the file. Roll the clock back so the file is
909
836
# guaranteed to look too new.
910
837
state.adjust_time(-10)
913
839
link_or_sha1 = self.update_entry(state, entry, abspath='a',
914
840
stat_value=stat_value)
915
self.assertEqual([('is_exec', mode, False)], state._log)
916
self.assertEqual(None, link_or_sha1)
841
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
842
('sha1', 'a'), ('is_exec', mode, False),
844
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
917
846
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
918
847
state._dirblock_state)
919
self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
848
self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
923
# If it is cachable (the clock has moved forward) but new it still
924
# won't calculate the sha or cache it.
852
# However, if we move the clock forward so the file is considered
853
# "stable", it should just cache the value.
925
854
state.adjust_time(+20)
927
link_or_sha1 = dirstate.update_entry(state, entry, abspath='a',
928
stat_value=stat_value)
929
self.assertEqual(None, link_or_sha1)
930
self.assertEqual([('is_exec', mode, False)], state._log)
931
self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
934
# If the file is no longer new, and the clock has been moved forward
935
# sufficiently, it will cache the sha.
937
state.set_parent_trees(
938
[(with_a_id, tree.branch.repository.revision_tree(with_a_id))],
940
entry = state._get_entry(0, path_utf8='a')
942
855
link_or_sha1 = self.update_entry(state, entry, abspath='a',
943
856
stat_value=stat_value)
944
857
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
946
self.assertEqual([('is_exec', mode, False), ('sha1', 'a')],
948
self.assertEqual(('f', link_or_sha1, 14, False, packed_stat),
859
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
860
('sha1', 'a'), ('is_exec', mode, False),
861
('sha1', 'a'), ('is_exec', mode, False),
863
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
951
866
# Subsequent calls will just return the cached value
953
867
link_or_sha1 = self.update_entry(state, entry, abspath='a',
954
868
stat_value=stat_value)
955
869
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
957
self.assertEqual([], state._log)
958
self.assertEqual(('f', link_or_sha1, 14, False, packed_stat),
871
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
872
('sha1', 'a'), ('is_exec', mode, False),
873
('sha1', 'a'), ('is_exec', mode, False),
875
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
961
878
def test_update_entry_symlink(self):
962
879
"""Update entry should read symlinks."""
963
self.requireFeature(tests.SymlinkFeature)
880
self.requireFeature(SymlinkFeature)
964
881
state, entry = self.get_state_with_a()
966
883
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1060
967
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1061
968
state._dirblock_state)
1063
def test_update_entry_tree_reference(self):
1064
state = test_dirstate.InstrumentedDirState.initialize('dirstate')
1065
self.addCleanup(state.unlock)
1066
state.add('r', 'r-id', 'tree-reference', None, '')
1067
self.build_tree(['r/'])
1068
entry = state._get_entry(0, path_utf8='r')
1069
self.do_update_entry(state, entry, 'r')
1070
entry = state._get_entry(0, path_utf8='r')
1071
self.assertEqual('t', entry[1][0][0])
1073
970
def create_and_test_file(self, state, entry):
1074
"""Create a file at 'a' and verify the state finds it during update.
971
"""Create a file at 'a' and verify the state finds it.
1076
973
The state should already be versioning *something* at 'a'. This makes
1077
974
sure that state.update_entry recognizes it as a file.
1205
1102
self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
1208
# Make the disk object look old enough to cache (but it won't cache the
1209
# sha as it is a new file).
1105
# Make the disk object look old enough to cache
1210
1106
state.adjust_time(+20)
1211
1107
digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1212
1108
self.update_entry(state, entry, abspath='a', stat_value=stat_value)
1213
self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
1216
def _prepare_tree(self):
1218
text = 'Hello World\n'
1219
tree = self.make_branch_and_tree('tree')
1220
self.build_tree_contents([('tree/a file', text)])
1221
tree.add('a file', 'a-file-id')
1222
# Note: dirstate does not sha prior to the first commit
1223
# so commit now in order for the test to work
1224
tree.commit('first')
1227
def test_sha1provider_sha1_used(self):
1228
tree, text = self._prepare_tree()
1229
state = dirstate.DirState.from_tree(tree, 'dirstate',
1230
UppercaseSHA1Provider())
1231
self.addCleanup(state.unlock)
1232
expected_sha = osutils.sha_string(text.upper() + "foo")
1233
entry = state._get_entry(0, path_utf8='a file')
1234
state._sha_cutoff_time()
1235
state._cutoff_time += 10
1236
sha1 = self.update_entry(state, entry, 'tree/a file',
1237
os.lstat('tree/a file'))
1238
self.assertEqual(expected_sha, sha1)
1240
def test_sha1provider_stat_and_sha1_used(self):
1241
tree, text = self._prepare_tree()
1243
self.addCleanup(tree.unlock)
1244
state = tree._current_dirstate()
1245
state._sha1_provider = UppercaseSHA1Provider()
1246
# If we used the standard provider, it would look like nothing has
1248
file_ids_changed = [change[0] for change
1249
in tree.iter_changes(tree.basis_tree())]
1250
self.assertEqual(['a-file-id'], file_ids_changed)
1253
class UppercaseSHA1Provider(dirstate.SHA1Provider):
1254
"""A custom SHA1Provider."""
1256
def sha1(self, abspath):
1257
return self.stat_and_sha1(abspath)[1]
1259
def stat_and_sha1(self, abspath):
1260
file_obj = file(abspath, 'rb')
1262
statvalue = os.fstat(file_obj.fileno())
1263
text = ''.join(file_obj.readlines())
1264
sha1 = osutils.sha_string(text.upper() + "foo")
1267
return statvalue, sha1
1270
class TestProcessEntry(test_dirstate.TestCaseWithDirState):
1273
_process_entry = None
1276
super(TestProcessEntry, self).setUp()
1277
self.overrideAttr(dirstate, '_process_entry', self._process_entry)
1279
def assertChangedFileIds(self, expected, tree):
1282
file_ids = [info[0] for info
1283
in tree.iter_changes(tree.basis_tree())]
1286
self.assertEqual(sorted(expected), sorted(file_ids))
1288
def test_exceptions_raised(self):
1289
# This is a direct test of bug #495023, it relies on osutils.is_inside
1290
# getting called in an inner function. Which makes it a bit brittle,
1291
# but at least it does reproduce the bug.
1292
tree = self.make_branch_and_tree('tree')
1293
self.build_tree(['tree/file', 'tree/dir/', 'tree/dir/sub',
1294
'tree/dir2/', 'tree/dir2/sub2'])
1295
tree.add(['file', 'dir', 'dir/sub', 'dir2', 'dir2/sub2'])
1296
tree.commit('first commit')
1298
self.addCleanup(tree.unlock)
1299
basis_tree = tree.basis_tree()
1300
def is_inside_raises(*args, **kwargs):
1301
raise RuntimeError('stop this')
1302
self.overrideAttr(osutils, 'is_inside', is_inside_raises)
1303
self.assertListRaises(RuntimeError, tree.iter_changes, basis_tree)
1305
def test_simple_changes(self):
1306
tree = self.make_branch_and_tree('tree')
1307
self.build_tree(['tree/file'])
1308
tree.add(['file'], ['file-id'])
1309
self.assertChangedFileIds([tree.get_root_id(), 'file-id'], tree)
1311
self.assertChangedFileIds([], tree)
1313
def test_sha1provider_stat_and_sha1_used(self):
1314
tree = self.make_branch_and_tree('tree')
1315
self.build_tree(['tree/file'])
1316
tree.add(['file'], ['file-id'])
1319
self.addCleanup(tree.unlock)
1320
state = tree._current_dirstate()
1321
state._sha1_provider = UppercaseSHA1Provider()
1322
self.assertChangedFileIds(['file-id'], tree)
1109
self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
1112
class TestCompiledUpdateEntry(TestUpdateEntry):
1113
"""Test the pyrex implementation of _read_dirblocks"""
1115
_test_needs_features = [CompiledDirstateHelpersFeature]
1117
def set_update_entry(self):
1118
from bzrlib._dirstate_helpers_c import update_entry
1119
self.update_entry = update_entry
added
removed
bzrlib/tests/test__dirstate_helpers.py
