823
823
def test_observed_sha1_cachable(self):
824
824
state, entry = self.get_state_with_a()
825
826
atime = time.time() - 10
826
827
self.build_tree(['a'])
827
statvalue = os.lstat('a')
828
statvalue = test_dirstate._FakeStat(statvalue.st_size, atime, atime,
829
statvalue.st_dev, statvalue.st_ino, statvalue.st_mode)
828
statvalue = test_dirstate._FakeStat.from_stat(os.lstat('a'))
829
statvalue.st_mtime = statvalue.st_ctime = atime
830
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
831
state._dirblock_state)
830
832
state._observed_sha1(entry, "foo", statvalue)
831
833
self.assertEqual('foo', entry[1][0][1])
832
834
packed_stat = dirstate.pack_stat(statvalue)
833
835
self.assertEqual(packed_stat, entry[1][0][4])
836
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
837
state._dirblock_state)
835
839
def test_observed_sha1_not_cachable(self):
836
840
state, entry = self.get_state_with_a()
837
842
oldval = entry[1][0][1]
838
843
oldstat = entry[1][0][4]
839
844
self.build_tree(['a'])
840
845
statvalue = os.lstat('a')
846
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
847
state._dirblock_state)
841
848
state._observed_sha1(entry, "foo", statvalue)
842
849
self.assertEqual(oldval, entry[1][0][1])
843
850
self.assertEqual(oldstat, entry[1][0][4])
851
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
852
state._dirblock_state)
845
854
def test_update_entry(self):
846
855
state, _ = self.get_state_with_a()
871
880
stat_value=stat_value)
872
881
self.assertEqual(None, link_or_sha1)
874
# The dirblock entry should not have cached the file's sha1 (too new)
883
# The dirblock entry should not have computed or cached the file's
884
# sha1, but it did update the files' st_size. However, this is not
885
# worth writing a dirstate file for, so we leave the state UNMODIFIED
875
886
self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
877
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
888
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
878
889
state._dirblock_state)
879
890
mode = stat_value.st_mode
880
891
self.assertEqual([('is_exec', mode, False)], state._log)
883
894
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
884
895
state._dirblock_state)
886
# If we do it again right away, we don't know if the file has changed
887
# so we will re-read the file. Roll the clock back so the file is
888
# guaranteed to look too new.
897
# Roll the clock back so the file is guaranteed to look too new. We
898
# should still not compute the sha1.
889
899
state.adjust_time(-10)
890
900
del state._log[:]
893
903
stat_value=stat_value)
894
904
self.assertEqual([('is_exec', mode, False)], state._log)
895
905
self.assertEqual(None, link_or_sha1)
896
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
906
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
897
907
state._dirblock_state)
898
908
self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
909
919
self.assertEqual([('is_exec', mode, False)], state._log)
910
920
self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
922
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
923
state._dirblock_state)
913
925
# If the file is no longer new, and the clock has been moved forward
914
926
# sufficiently, it will cache the sha.
956
968
# Dirblock is not updated (the link is too new)
957
969
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
959
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
971
# The file entry turned into a symlink, that is considered
972
# HASH modified worthy.
973
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
960
974
state._dirblock_state)
962
976
# Because the stat_value looks new, we should re-read the target
963
978
link_or_sha1 = self.update_entry(state, entry, abspath='a',
964
979
stat_value=stat_value)
965
980
self.assertEqual('target', link_or_sha1)
966
self.assertEqual([('read_link', 'a', ''),
967
('read_link', 'a', ''),
981
self.assertEqual([('read_link', 'a', '')], state._log)
969
982
self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
971
985
state.adjust_time(+20) # Skip into the future, all files look old
972
987
link_or_sha1 = self.update_entry(state, entry, abspath='a',
973
988
stat_value=stat_value)
989
# The symlink stayed a symlink. So while it is new enough to cache, we
990
# don't bother setting the flag, because it is not really worth saving
991
# (when we stat the symlink, we'll have paged in the target.)
992
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
993
state._dirblock_state)
974
994
self.assertEqual('target', link_or_sha1)
975
995
# We need to re-read the link because only now can we cache it
976
self.assertEqual([('read_link', 'a', ''),
977
('read_link', 'a', ''),
978
('read_link', 'a', ''),
996
self.assertEqual([('read_link', 'a', '')], state._log)
980
997
self.assertEqual([('l', 'target', 6, False, packed_stat)],
983
1001
# Another call won't re-read the link
984
self.assertEqual([('read_link', 'a', ''),
985
('read_link', 'a', ''),
986
('read_link', 'a', ''),
1002
self.assertEqual([], state._log)
988
1003
link_or_sha1 = self.update_entry(state, entry, abspath='a',
989
1004
stat_value=stat_value)
990
1005
self.assertEqual('target', link_or_sha1)
1005
1020
self.build_tree(['a/'])
1006
1021
state.adjust_time(+20)
1007
1022
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1023
# a/ used to be a file, but is now a directory, worth saving
1008
1024
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1009
1025
state._dirblock_state)
1011
1027
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1012
1028
state._dirblock_state)
1013
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1029
# No changes to a/ means not worth saving.
1030
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1031
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1032
state._dirblock_state)
1033
# Change the last-modified time for the directory
1034
t = time.time() - 100.0
1036
os.utime('a', (t, t))
1038
# It looks like Win32 + FAT doesn't allow to change times on a dir.
1039
raise tests.TestSkipped("can't update mtime of a dir on FAT")
1040
saved_packed_stat = entry[1][0][-1]
1041
self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1042
# We *do* go ahead and update the information in the dirblocks, but we
1043
# don't bother setting IN_MEMORY_MODIFIED because it is trivial to
1045
self.assertNotEqual(saved_packed_stat, entry[1][0][-1])
1014
1046
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1015
1047
state._dirblock_state)