23
23
from bzrlib import (
29
28
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)
31
from bzrlib.tests import test_dirstate
34
class _CompiledDirstateHelpersFeature(tests.Feature):
37
import bzrlib._dirstate_helpers_c
42
def feature_name(self):
43
return 'bzrlib._dirstate_helpers_c'
45
CompiledDirstateHelpersFeature = _CompiledDirstateHelpersFeature()
87
48
class TestBisectPathMixin(object):
242
203
class TestBisectPathLeft(tests.TestCase, TestBisectPathMixin):
243
"""Run all Bisect Path tests against _bisect_path_left."""
204
"""Run all Bisect Path tests against _bisect_path_left_py."""
245
206
def get_bisect_path(self):
246
from bzrlib._dirstate_helpers_py import _bisect_path_left
247
return _bisect_path_left
207
from bzrlib._dirstate_helpers_py import _bisect_path_left_py
208
return _bisect_path_left_py
249
210
def get_bisect(self):
250
211
return bisect.bisect_left, 0
253
214
class TestCompiledBisectPathLeft(TestBisectPathLeft):
254
"""Run all Bisect Path tests against _bisect_path_lect"""
215
"""Run all Bisect Path tests against _bisect_path_right_c"""
256
_test_needs_features = [compiled_dirstate_helpers_feature]
217
_test_needs_features = [CompiledDirstateHelpersFeature]
258
219
def get_bisect_path(self):
259
from bzrlib._dirstate_helpers_pyx import _bisect_path_left
260
return _bisect_path_left
220
from bzrlib._dirstate_helpers_c import _bisect_path_left_c
221
return _bisect_path_left_c
263
224
class TestBisectPathRight(tests.TestCase, TestBisectPathMixin):
264
"""Run all Bisect Path tests against _bisect_path_right"""
225
"""Run all Bisect Path tests against _bisect_path_right_py"""
266
227
def get_bisect_path(self):
267
from bzrlib._dirstate_helpers_py import _bisect_path_right
268
return _bisect_path_right
228
from bzrlib._dirstate_helpers_py import _bisect_path_right_py
229
return _bisect_path_right_py
270
231
def get_bisect(self):
271
232
return bisect.bisect_right, -1
274
235
class TestCompiledBisectPathRight(TestBisectPathRight):
275
"""Run all Bisect Path tests against _bisect_path_right"""
236
"""Run all Bisect Path tests against _bisect_path_right_c"""
277
_test_needs_features = [compiled_dirstate_helpers_feature]
238
_test_needs_features = [CompiledDirstateHelpersFeature]
279
240
def get_bisect_path(self):
280
from bzrlib._dirstate_helpers_pyx import _bisect_path_right
281
return _bisect_path_right
241
from bzrlib._dirstate_helpers_c import _bisect_path_right_c
242
return _bisect_path_right_c
284
245
class TestBisectDirblock(tests.TestCase):
659
620
class TestCompiledCmpPathByDirblock(TestCmpPathByDirblock):
660
621
"""Test the pyrex implementation of _cmp_path_by_dirblock"""
662
_test_needs_features = [compiled_dirstate_helpers_feature]
623
_test_needs_features = [CompiledDirstateHelpersFeature]
664
625
def get_cmp_by_dirs(self):
665
from bzrlib._dirstate_helpers_pyx import _cmp_path_by_dirblock
666
return _cmp_path_by_dirblock
626
from bzrlib._dirstate_helpers_c import _cmp_path_by_dirblock_c
627
return _cmp_path_by_dirblock_c
669
630
class TestMemRChr(tests.TestCase):
670
631
"""Test memrchr functionality"""
672
_test_needs_features = [compiled_dirstate_helpers_feature]
633
_test_needs_features = [CompiledDirstateHelpersFeature]
674
635
def assertMemRChr(self, expected, s, c):
675
from bzrlib._dirstate_helpers_pyx import _py_memrchr
636
from bzrlib._dirstate_helpers_c import _py_memrchr
676
637
self.assertEqual(expected, _py_memrchr(s, c))
678
639
def test_missing(self):
757
714
class TestCompiledReadDirblocks(TestReadDirblocks):
758
715
"""Test the pyrex implementation of _read_dirblocks"""
760
_test_needs_features = [compiled_dirstate_helpers_feature]
717
_test_needs_features = [CompiledDirstateHelpersFeature]
762
719
def get_read_dirblocks(self):
763
from bzrlib._dirstate_helpers_pyx import _read_dirblocks
764
return _read_dirblocks
720
from bzrlib._dirstate_helpers_c import _read_dirblocks_c
721
return _read_dirblocks_c
767
724
class TestUsingCompiledIfAvailable(tests.TestCase):
768
725
"""Check that any compiled functions that are available are the default.
770
727
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
728
_dirstate_helpers_c is actually available, but the compiled functions are
775
732
def test_bisect_dirblock(self):
776
if compiled_dirstate_helpers_feature.available():
777
from bzrlib._dirstate_helpers_pyx import bisect_dirblock
733
if CompiledDirstateHelpersFeature.available():
734
from bzrlib._dirstate_helpers_c import bisect_dirblock_c
735
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)
737
from bzrlib._dirstate_helpers_py import bisect_dirblock_py
738
self.assertIs(bisect_dirblock_py, dirstate.bisect_dirblock)
782
740
def test__bisect_path_left(self):
783
if compiled_dirstate_helpers_feature.available():
784
from bzrlib._dirstate_helpers_pyx import _bisect_path_left
741
if CompiledDirstateHelpersFeature.available():
742
from bzrlib._dirstate_helpers_c import _bisect_path_left_c
743
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)
745
from bzrlib._dirstate_helpers_py import _bisect_path_left_py
746
self.assertIs(_bisect_path_left_py, dirstate._bisect_path_left)
789
748
def test__bisect_path_right(self):
790
if compiled_dirstate_helpers_feature.available():
791
from bzrlib._dirstate_helpers_pyx import _bisect_path_right
749
if CompiledDirstateHelpersFeature.available():
750
from bzrlib._dirstate_helpers_c import _bisect_path_right_c
751
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)
753
from bzrlib._dirstate_helpers_py import _bisect_path_right_py
754
self.assertIs(_bisect_path_right_py, dirstate._bisect_path_right)
796
756
def test_cmp_by_dirs(self):
797
if compiled_dirstate_helpers_feature.available():
798
from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
757
if CompiledDirstateHelpersFeature.available():
758
from bzrlib._dirstate_helpers_c import cmp_by_dirs_c
759
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)
761
from bzrlib._dirstate_helpers_py import cmp_by_dirs_py
762
self.assertIs(cmp_by_dirs_py, dirstate.cmp_by_dirs)
803
764
def test__read_dirblocks(self):
804
if compiled_dirstate_helpers_feature.available():
805
from bzrlib._dirstate_helpers_pyx import _read_dirblocks
765
if CompiledDirstateHelpersFeature.available():
766
from bzrlib._dirstate_helpers_c import _read_dirblocks_c
767
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)
769
from bzrlib._dirstate_helpers_py import _read_dirblocks_py
770
self.assertIs(_read_dirblocks_py, dirstate._read_dirblocks)
810
772
def test_update_entry(self):
811
if compiled_dirstate_helpers_feature.available():
812
from bzrlib._dirstate_helpers_pyx import update_entry
773
if CompiledDirstateHelpersFeature.available():
774
from bzrlib._dirstate_helpers_c import update_entry
775
self.assertIs(update_entry, dirstate.update_entry)
814
from bzrlib.dirstate import update_entry
815
self.assertIs(update_entry, dirstate.update_entry)
777
from bzrlib.dirstate import py_update_entry
778
self.assertIs(py_update_entry, dirstate.py_update_entry)
817
780
def test_process_entry(self):
818
if compiled_dirstate_helpers_feature.available():
819
from bzrlib._dirstate_helpers_pyx import ProcessEntryC
781
if CompiledDirstateHelpersFeature.available():
782
from bzrlib._dirstate_helpers_c import ProcessEntryC
820
783
self.assertIs(ProcessEntryC, dirstate._process_entry)
822
785
from bzrlib.dirstate import ProcessEntryPython
826
789
class TestUpdateEntry(test_dirstate.TestCaseWithDirState):
827
790
"""Test the DirState.update_entry functions"""
833
super(TestUpdateEntry, self).setUp()
834
self.overrideAttr(dirstate, 'update_entry', self.update_entry)
836
792
def get_state_with_a(self):
837
793
"""Create a DirState tracking a single object named 'a'"""
838
794
state = test_dirstate.InstrumentedDirState.initialize('dirstate')
839
795
self.addCleanup(state.unlock)
840
796
state.add('a', 'a-id', 'file', None, '')
841
797
entry = state._get_entry(0, path_utf8='a')
798
self.set_update_entry()
842
799
return state, entry
801
def set_update_entry(self):
802
self.update_entry = dirstate.py_update_entry
844
804
def test_observed_sha1_cachable(self):
845
805
state, entry = self.get_state_with_a()
846
806
atime = time.time() - 10
864
824
self.assertEqual(oldstat, entry[1][0][4])
866
826
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')
827
state, entry = self.get_state_with_a()
879
828
self.build_tree(['a'])
880
829
# Add one where we don't provide the stat or sha already
881
830
self.assertEqual(('', 'a', 'a-id'), entry[0])
882
self.assertEqual(('f', '', 0, False, dirstate.DirState.NULLSTAT),
831
self.assertEqual([('f', '', 0, False, dirstate.DirState.NULLSTAT)],
884
833
# Flush the buffers to disk
886
835
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
890
839
packed_stat = dirstate.pack_stat(stat_value)
891
840
link_or_sha1 = self.update_entry(state, entry, abspath='a',
892
841
stat_value=stat_value)
893
self.assertEqual(None, link_or_sha1)
842
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),
845
# The dirblock entry should not cache the file's sha1
846
self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
898
848
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
899
849
state._dirblock_state)
900
850
mode = stat_value.st_mode
901
self.assertEqual([('is_exec', mode, False)], state._log)
851
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False)], state._log)
904
854
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
908
858
# so we will re-read the file. Roll the clock back so the file is
909
859
# guaranteed to look too new.
910
860
state.adjust_time(-10)
913
862
link_or_sha1 = self.update_entry(state, entry, abspath='a',
914
863
stat_value=stat_value)
915
self.assertEqual([('is_exec', mode, False)], state._log)
916
self.assertEqual(None, link_or_sha1)
864
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
865
('sha1', 'a'), ('is_exec', mode, False),
867
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
917
869
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
918
870
state._dirblock_state)
919
self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
871
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.
875
# However, if we move the clock forward so the file is considered
876
# "stable", it should just cache the value.
925
877
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
878
link_or_sha1 = self.update_entry(state, entry, abspath='a',
943
879
stat_value=stat_value)
944
880
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
946
self.assertEqual([('is_exec', mode, False), ('sha1', 'a')],
948
self.assertEqual(('f', link_or_sha1, 14, False, packed_stat),
882
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
883
('sha1', 'a'), ('is_exec', mode, False),
884
('sha1', 'a'), ('is_exec', mode, False),
886
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
951
889
# Subsequent calls will just return the cached value
953
890
link_or_sha1 = self.update_entry(state, entry, abspath='a',
954
891
stat_value=stat_value)
955
892
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
957
self.assertEqual([], state._log)
958
self.assertEqual(('f', link_or_sha1, 14, False, packed_stat),
894
self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
895
('sha1', 'a'), ('is_exec', mode, False),
896
('sha1', 'a'), ('is_exec', mode, False),
898
self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
961
901
def test_update_entry_symlink(self):
962
902
"""Update entry should read symlinks."""
963
self.requireFeature(tests.SymlinkFeature)
903
self.requireFeature(SymlinkFeature)
964
904
state, entry = self.get_state_with_a()
966
906
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1060
990
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1061
991
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
993
def create_and_test_file(self, state, entry):
1074
"""Create a file at 'a' and verify the state finds it during update.
994
"""Create a file at 'a' and verify the state finds it.
1076
996
The state should already be versioning *something* at 'a'. This makes
1077
997
sure that state.update_entry recognizes it as a file.
1205
1125
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).
1128
# Make the disk object look old enough to cache
1210
1129
state.adjust_time(+20)
1211
1130
digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1212
1131
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)
1132
self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
1135
class TestCompiledUpdateEntry(TestUpdateEntry):
1136
"""Test the pyrex implementation of _read_dirblocks"""
1138
_test_needs_features = [CompiledDirstateHelpersFeature]
1140
def set_update_entry(self):
1141
from bzrlib._dirstate_helpers_c import update_entry
1142
self.update_entry = update_entry
added
removed
bzrlib/tests/test__dirstate_helpers.py
