← 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: John Arbash Meinel
  • Date: 2011-04-22 14:12:22 UTC
  • mfrom: (5809 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5836.
  • Revision ID: john@arbash-meinel.com-20110422141222-nx2j0hbkihcb8j16
Merge newer bzr.dev and resolve conflicts.
Try to write some documentation about how the _dirblock_state works.
Fix up the tests so that they pass again.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test__dirstate_helpers.py
880
880
                                          stat_value=stat_value)
881
881
        self.assertEqual(None, link_or_sha1)
882
882
 
883
 
        # 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
884
886
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
885
887
                         entry[1][0])
886
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
 
888
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
887
889
                         state._dirblock_state)
888
890
        mode = stat_value.st_mode
889
891
        self.assertEqual([('is_exec', mode, False)], state._log)
892
894
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
893
895
                         state._dirblock_state)
894
896
 
895
 
        # If we do it again right away, we don't know if the file has changed
896
 
        # so we will re-read the file. Roll the clock back so the file is
897
 
        # 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.
898
899
        state.adjust_time(-10)
899
900
        del state._log[:]
900
901
 
902
903
                                          stat_value=stat_value)
903
904
        self.assertEqual([('is_exec', mode, False)], state._log)
904
905
        self.assertEqual(None, link_or_sha1)
905
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
 
906
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
906
907
                         state._dirblock_state)
907
908
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
908
909
                         entry[1][0])
918
919
        self.assertEqual([('is_exec', mode, False)], state._log)
919
920
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
920
921
                         entry[1][0])
 
922
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
923
                         state._dirblock_state)
921
924
 
922
925
        # If the file is no longer new, and the clock has been moved forward
923
926
        # sufficiently, it will cache the sha.
965
968
        # Dirblock is not updated (the link is too new)
966
969
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
967
970
                         entry[1])
 
971
        # The file entry turned into a symlink, that is considered
 
972
        # HASH modified worthy.
968
973
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
969
974
                         state._dirblock_state)
970
975
 
971
976
        # Because the stat_value looks new, we should re-read the target
 
977
        del state._log[:]
972
978
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
973
979
                                          stat_value=stat_value)
974
980
        self.assertEqual('target', link_or_sha1)
975
 
        self.assertEqual([('read_link', 'a', ''),
976
 
                          ('read_link', 'a', ''),
977
 
                         ], state._log)
 
981
        self.assertEqual([('read_link', 'a', '')], state._log)
978
982
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
979
983
                         entry[1])
 
984
        state.save()
980
985
        state.adjust_time(+20) # Skip into the future, all files look old
 
986
        del state._log[:]
981
987
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
982
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)
983
994
        self.assertEqual('target', link_or_sha1)
984
995
        # We need to re-read the link because only now can we cache it
985
 
        self.assertEqual([('read_link', 'a', ''),
986
 
                          ('read_link', 'a', ''),
987
 
                          ('read_link', 'a', ''),
988
 
                         ], state._log)
 
996
        self.assertEqual([('read_link', 'a', '')], state._log)
989
997
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
990
998
                         entry[1])
991
999
 
 
1000
        del state._log[:]
992
1001
        # Another call won't re-read the link
993
 
        self.assertEqual([('read_link', 'a', ''),
994
 
                          ('read_link', 'a', ''),
995
 
                          ('read_link', 'a', ''),
996
 
                         ], state._log)
 
1002
        self.assertEqual([], state._log)
997
1003
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
998
1004
                                          stat_value=stat_value)
999
1005
        self.assertEqual('target', link_or_sha1)
1014
1020
        self.build_tree(['a/'])
1015
1021
        state.adjust_time(+20)
1016
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
1017
1024
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1018
1025
                         state._dirblock_state)
1019
1026
        state.save()
1020
1027
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1021
1028
                         state._dirblock_state)
1022
 
        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
        os.utime('a', (t, t))
 
1036
        saved_packed_stat = entry[1][0][-1]
 
1037
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1038
        # We *do* go ahead and update the information in the dirblocks, but we
 
1039
        # don't bother setting IN_MEMORY_MODIFIED because it is trivial to
 
1040
        # recompute.
 
1041
        self.assertNotEqual(saved_packed_stat, entry[1][0][-1])
1023
1042
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1024
1043
                         state._dirblock_state)
1025
1044