23
23
from bzrlib import (
28
29
from bzrlib.tests import (
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()
32
from bzrlib.tests.test_osutils import dir_reader_scenarios
33
from bzrlib.tests.scenarios import (
34
load_tests_apply_scenarios,
37
from bzrlib.tests import (
42
load_tests = load_tests_apply_scenarios
45
compiled_dirstate_helpers_feature = features.ModuleAvailableFeature(
46
'bzrlib._dirstate_helpers_pyx')
49
# FIXME: we should also parametrize against SHA1Provider !
51
ue_scenarios = [('dirstate_Python',
52
{'update_entry': dirstate.py_update_entry})]
53
if compiled_dirstate_helpers_feature.available():
54
update_entry = compiled_dirstate_helpers_feature.module.update_entry
55
ue_scenarios.append(('dirstate_Pyrex', {'update_entry': update_entry}))
57
pe_scenarios = [('dirstate_Python',
58
{'_process_entry': dirstate.ProcessEntryPython})]
59
if compiled_dirstate_helpers_feature.available():
60
process_entry = compiled_dirstate_helpers_feature.module.ProcessEntryC
61
pe_scenarios.append(('dirstate_Pyrex', {'_process_entry': process_entry}))
48
64
class TestBisectPathMixin(object):
203
219
class TestBisectPathLeft(tests.TestCase, TestBisectPathMixin):
204
"""Run all Bisect Path tests against _bisect_path_left_py."""
220
"""Run all Bisect Path tests against _bisect_path_left."""
206
222
def get_bisect_path(self):
207
from bzrlib._dirstate_helpers_py import _bisect_path_left_py
208
return _bisect_path_left_py
223
from bzrlib._dirstate_helpers_py import _bisect_path_left
224
return _bisect_path_left
210
226
def get_bisect(self):
211
227
return bisect.bisect_left, 0
214
230
class TestCompiledBisectPathLeft(TestBisectPathLeft):
215
"""Run all Bisect Path tests against _bisect_path_right_c"""
231
"""Run all Bisect Path tests against _bisect_path_lect"""
217
_test_needs_features = [CompiledDirstateHelpersFeature]
233
_test_needs_features = [compiled_dirstate_helpers_feature]
219
235
def get_bisect_path(self):
220
from bzrlib._dirstate_helpers_c import _bisect_path_left_c
221
return _bisect_path_left_c
236
from bzrlib._dirstate_helpers_pyx import _bisect_path_left
237
return _bisect_path_left
224
240
class TestBisectPathRight(tests.TestCase, TestBisectPathMixin):
225
"""Run all Bisect Path tests against _bisect_path_right_py"""
241
"""Run all Bisect Path tests against _bisect_path_right"""
227
243
def get_bisect_path(self):
228
from bzrlib._dirstate_helpers_py import _bisect_path_right_py
229
return _bisect_path_right_py
244
from bzrlib._dirstate_helpers_py import _bisect_path_right
245
return _bisect_path_right
231
247
def get_bisect(self):
232
248
return bisect.bisect_right, -1
235
251
class TestCompiledBisectPathRight(TestBisectPathRight):
236
"""Run all Bisect Path tests against _bisect_path_right_c"""
252
"""Run all Bisect Path tests against _bisect_path_right"""
238
_test_needs_features = [CompiledDirstateHelpersFeature]
254
_test_needs_features = [compiled_dirstate_helpers_feature]
240
256
def get_bisect_path(self):
241
from bzrlib._dirstate_helpers_c import _bisect_path_right_c
242
return _bisect_path_right_c
257
from bzrlib._dirstate_helpers_pyx import _bisect_path_right
258
return _bisect_path_right
245
261
class TestBisectDirblock(tests.TestCase):
620
636
class TestCompiledCmpPathByDirblock(TestCmpPathByDirblock):
621
637
"""Test the pyrex implementation of _cmp_path_by_dirblock"""
623
_test_needs_features = [CompiledDirstateHelpersFeature]
639
_test_needs_features = [compiled_dirstate_helpers_feature]
625
641
def get_cmp_by_dirs(self):
626
from bzrlib._dirstate_helpers_c import _cmp_path_by_dirblock_c
627
return _cmp_path_by_dirblock_c
642
from bzrlib._dirstate_helpers_pyx import _cmp_path_by_dirblock
643
return _cmp_path_by_dirblock
630
646
class TestMemRChr(tests.TestCase):
631
647
"""Test memrchr functionality"""
633
_test_needs_features = [CompiledDirstateHelpersFeature]
649
_test_needs_features = [compiled_dirstate_helpers_feature]
635
651
def assertMemRChr(self, expected, s, c):
636
from bzrlib._dirstate_helpers_c import _py_memrchr
652
from bzrlib._dirstate_helpers_pyx import _py_memrchr
637
653
self.assertEqual(expected, _py_memrchr(s, c))
639
655
def test_missing(self):
714
736
class TestCompiledReadDirblocks(TestReadDirblocks):
715
737
"""Test the pyrex implementation of _read_dirblocks"""
717
_test_needs_features = [CompiledDirstateHelpersFeature]
739
_test_needs_features = [compiled_dirstate_helpers_feature]
719
741
def get_read_dirblocks(self):
720
from bzrlib._dirstate_helpers_c import _read_dirblocks_c
721
return _read_dirblocks_c
742
from bzrlib._dirstate_helpers_pyx import _read_dirblocks
743
return _read_dirblocks
724
746
class TestUsingCompiledIfAvailable(tests.TestCase):
725
747
"""Check that any compiled functions that are available are the default.
727
749
It is possible to have typos, etc in the import line, such that
728
_dirstate_helpers_c is actually available, but the compiled functions are
750
_dirstate_helpers_pyx is actually available, but the compiled functions are
732
754
def test_bisect_dirblock(self):
733
if CompiledDirstateHelpersFeature.available():
734
from bzrlib._dirstate_helpers_c import bisect_dirblock_c
735
self.assertIs(bisect_dirblock_c, dirstate.bisect_dirblock)
755
if compiled_dirstate_helpers_feature.available():
756
from bzrlib._dirstate_helpers_pyx import bisect_dirblock
737
from bzrlib._dirstate_helpers_py import bisect_dirblock_py
738
self.assertIs(bisect_dirblock_py, dirstate.bisect_dirblock)
758
from bzrlib._dirstate_helpers_py import bisect_dirblock
759
self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
740
761
def test__bisect_path_left(self):
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)
762
if compiled_dirstate_helpers_feature.available():
763
from bzrlib._dirstate_helpers_pyx import _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)
765
from bzrlib._dirstate_helpers_py import _bisect_path_left
766
self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
748
768
def test__bisect_path_right(self):
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)
769
if compiled_dirstate_helpers_feature.available():
770
from bzrlib._dirstate_helpers_pyx import _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)
772
from bzrlib._dirstate_helpers_py import _bisect_path_right
773
self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
756
775
def test_cmp_by_dirs(self):
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)
776
if compiled_dirstate_helpers_feature.available():
777
from bzrlib._dirstate_helpers_pyx import 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)
779
from bzrlib._dirstate_helpers_py import cmp_by_dirs
780
self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
764
782
def test__read_dirblocks(self):
765
if CompiledDirstateHelpersFeature.available():
766
from bzrlib._dirstate_helpers_c import _read_dirblocks_c
767
self.assertIs(_read_dirblocks_c, dirstate._read_dirblocks)
783
if compiled_dirstate_helpers_feature.available():
784
from bzrlib._dirstate_helpers_pyx import _read_dirblocks
769
from bzrlib._dirstate_helpers_py import _read_dirblocks_py
770
self.assertIs(_read_dirblocks_py, dirstate._read_dirblocks)
786
from bzrlib._dirstate_helpers_py import _read_dirblocks
787
self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
772
789
def test_update_entry(self):
773
if CompiledDirstateHelpersFeature.available():
774
from bzrlib._dirstate_helpers_c import update_entry
775
self.assertIs(update_entry, dirstate.update_entry)
790
if compiled_dirstate_helpers_feature.available():
791
from bzrlib._dirstate_helpers_pyx import update_entry
777
from bzrlib.dirstate import py_update_entry
778
self.assertIs(py_update_entry, dirstate.py_update_entry)
793
from bzrlib.dirstate import update_entry
794
self.assertIs(update_entry, dirstate.update_entry)
780
796
def test_process_entry(self):
781
if CompiledDirstateHelpersFeature.available():
782
from bzrlib._dirstate_helpers_c import ProcessEntryC
797
if compiled_dirstate_helpers_feature.available():
798
from bzrlib._dirstate_helpers_pyx import ProcessEntryC
783
799
self.assertIs(ProcessEntryC, dirstate._process_entry)
785
801
from bzrlib.dirstate import ProcessEntryPython
789
805
class TestUpdateEntry(test_dirstate.TestCaseWithDirState):
790
806
"""Test the DirState.update_entry functions"""
808
scenarios = multiply_scenarios(
809
dir_reader_scenarios(), ue_scenarios)
815
super(TestUpdateEntry, self).setUp()
816
self.overrideAttr(dirstate, 'update_entry', self.update_entry)
792
818
def get_state_with_a(self):
793
819
"""Create a DirState tracking a single object named 'a'"""
794
820
state = test_dirstate.InstrumentedDirState.initialize('dirstate')
795
821
self.addCleanup(state.unlock)
796
822
state.add('a', 'a-id', 'file', None, '')
797
823
entry = state._get_entry(0, path_utf8='a')
798
self.set_update_entry()
799
824
return state, entry
801
def set_update_entry(self):
802
self.update_entry = dirstate.py_update_entry
804
826
def test_observed_sha1_cachable(self):
805
827
state, entry = self.get_state_with_a()
806
829
atime = time.time() - 10
807
830
self.build_tree(['a'])
808
statvalue = os.lstat('a')
809
statvalue = test_dirstate._FakeStat(statvalue.st_size, atime, atime,
810
statvalue.st_dev, statvalue.st_ino, statvalue.st_mode)
831
statvalue = test_dirstate._FakeStat.from_stat(os.lstat('a'))
832
statvalue.st_mtime = statvalue.st_ctime = atime
833
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
834
state._dirblock_state)
811
835
state._observed_sha1(entry, "foo", statvalue)
812
836
self.assertEqual('foo', entry[1][0][1])
813
837
packed_stat = dirstate.pack_stat(statvalue)
814
838
self.assertEqual(packed_stat, entry[1][0][4])
839
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
840
state._dirblock_state)
816
842
def test_observed_sha1_not_cachable(self):
817
843
state, entry = self.get_state_with_a()
818
845
oldval = entry[1][0][1]
819
846
oldstat = entry[1][0][4]
820
847
self.build_tree(['a'])
821
848
statvalue = os.lstat('a')
849
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
850
state._dirblock_state)
822
851
state._observed_sha1(entry, "foo", statvalue)
823
852
self.assertEqual(oldval, entry[1][0][1])
824
853
self.assertEqual(oldstat, entry[1][0][4])
854
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
855
state._dirblock_state)
826
857
def test_update_entry(self):
827
858
state, _ = self.get_state_with_a()
937
971
# Dirblock is not updated (the link is too new)
938
972
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
940
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
974
# The file entry turned into a symlink, that is considered
975
# HASH modified worthy.
976
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
941
977
state._dirblock_state)
943
979
# Because the stat_value looks new, we should re-read the target
944
981
link_or_sha1 = self.update_entry(state, entry, abspath='a',
945
982
stat_value=stat_value)
946
983
self.assertEqual('target', link_or_sha1)
947
self.assertEqual([('read_link', 'a', ''),
948
('read_link', 'a', ''),
984
self.assertEqual([('read_link', 'a', '')], state._log)
950
985
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
952
988
state.adjust_time(+20) # Skip into the future, all files look old
953
990
link_or_sha1 = self.update_entry(state, entry, abspath='a',
954
991
stat_value=stat_value)
992
# The symlink stayed a symlink. So while it is new enough to cache, we
993
# don't bother setting the flag, because it is not really worth saving
994
# (when we stat the symlink, we'll have paged in the target.)
995
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
996
state._dirblock_state)
955
997
self.assertEqual('target', link_or_sha1)
956
998
# We need to re-read the link because only now can we cache it
957
self.assertEqual([('read_link', 'a', ''),
958
('read_link', 'a', ''),
959
('read_link', 'a', ''),
999
self.assertEqual([('read_link', 'a', '')], state._log)
961
1000
self.assertEqual([('l', 'target', 6, False, packed_stat)],
964
1004
# Another call won't re-read the link
965
self.assertEqual([('read_link', 'a', ''),
966
('read_link', 'a', ''),
967
('read_link', 'a', ''),
1005
self.assertEqual([], state._log)
969
1006
link_or_sha1 = self.update_entry(state, entry, abspath='a',
970
1007
stat_value=stat_value)
971
1008
self.assertEqual('target', link_or_sha1)
986
1023
self.build_tree(['a/'])
987
1024
state.adjust_time(+20)
988
1025
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1026
# a/ used to be a file, but is now a directory, worth saving
989
1027
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
990
1028
state._dirblock_state)
992
1030
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
993
1031
state._dirblock_state)
994
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1032
# No changes to a/ means not worth saving.
1033
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1034
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1035
state._dirblock_state)
1036
# Change the last-modified time for the directory
1037
t = time.time() - 100.0
1039
os.utime('a', (t, t))
1041
# It looks like Win32 + FAT doesn't allow to change times on a dir.
1042
raise tests.TestSkipped("can't update mtime of a dir on FAT")
1043
saved_packed_stat = entry[1][0][-1]
1044
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1045
# We *do* go ahead and update the information in the dirblocks, but we
1046
# don't bother setting IN_MEMORY_MODIFIED because it is trivial to
1048
self.assertNotEqual(saved_packed_stat, entry[1][0][-1])
995
1049
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
996
1050
state._dirblock_state)
1154
1219
self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
1157
# Make the disk object look old enough to cache (but it won't cache the sha
1158
# as it is a new file).
1222
# Make the disk object look old enough to cache (but it won't cache the
1223
# sha as it is a new file).
1159
1224
state.adjust_time(+20)
1160
1225
digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1161
1226
self.update_entry(state, entry, abspath='a', stat_value=stat_value)
1162
1227
self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
1166
class TestCompiledUpdateEntry(TestUpdateEntry):
1167
"""Test the pyrex implementation of _read_dirblocks"""
1169
_test_needs_features = [CompiledDirstateHelpersFeature]
1171
def set_update_entry(self):
1172
from bzrlib._dirstate_helpers_c import update_entry
1173
self.update_entry = update_entry
1230
def _prepare_tree(self):
1232
text = 'Hello World\n'
1233
tree = self.make_branch_and_tree('tree')
1234
self.build_tree_contents([('tree/a file', text)])
1235
tree.add('a file', 'a-file-id')
1236
# Note: dirstate does not sha prior to the first commit
1237
# so commit now in order for the test to work
1238
tree.commit('first')
1241
def test_sha1provider_sha1_used(self):
1242
tree, text = self._prepare_tree()
1243
state = dirstate.DirState.from_tree(tree, 'dirstate',
1244
UppercaseSHA1Provider())
1245
self.addCleanup(state.unlock)
1246
expected_sha = osutils.sha_string(text.upper() + "foo")
1247
entry = state._get_entry(0, path_utf8='a file')
1248
state._sha_cutoff_time()
1249
state._cutoff_time += 10
1250
sha1 = self.update_entry(state, entry, 'tree/a file',
1251
os.lstat('tree/a file'))
1252
self.assertEqual(expected_sha, sha1)
1254
def test_sha1provider_stat_and_sha1_used(self):
1255
tree, text = self._prepare_tree()
1257
self.addCleanup(tree.unlock)
1258
state = tree._current_dirstate()
1259
state._sha1_provider = UppercaseSHA1Provider()
1260
# If we used the standard provider, it would look like nothing has
1262
file_ids_changed = [change[0] for change
1263
in tree.iter_changes(tree.basis_tree())]
1264
self.assertEqual(['a-file-id'], file_ids_changed)
1267
class UppercaseSHA1Provider(dirstate.SHA1Provider):
1268
"""A custom SHA1Provider."""
1270
def sha1(self, abspath):
1271
return self.stat_and_sha1(abspath)[1]
1273
def stat_and_sha1(self, abspath):
1274
file_obj = file(abspath, 'rb')
1276
statvalue = os.fstat(file_obj.fileno())
1277
text = ''.join(file_obj.readlines())
1278
sha1 = osutils.sha_string(text.upper() + "foo")
1281
return statvalue, sha1
1284
class TestProcessEntry(test_dirstate.TestCaseWithDirState):
1286
scenarios = multiply_scenarios(dir_reader_scenarios(), pe_scenarios)
1289
_process_entry = None
1292
super(TestProcessEntry, self).setUp()
1293
self.overrideAttr(dirstate, '_process_entry', self._process_entry)
1295
def assertChangedFileIds(self, expected, tree):
1298
file_ids = [info[0] for info
1299
in tree.iter_changes(tree.basis_tree())]
1302
self.assertEqual(sorted(expected), sorted(file_ids))
1304
def test_exceptions_raised(self):
1305
# This is a direct test of bug #495023, it relies on osutils.is_inside
1306
# getting called in an inner function. Which makes it a bit brittle,
1307
# but at least it does reproduce the bug.
1308
tree = self.make_branch_and_tree('tree')
1309
self.build_tree(['tree/file', 'tree/dir/', 'tree/dir/sub',
1310
'tree/dir2/', 'tree/dir2/sub2'])
1311
tree.add(['file', 'dir', 'dir/sub', 'dir2', 'dir2/sub2'])
1312
tree.commit('first commit')
1314
self.addCleanup(tree.unlock)
1315
basis_tree = tree.basis_tree()
1316
def is_inside_raises(*args, **kwargs):
1317
raise RuntimeError('stop this')
1318
self.overrideAttr(osutils, 'is_inside', is_inside_raises)
1319
self.assertListRaises(RuntimeError, tree.iter_changes, basis_tree)
1321
def test_simple_changes(self):
1322
tree = self.make_branch_and_tree('tree')
1323
self.build_tree(['tree/file'])
1324
tree.add(['file'], ['file-id'])
1325
self.assertChangedFileIds([tree.get_root_id(), 'file-id'], tree)
1327
self.assertChangedFileIds([], tree)
1329
def test_sha1provider_stat_and_sha1_used(self):
1330
tree = self.make_branch_and_tree('tree')
1331
self.build_tree(['tree/file'])
1332
tree.add(['file'], ['file-id'])
1335
self.addCleanup(tree.unlock)
1336
state = tree._current_dirstate()
1337
state._sha1_provider = UppercaseSHA1Provider()
1338
self.assertChangedFileIds(['file-id'], tree)
added
removed
bzrlib/tests/test__dirstate_helpers.py
