← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test__dirstate_helpers.py

  • Committer: Vincent Ladeuil
  • Date: 2011-07-06 09:22:00 UTC
  • mfrom: (6008 +trunk)
  • mto: (6012.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6013.
  • Revision ID: v.ladeuil+lp@free.fr-20110706092200-7iai2mwzc0sqdsvf
Merging in trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test__dirstate_helpers.py
822
822
 
823
823
    def test_observed_sha1_cachable(self):
824
824
        state, entry = self.get_state_with_a()
 
825
        state.save()
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)
834
838
 
835
839
    def test_observed_sha1_not_cachable(self):
836
840
        state, entry = self.get_state_with_a()
 
841
        state.save()
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)
844
853
 
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)
873
882
 
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),
876
887
                         entry[1][0])
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)
885
896
 
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[:]
891
901
 
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),
899
909
                         entry[1][0])
909
919
        self.assertEqual([('is_exec', mode, False)], state._log)
910
920
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
911
921
                         entry[1][0])
 
922
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
923
                         state._dirblock_state)
912
924
 
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)],
958
970
                         entry[1])
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)
961
975
 
962
976
        # Because the stat_value looks new, we should re-read the target
 
977
        del state._log[:]
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', ''),
968
 
                         ], state._log)
 
981
        self.assertEqual([('read_link', 'a', '')], state._log)
969
982
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
970
983
                         entry[1])
 
984
        state.save()
971
985
        state.adjust_time(+20) # Skip into the future, all files look old
 
986
        del state._log[:]
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', ''),
979
 
                         ], state._log)
 
996
        self.assertEqual([('read_link', 'a', '')], state._log)
980
997
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
981
998
                         entry[1])
982
999
 
 
1000
        del state._log[:]
983
1001
        # Another call won't re-read the link
984
 
        self.assertEqual([('read_link', 'a', ''),
985
 
                          ('read_link', 'a', ''),
986
 
                          ('read_link', 'a', ''),
987
 
                         ], state._log)
 
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)
1010
1026
        state.save()
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
 
1035
        try:
 
1036
            os.utime('a', (t, t))
 
1037
        except OSError:
 
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
 
1044
        # recompute.
 
1045
        self.assertNotEqual(saved_packed_stat, entry[1][0][-1])
1014
1046
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1015
1047
                         state._dirblock_state)
1016
1048