691
735
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
692
736
state._dirblock_state)
738
def test_trailing_garbage(self):
739
tree, state, expected = self.create_basic_dirstate()
740
# On Linux, we can write extra data as long as we haven't read yet, but
741
# on Win32, if you've opened the file with FILE_SHARE_READ, trying to
742
# open it in append mode will fail.
744
f = open('dirstate', 'ab')
746
# Add bogus trailing garbage
751
e = self.assertRaises(errors.DirstateCorrupt,
752
state._read_dirblocks_if_needed)
753
# Make sure we mention the bogus characters in the error
754
self.assertContainsRe(str(e), 'bogus')
695
757
class TestCompiledReadDirblocks(TestReadDirblocks):
696
758
"""Test the pyrex implementation of _read_dirblocks"""
698
_test_needs_features = [CompiledDirstateHelpersFeature]
760
_test_needs_features = [compiled_dirstate_helpers_feature]
700
762
def get_read_dirblocks(self):
701
from bzrlib._dirstate_helpers_c import _read_dirblocks_c
702
return _read_dirblocks_c
763
from bzrlib._dirstate_helpers_pyx import _read_dirblocks
764
return _read_dirblocks
705
767
class TestUsingCompiledIfAvailable(tests.TestCase):
706
768
"""Check that any compiled functions that are available are the default.
708
770
It is possible to have typos, etc in the import line, such that
709
_dirstate_helpers_c is actually available, but the compiled functions are
771
_dirstate_helpers_pyx is actually available, but the compiled functions are
713
775
def test_bisect_dirblock(self):
714
if CompiledDirstateHelpersFeature.available():
715
from bzrlib._dirstate_helpers_c import bisect_dirblock_c
716
self.assertIs(bisect_dirblock_c, dirstate.bisect_dirblock)
776
if compiled_dirstate_helpers_feature.available():
777
from bzrlib._dirstate_helpers_pyx import bisect_dirblock
718
from bzrlib._dirstate_helpers_py import bisect_dirblock_py
719
self.assertIs(bisect_dirblock_py, dirstate.bisect_dirblock)
779
from bzrlib._dirstate_helpers_py import bisect_dirblock
780
self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
721
782
def test__bisect_path_left(self):
722
if CompiledDirstateHelpersFeature.available():
723
from bzrlib._dirstate_helpers_c import _bisect_path_left_c
724
self.assertIs(_bisect_path_left_c, dirstate._bisect_path_left)
783
if compiled_dirstate_helpers_feature.available():
784
from bzrlib._dirstate_helpers_pyx import _bisect_path_left
726
from bzrlib._dirstate_helpers_py import _bisect_path_left_py
727
self.assertIs(_bisect_path_left_py, dirstate._bisect_path_left)
786
from bzrlib._dirstate_helpers_py import _bisect_path_left
787
self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
729
789
def test__bisect_path_right(self):
730
if CompiledDirstateHelpersFeature.available():
731
from bzrlib._dirstate_helpers_c import _bisect_path_right_c
732
self.assertIs(_bisect_path_right_c, dirstate._bisect_path_right)
790
if compiled_dirstate_helpers_feature.available():
791
from bzrlib._dirstate_helpers_pyx import _bisect_path_right
734
from bzrlib._dirstate_helpers_py import _bisect_path_right_py
735
self.assertIs(_bisect_path_right_py, dirstate._bisect_path_right)
793
from bzrlib._dirstate_helpers_py import _bisect_path_right
794
self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
737
796
def test_cmp_by_dirs(self):
738
if CompiledDirstateHelpersFeature.available():
739
from bzrlib._dirstate_helpers_c import cmp_by_dirs_c
740
self.assertIs(cmp_by_dirs_c, dirstate.cmp_by_dirs)
797
if compiled_dirstate_helpers_feature.available():
798
from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
742
from bzrlib._dirstate_helpers_py import cmp_by_dirs_py
743
self.assertIs(cmp_by_dirs_py, dirstate.cmp_by_dirs)
800
from bzrlib._dirstate_helpers_py import cmp_by_dirs
801
self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
745
803
def test__read_dirblocks(self):
746
if CompiledDirstateHelpersFeature.available():
747
from bzrlib._dirstate_helpers_c import _read_dirblocks_c
748
self.assertIs(_read_dirblocks_c, dirstate._read_dirblocks)
750
from bzrlib._dirstate_helpers_py import _read_dirblocks_py
751
self.assertIs(_read_dirblocks_py, dirstate._read_dirblocks)
804
if compiled_dirstate_helpers_feature.available():
805
from bzrlib._dirstate_helpers_pyx import _read_dirblocks
807
from bzrlib._dirstate_helpers_py import _read_dirblocks
808
self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
810
def test_update_entry(self):
811
if compiled_dirstate_helpers_feature.available():
812
from bzrlib._dirstate_helpers_pyx import update_entry
814
from bzrlib.dirstate import update_entry
815
self.assertIs(update_entry, dirstate.update_entry)
817
def test_process_entry(self):
818
if compiled_dirstate_helpers_feature.available():
819
from bzrlib._dirstate_helpers_pyx import ProcessEntryC
820
self.assertIs(ProcessEntryC, dirstate._process_entry)
822
from bzrlib.dirstate import ProcessEntryPython
823
self.assertIs(ProcessEntryPython, dirstate._process_entry)
826
class TestUpdateEntry(test_dirstate.TestCaseWithDirState):
827
"""Test the DirState.update_entry functions"""
833
super(TestUpdateEntry, self).setUp()
834
self.overrideAttr(dirstate, 'update_entry', self.update_entry)
836
def get_state_with_a(self):
837
"""Create a DirState tracking a single object named 'a'"""
838
state = test_dirstate.InstrumentedDirState.initialize('dirstate')
839
self.addCleanup(state.unlock)
840
state.add('a', 'a-id', 'file', None, '')
841
entry = state._get_entry(0, path_utf8='a')
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])
866
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')
879
self.build_tree(['a'])
880
# Add one where we don't provide the stat or sha already
881
self.assertEqual(('', 'a', 'a-id'), entry[0])
882
self.assertEqual(('f', '', 0, False, dirstate.DirState.NULLSTAT),
884
# Flush the buffers to disk
886
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
887
state._dirblock_state)
889
stat_value = os.lstat('a')
890
packed_stat = dirstate.pack_stat(stat_value)
891
link_or_sha1 = self.update_entry(state, entry, abspath='a',
892
stat_value=stat_value)
893
self.assertEqual(None, link_or_sha1)
895
# The dirblock entry should not have cached the file's sha1 (too new)
896
self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
898
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
899
state._dirblock_state)
900
mode = stat_value.st_mode
901
self.assertEqual([('is_exec', mode, False)], state._log)
904
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
905
state._dirblock_state)
907
# If we do it again right away, we don't know if the file has changed
908
# so we will re-read the file. Roll the clock back so the file is
909
# guaranteed to look too new.
910
state.adjust_time(-10)
913
link_or_sha1 = self.update_entry(state, entry, abspath='a',
914
stat_value=stat_value)
915
self.assertEqual([('is_exec', mode, False)], state._log)
916
self.assertEqual(None, link_or_sha1)
917
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
918
state._dirblock_state)
919
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.
925
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
link_or_sha1 = self.update_entry(state, entry, abspath='a',
943
stat_value=stat_value)
944
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
946
self.assertEqual([('is_exec', mode, False), ('sha1', 'a')],
948
self.assertEqual(('f', link_or_sha1, 14, False, packed_stat),
951
# Subsequent calls will just return the cached value
953
link_or_sha1 = self.update_entry(state, entry, abspath='a',
954
stat_value=stat_value)
955
self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
957
self.assertEqual([], state._log)
958
self.assertEqual(('f', link_or_sha1, 14, False, packed_stat),
961
def test_update_entry_symlink(self):
962
"""Update entry should read symlinks."""
963
self.requireFeature(tests.SymlinkFeature)
964
state, entry = self.get_state_with_a()
966
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
967
state._dirblock_state)
968
os.symlink('target', 'a')
970
state.adjust_time(-10) # Make the symlink look new
971
stat_value = os.lstat('a')
972
packed_stat = dirstate.pack_stat(stat_value)
973
link_or_sha1 = self.update_entry(state, entry, abspath='a',
974
stat_value=stat_value)
975
self.assertEqual('target', link_or_sha1)
976
self.assertEqual([('read_link', 'a', '')], state._log)
977
# Dirblock is not updated (the link is too new)
978
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
980
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
981
state._dirblock_state)
983
# Because the stat_value looks new, we should re-read the target
984
link_or_sha1 = self.update_entry(state, entry, abspath='a',
985
stat_value=stat_value)
986
self.assertEqual('target', link_or_sha1)
987
self.assertEqual([('read_link', 'a', ''),
988
('read_link', 'a', ''),
990
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
992
state.adjust_time(+20) # Skip into the future, all files look old
993
link_or_sha1 = self.update_entry(state, entry, abspath='a',
994
stat_value=stat_value)
995
self.assertEqual('target', link_or_sha1)
996
# We need to re-read the link because only now can we cache it
997
self.assertEqual([('read_link', 'a', ''),
998
('read_link', 'a', ''),
999
('read_link', 'a', ''),
1001
self.assertEqual([('l', 'target', 6, False, packed_stat)],
1004
# Another call won't re-read the link
1005
self.assertEqual([('read_link', 'a', ''),
1006
('read_link', 'a', ''),
1007
('read_link', 'a', ''),
1009
link_or_sha1 = self.update_entry(state, entry, abspath='a',
1010
stat_value=stat_value)
1011
self.assertEqual('target', link_or_sha1)
1012
self.assertEqual([('l', 'target', 6, False, packed_stat)],
1015
def do_update_entry(self, state, entry, abspath):
1016
stat_value = os.lstat(abspath)
1017
return self.update_entry(state, entry, abspath, stat_value)
1019
def test_update_entry_dir(self):
1020
state, entry = self.get_state_with_a()
1021
self.build_tree(['a/'])
1022
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1024
def test_update_entry_dir_unchanged(self):
1025
state, entry = self.get_state_with_a()
1026
self.build_tree(['a/'])
1027
state.adjust_time(+20)
1028
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1029
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1030
state._dirblock_state)
1032
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1033
state._dirblock_state)
1034
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1035
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1036
state._dirblock_state)
1038
def test_update_entry_file_unchanged(self):
1039
state, _ = self.get_state_with_a()
1040
tree = self.make_branch_and_tree('tree')
1042
self.build_tree(['tree/a'])
1043
tree.add(['a'], ['a-id'])
1044
with_a_id = tree.commit('witha')
1045
self.addCleanup(tree.unlock)
1046
state.set_parent_trees(
1047
[(with_a_id, tree.branch.repository.revision_tree(with_a_id))],
1049
entry = state._get_entry(0, path_utf8='a')
1050
self.build_tree(['a'])
1051
sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1052
state.adjust_time(+20)
1053
self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
1054
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1055
state._dirblock_state)
1057
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1058
state._dirblock_state)
1059
self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
1060
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1061
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
def create_and_test_file(self, state, entry):
1074
"""Create a file at 'a' and verify the state finds it during update.
1076
The state should already be versioning *something* at 'a'. This makes
1077
sure that state.update_entry recognizes it as a file.
1079
self.build_tree(['a'])
1080
stat_value = os.lstat('a')
1081
packed_stat = dirstate.pack_stat(stat_value)
1083
link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1084
self.assertEqual(None, link_or_sha1)
1085
self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
1089
def create_and_test_dir(self, state, entry):
1090
"""Create a directory at 'a' and verify the state finds it.
1092
The state should already be versioning *something* at 'a'. This makes
1093
sure that state.update_entry recognizes it as a directory.
1095
self.build_tree(['a/'])
1096
stat_value = os.lstat('a')
1097
packed_stat = dirstate.pack_stat(stat_value)
1099
link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1100
self.assertIs(None, link_or_sha1)
1101
self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
1105
# FIXME: Add unicode version
1106
def create_and_test_symlink(self, state, entry):
1107
"""Create a symlink at 'a' and verify the state finds it.
1109
The state should already be versioning *something* at 'a'. This makes
1110
sure that state.update_entry recognizes it as a symlink.
1112
This should not be called if this platform does not have symlink
1115
# caller should care about skipping test on platforms without symlinks
1116
os.symlink('path/to/foo', 'a')
1118
stat_value = os.lstat('a')
1119
packed_stat = dirstate.pack_stat(stat_value)
1121
link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
1122
self.assertEqual('path/to/foo', link_or_sha1)
1123
self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
1127
def test_update_file_to_dir(self):
1128
"""If a file changes to a directory we return None for the sha.
1129
We also update the inventory record.
1131
state, entry = self.get_state_with_a()
1132
# The file sha1 won't be cached unless the file is old
1133
state.adjust_time(+10)
1134
self.create_and_test_file(state, entry)
1136
self.create_and_test_dir(state, entry)
1138
def test_update_file_to_symlink(self):
1139
"""File becomes a symlink"""
1140
self.requireFeature(tests.SymlinkFeature)
1141
state, entry = self.get_state_with_a()
1142
# The file sha1 won't be cached unless the file is old
1143
state.adjust_time(+10)
1144
self.create_and_test_file(state, entry)
1146
self.create_and_test_symlink(state, entry)
1148
def test_update_dir_to_file(self):
1149
"""Directory becoming a file updates the entry."""
1150
state, entry = self.get_state_with_a()
1151
# The file sha1 won't be cached unless the file is old
1152
state.adjust_time(+10)
1153
self.create_and_test_dir(state, entry)
1155
self.create_and_test_file(state, entry)
1157
def test_update_dir_to_symlink(self):
1158
"""Directory becomes a symlink"""
1159
self.requireFeature(tests.SymlinkFeature)
1160
state, entry = self.get_state_with_a()
1161
# The symlink target won't be cached if it isn't old
1162
state.adjust_time(+10)
1163
self.create_and_test_dir(state, entry)
1165
self.create_and_test_symlink(state, entry)
1167
def test_update_symlink_to_file(self):
1168
"""Symlink becomes a file"""
1169
self.requireFeature(tests.SymlinkFeature)
1170
state, entry = self.get_state_with_a()
1171
# The symlink and file info won't be cached unless old
1172
state.adjust_time(+10)
1173
self.create_and_test_symlink(state, entry)
1175
self.create_and_test_file(state, entry)
1177
def test_update_symlink_to_dir(self):
1178
"""Symlink becomes a directory"""
1179
self.requireFeature(tests.SymlinkFeature)
1180
state, entry = self.get_state_with_a()
1181
# The symlink target won't be cached if it isn't old
1182
state.adjust_time(+10)
1183
self.create_and_test_symlink(state, entry)
1185
self.create_and_test_dir(state, entry)
1187
def test__is_executable_win32(self):
1188
state, entry = self.get_state_with_a()
1189
self.build_tree(['a'])
1191
# Make sure we are using the win32 implementation of _is_executable
1192
state._is_executable = state._is_executable_win32
1194
# The file on disk is not executable, but we are marking it as though
1195
# it is. With _is_executable_win32 we ignore what is on disk.
1196
entry[1][0] = ('f', '', 0, True, dirstate.DirState.NULLSTAT)
1198
stat_value = os.lstat('a')
1199
packed_stat = dirstate.pack_stat(stat_value)
1201
state.adjust_time(-10) # Make sure everything is new
1202
self.update_entry(state, entry, abspath='a', stat_value=stat_value)
1204
# The row is updated, but the executable bit stays set.
1205
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).
1210
state.adjust_time(+20)
1211
digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1212
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)
added
removed
bzrlib/tests/test__dirstate_helpers.py
