/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_dirstate.py

  • Committer: Robert Collins
  • Date: 2008-01-25 10:46:10 UTC
  • mto: This revision was merged to the branch mainline in revision 3211.
  • Revision ID: robertc@robertcollins.net-20080125104610-4qweeqqch2feyxdv
 * The ``register-branch`` command will now use the public url of the branch
   containing the current directory, if one has been set and no explicit branch is provided.
   (Robert Collins)

 * New error ``NoPublicBranch`` for commands that need a public branch to
   operate. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_dirstate.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests of the dirstate functionality being built for WorkingTreeFormat4."""
18
18
 
19
19
import bisect
20
20
import os
 
21
import time
21
22
 
22
23
from bzrlib import (
23
24
    dirstate,
24
25
    errors,
25
 
    inventory,
26
 
    memorytree,
27
26
    osutils,
28
 
    revision as _mod_revision,
29
 
    tests,
30
27
    )
31
 
from bzrlib.tests import test_osutils
 
28
from bzrlib.memorytree import MemoryTree
 
29
from bzrlib.tests import (
 
30
        SymlinkFeature,
 
31
        TestCase,
 
32
        TestCaseWithTransport,
 
33
        )
32
34
 
33
35
 
34
36
# TODO:
44
46
# set_path_id  setting id when state is in memory modified
45
47
 
46
48
 
47
 
def load_tests(basic_tests, module, loader):
48
 
    suite = loader.suiteClass()
49
 
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
50
 
        basic_tests, tests.condition_isinstance(TestCaseWithDirState))
51
 
    tests.multiply_tests(dir_reader_tests,
52
 
                         test_osutils.dir_reader_scenarios(), suite)
53
 
    suite.addTest(remaining_tests)
54
 
    return suite
55
 
 
56
 
 
57
 
class TestCaseWithDirState(tests.TestCaseWithTransport):
 
49
class TestCaseWithDirState(TestCaseWithTransport):
58
50
    """Helper functions for creating DirState objects with various content."""
59
51
 
60
 
    # Set by load_tests
61
 
    _dir_reader_class = None
62
 
    _native_to_unicode = None # Not used yet
63
 
 
64
 
    def setUp(self):
65
 
        tests.TestCaseWithTransport.setUp(self)
66
 
 
67
 
        self.overrideAttr(osutils,
68
 
                          '_selected_dir_reader', self._dir_reader_class())
69
 
 
70
52
    def create_empty_dirstate(self):
71
53
        """Return a locked but empty dirstate"""
72
54
        state = dirstate.DirState.initialize('dirstate')
180
162
        """
181
163
        # The state should already be write locked, since we just had to do
182
164
        # some operation to get here.
183
 
        self.assertTrue(state._lock_token is not None)
 
165
        assert state._lock_token is not None
184
166
        try:
185
167
            self.assertEqual(expected_result[0],  state.get_parent_ids())
186
168
            # there should be no ghosts in this tree.
413
395
            (('', '', tree.get_root_id()), # common details
414
396
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
415
397
              ('d', '', 0, False, rev_id), # first parent details
416
 
              ('d', '', 0, False, rev_id), # second parent details
 
398
              ('d', '', 0, False, rev_id2), # second parent details
417
399
             ])])
418
400
        state = dirstate.DirState.from_tree(tree, 'dirstate')
419
401
        self.check_state_with_reopen(expected_result, state)
494
476
            (('', '', tree.get_root_id()), # common details
495
477
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
496
478
              ('d', '', 0, False, rev_id), # first parent details
497
 
              ('d', '', 0, False, rev_id), # second parent details
 
479
              ('d', '', 0, False, rev_id2), # second parent details
498
480
             ]),
499
481
            (('', 'a file', 'a-file-id'), # common
500
482
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
580
562
        state.lock_read()
581
563
        try:
582
564
            entry = state._get_entry(0, path_utf8='a-file')
583
 
            # The current size should be 0 (default)
584
 
            self.assertEqual(0, entry[1][0][2])
 
565
            # The current sha1 sum should be empty
 
566
            self.assertEqual('', entry[1][0][1])
585
567
            # We should have a real entry.
586
568
            self.assertNotEqual((None, None), entry)
587
569
            # Make sure everything is old enough
588
570
            state._sha_cutoff_time()
589
571
            state._cutoff_time += 10
590
 
            # Change the file length
591
 
            self.build_tree_contents([('a-file', 'shorter')])
592
 
            sha1sum = dirstate.update_entry(state, entry, 'a-file',
593
 
                os.lstat('a-file'))
594
 
            # new file, no cached sha:
595
 
            self.assertEqual(None, sha1sum)
 
572
            sha1sum = state.update_entry(entry, 'a-file', os.lstat('a-file'))
 
573
            # We should have gotten a real sha1
 
574
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
 
575
                             sha1sum)
596
576
 
597
577
            # The dirblock has been updated
598
 
            self.assertEqual(7, entry[1][0][2])
 
578
            self.assertEqual(sha1sum, entry[1][0][1])
599
579
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
600
580
                             state._dirblock_state)
601
581
 
611
591
        state.lock_read()
612
592
        try:
613
593
            entry = state._get_entry(0, path_utf8='a-file')
614
 
            self.assertEqual(7, entry[1][0][2])
 
594
            self.assertEqual(sha1sum, entry[1][0][1])
615
595
        finally:
616
596
            state.unlock()
617
597
 
630
610
        state.lock_read()
631
611
        try:
632
612
            entry = state._get_entry(0, path_utf8='a-file')
633
 
            sha1sum = dirstate.update_entry(state, entry, 'a-file',
634
 
                os.lstat('a-file'))
635
 
            # No sha - too new
636
 
            self.assertEqual(None, sha1sum)
 
613
            sha1sum = state.update_entry(entry, 'a-file', os.lstat('a-file'))
 
614
            # We should have gotten a real sha1
 
615
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
 
616
                             sha1sum)
637
617
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
638
618
                             state._dirblock_state)
639
619
 
656
636
                state2.unlock()
657
637
        finally:
658
638
            state.unlock()
659
 
 
 
639
        
660
640
        # The file on disk should not be modified.
661
641
        state = dirstate.DirState.on_file('dirstate')
662
642
        state.lock_read()
666
646
        finally:
667
647
            state.unlock()
668
648
 
669
 
    def test_save_refuses_if_changes_aborted(self):
670
 
        self.build_tree(['a-file', 'a-dir/'])
671
 
        state = dirstate.DirState.initialize('dirstate')
672
 
        try:
673
 
            # No stat and no sha1 sum.
674
 
            state.add('a-file', 'a-file-id', 'file', None, '')
675
 
            state.save()
676
 
        finally:
677
 
            state.unlock()
678
 
 
679
 
        # The dirstate should include TREE_ROOT and 'a-file' and nothing else
680
 
        expected_blocks = [
681
 
            ('', [(('', '', 'TREE_ROOT'),
682
 
                   [('d', '', 0, False, dirstate.DirState.NULLSTAT)])]),
683
 
            ('', [(('', 'a-file', 'a-file-id'),
684
 
                   [('f', '', 0, False, dirstate.DirState.NULLSTAT)])]),
685
 
        ]
686
 
 
687
 
        state = dirstate.DirState.on_file('dirstate')
688
 
        state.lock_write()
689
 
        try:
690
 
            state._read_dirblocks_if_needed()
691
 
            self.assertEqual(expected_blocks, state._dirblocks)
692
 
 
693
 
            # Now modify the state, but mark it as inconsistent
694
 
            state.add('a-dir', 'a-dir-id', 'directory', None, '')
695
 
            state._changes_aborted = True
696
 
            state.save()
697
 
        finally:
698
 
            state.unlock()
699
 
 
700
 
        state = dirstate.DirState.on_file('dirstate')
701
 
        state.lock_read()
702
 
        try:
703
 
            state._read_dirblocks_if_needed()
704
 
            self.assertEqual(expected_blocks, state._dirblocks)
705
 
        finally:
706
 
            state.unlock()
707
 
 
708
649
 
709
650
class TestDirStateInitialize(TestCaseWithDirState):
710
651
 
762
703
        # https://bugs.launchpad.net/bzr/+bug/146176
763
704
        # set_state_from_inventory should preserve the stat and hash value for
764
705
        # workingtree files that are not changed by the inventory.
765
 
 
 
706
       
766
707
        tree = self.make_branch_and_tree('.')
767
708
        # depends on the default format using dirstate...
768
709
        tree.lock_write()
769
710
        try:
770
 
            # make a dirstate with some valid hashcache data
 
711
            # make a dirstate with some valid hashcache data 
771
712
            # file on disk, but that's not needed for this test
772
713
            foo_contents = 'contents of foo'
773
714
            self.build_tree_contents([('foo', foo_contents)])
793
734
                (('', 'foo', 'foo-id',),
794
735
                 [('f', foo_sha, foo_size, False, foo_packed)]),
795
736
                tree._dirstate._get_entry(0, 'foo-id'))
796
 
 
 
737
           
797
738
            # extract the inventory, and add something to it
798
739
            inv = tree._get_inventory()
799
740
            # should see the file we poked in...
821
762
        finally:
822
763
            tree.unlock()
823
764
 
 
765
 
824
766
    def test_set_state_from_inventory_mixed_paths(self):
825
767
        tree1 = self.make_branch_and_tree('tree1')
826
768
        self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
867
809
        state = dirstate.DirState.initialize('dirstate')
868
810
        try:
869
811
            # check precondition to be sure the state does change appropriately.
870
 
            root_entry = (('', '', 'TREE_ROOT'), [('d', '', 0, False, 'x'*32)])
871
 
            self.assertEqual([root_entry], list(state._iter_entries()))
872
 
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
873
 
            self.assertEqual(root_entry,
874
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
875
 
            self.assertEqual((None, None),
876
 
                             state._get_entry(0, fileid_utf8='second-root-id'))
877
 
            state.set_path_id('', 'second-root-id')
878
 
            new_root_entry = (('', '', 'second-root-id'),
879
 
                              [('d', '', 0, False, 'x'*32)])
880
 
            expected_rows = [new_root_entry]
 
812
            self.assertEqual(
 
813
                [(('', '', 'TREE_ROOT'), [('d', '', 0, False,
 
814
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])],
 
815
                list(state._iter_entries()))
 
816
            state.set_path_id('', 'foobarbaz')
 
817
            expected_rows = [
 
818
                (('', '', 'foobarbaz'), [('d', '', 0, False,
 
819
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])]
881
820
            self.assertEqual(expected_rows, list(state._iter_entries()))
882
 
            self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
883
 
            self.assertEqual(new_root_entry, 
884
 
                             state._get_entry(0, fileid_utf8='second-root-id'))
885
 
            self.assertEqual((None, None),
886
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
887
821
            # should work across save too
888
822
            state.save()
889
823
        finally:
907
841
        state._validate()
908
842
        try:
909
843
            state.set_parent_trees([('parent-revid', rt)], ghosts=[])
910
 
            root_entry = (('', '', 'TREE_ROOT'),
911
 
                          [('d', '', 0, False, 'x'*32),
912
 
                           ('d', '', 0, False, 'parent-revid')])
913
 
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
914
 
            self.assertEqual(root_entry,
915
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
916
 
            self.assertEqual((None, None),
917
 
                             state._get_entry(0, fileid_utf8='Asecond-root-id'))
918
 
            state.set_path_id('', 'Asecond-root-id')
 
844
            state.set_path_id('', 'foobarbaz')
919
845
            state._validate()
920
846
            # now see that it is what we expected
921
 
            old_root_entry = (('', '', 'TREE_ROOT'),
922
 
                              [('a', '', 0, False, ''),
923
 
                               ('d', '', 0, False, 'parent-revid')])
924
 
            new_root_entry = (('', '', 'Asecond-root-id'),
925
 
                              [('d', '', 0, False, ''),
926
 
                               ('a', '', 0, False, '')])
927
 
            expected_rows = [new_root_entry, old_root_entry]
 
847
            expected_rows = [
 
848
                (('', '', 'TREE_ROOT'),
 
849
                    [('a', '', 0, False, ''),
 
850
                     ('d', '', 0, False, 'parent-revid'),
 
851
                     ]),
 
852
                (('', '', 'foobarbaz'),
 
853
                    [('d', '', 0, False, ''),
 
854
                     ('a', '', 0, False, ''),
 
855
                     ]),
 
856
                ]
928
857
            state._validate()
929
858
            self.assertEqual(expected_rows, list(state._iter_entries()))
930
 
            self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
931
 
            self.assertEqual(old_root_entry, state._get_entry(1, path_utf8=''))
932
 
            self.assertEqual((None, None),
933
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
934
 
            self.assertEqual(old_root_entry,
935
 
                             state._get_entry(1, fileid_utf8='TREE_ROOT'))
936
 
            self.assertEqual(new_root_entry,
937
 
                             state._get_entry(0, fileid_utf8='Asecond-root-id'))
938
 
            self.assertEqual((None, None),
939
 
                             state._get_entry(1, fileid_utf8='Asecond-root-id'))
940
859
            # should work across save too
941
860
            state.save()
942
861
        finally:
958
877
        finally:
959
878
            state.unlock()
960
879
 
 
880
 
961
881
    def test_set_parent_trees_no_content(self):
962
882
        # set_parent_trees is a slow but important api to support.
963
883
        tree1 = self.make_branch_and_memory_tree('tree1')
968
888
        finally:
969
889
            tree1.unlock()
970
890
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
971
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
891
        tree2 = MemoryTree.create_on_branch(branch2)
972
892
        tree2.lock_write()
973
893
        try:
974
894
            revid2 = tree2.commit('foo')
1006
926
            state.set_parent_trees(
1007
927
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
1008
928
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
1009
 
                 ('ghost-rev', tree2.branch.repository.revision_tree(
1010
 
                                   _mod_revision.NULL_REVISION))),
 
929
                 ('ghost-rev', tree2.branch.repository.revision_tree(None))),
1011
930
                ['ghost-rev'])
1012
931
            self.assertEqual([revid1, revid2, 'ghost-rev'],
1013
932
                             state.get_parent_ids())
1017
936
                [(('', '', root_id), [
1018
937
                  ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1019
938
                  ('d', '', 0, False, revid1),
1020
 
                  ('d', '', 0, False, revid1)
 
939
                  ('d', '', 0, False, revid2)
1021
940
                  ])],
1022
941
                list(state._iter_entries()))
1023
942
        finally:
1038
957
        finally:
1039
958
            tree1.unlock()
1040
959
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1041
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
960
        tree2 = MemoryTree.create_on_branch(branch2)
1042
961
        tree2.lock_write()
1043
962
        try:
1044
963
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1051
970
            (('', '', root_id), [
1052
971
             ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1053
972
             ('d', '', 0, False, revid1.encode('utf8')),
1054
 
             ('d', '', 0, False, revid1.encode('utf8'))
 
973
             ('d', '', 0, False, revid2.encode('utf8'))
1055
974
             ]),
1056
975
            (('', 'a file', 'file-id'), [
1057
976
             ('a', '', 0, False, ''),
1103
1022
            state.unlock()
1104
1023
        state = dirstate.DirState.on_file('dirstate')
1105
1024
        state.lock_read()
1106
 
        self.addCleanup(state.unlock)
1107
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1025
        try:
 
1026
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1027
        finally:
 
1028
            state.unlock()
1108
1029
 
1109
1030
    def test_add_path_to_unversioned_directory(self):
1110
1031
        """Adding a path to an unversioned directory should error.
1115
1036
        """
1116
1037
        self.build_tree(['unversioned/', 'unversioned/a file'])
1117
1038
        state = dirstate.DirState.initialize('dirstate')
1118
 
        self.addCleanup(state.unlock)
1119
 
        self.assertRaises(errors.NotVersionedError, state.add,
1120
 
                          'unversioned/a file', 'a-file-id', 'file', None, None)
 
1039
        try:
 
1040
            self.assertRaises(errors.NotVersionedError, state.add,
 
1041
                'unversioned/a file', 'a-file-id', 'file', None, None)
 
1042
        finally:
 
1043
            state.unlock()
1121
1044
 
1122
1045
    def test_add_directory_to_root_no_parents_all_data(self):
1123
1046
        # The most trivial addition of a dir is when there are no parents and
1143
1066
            state.unlock()
1144
1067
        state = dirstate.DirState.on_file('dirstate')
1145
1068
        state.lock_read()
1146
 
        self.addCleanup(state.unlock)
1147
1069
        state._validate()
1148
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1070
        try:
 
1071
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1072
        finally:
 
1073
            state.unlock()
1149
1074
 
1150
 
    def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
 
1075
    def test_add_symlink_to_root_no_parents_all_data(self):
1151
1076
        # The most trivial addition of a symlink when there are no parents and
1152
1077
        # its in the root and all data about the file is supplied
1153
1078
        # bzr doesn't support fake symlinks on windows, yet.
1154
 
        self.requireFeature(tests.SymlinkFeature)
1155
 
        os.symlink(target, link_name)
1156
 
        stat = os.lstat(link_name)
 
1079
        self.requireFeature(SymlinkFeature)
 
1080
        os.symlink('target', 'a link')
 
1081
        stat = os.lstat('a link')
1157
1082
        expected_entries = [
1158
1083
            (('', '', 'TREE_ROOT'), [
1159
1084
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1160
1085
             ]),
1161
 
            (('', link_name.encode('UTF-8'), 'a link id'), [
1162
 
             ('l', target.encode('UTF-8'), stat[6],
1163
 
              False, dirstate.pack_stat(stat)), # current tree
 
1086
            (('', 'a link', 'a link id'), [
 
1087
             ('l', 'target', 6, False, dirstate.pack_stat(stat)), # current tree
1164
1088
             ]),
1165
1089
            ]
1166
1090
        state = dirstate.DirState.initialize('dirstate')
1167
1091
        try:
1168
 
            state.add(link_name, 'a link id', 'symlink', stat,
1169
 
                      target.encode('UTF-8'))
 
1092
            state.add('a link', 'a link id', 'symlink', stat, 'target')
1170
1093
            # having added it, it should be in the output of iter_entries.
1171
1094
            self.assertEqual(expected_entries, list(state._iter_entries()))
1172
1095
            # saving and reloading should not affect this.
1175
1098
            state.unlock()
1176
1099
        state = dirstate.DirState.on_file('dirstate')
1177
1100
        state.lock_read()
1178
 
        self.addCleanup(state.unlock)
1179
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
1180
 
 
1181
 
    def test_add_symlink_to_root_no_parents_all_data(self):
1182
 
        self._test_add_symlink_to_root_no_parents_all_data('a link', 'target')
1183
 
 
1184
 
    def test_add_symlink_unicode_to_root_no_parents_all_data(self):
1185
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1186
 
        self._test_add_symlink_to_root_no_parents_all_data(
1187
 
            u'\N{Euro Sign}link', u'targ\N{Euro Sign}et')
 
1101
        try:
 
1102
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1103
        finally:
 
1104
            state.unlock()
1188
1105
 
1189
1106
    def test_add_directory_and_child_no_parents_all_data(self):
1190
1107
        # after adding a directory, we should be able to add children to it.
1215
1132
            state.unlock()
1216
1133
        state = dirstate.DirState.on_file('dirstate')
1217
1134
        state.lock_read()
1218
 
        self.addCleanup(state.unlock)
1219
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1135
        try:
 
1136
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1137
        finally:
 
1138
            state.unlock()
1220
1139
 
1221
1140
    def test_add_tree_reference(self):
1222
1141
        # make a dirstate and add a tree reference
1236
1155
            state.unlock()
1237
1156
        # now check we can read it back
1238
1157
        state.lock_read()
1239
 
        self.addCleanup(state.unlock)
1240
1158
        state._validate()
1241
 
        entry2 = state._get_entry(0, 'subdir-id', 'subdir')
1242
 
        self.assertEqual(entry, entry2)
1243
 
        self.assertEqual(entry, expected_entry)
1244
 
        # and lookup by id should work too
1245
 
        entry2 = state._get_entry(0, fileid_utf8='subdir-id')
1246
 
        self.assertEqual(entry, expected_entry)
 
1159
        try:
 
1160
            entry2 = state._get_entry(0, 'subdir-id', 'subdir')
 
1161
            self.assertEqual(entry, entry2)
 
1162
            self.assertEqual(entry, expected_entry)
 
1163
            # and lookup by id should work too
 
1164
            entry2 = state._get_entry(0, fileid_utf8='subdir-id')
 
1165
            self.assertEqual(entry, expected_entry)
 
1166
        finally:
 
1167
            state.unlock()
1247
1168
 
1248
1169
    def test_add_forbidden_names(self):
1249
1170
        state = dirstate.DirState.initialize('dirstate')
1253
1174
        self.assertRaises(errors.BzrError,
1254
1175
            state.add, '..', 'ass-id', 'directory', None, None)
1255
1176
 
1256
 
    def test_set_state_with_rename_b_a_bug_395556(self):
1257
 
        # bug 395556 uncovered a bug where the dirstate ends up with a false
1258
 
        # relocation record - in a tree with no parents there should be no
1259
 
        # absent or relocated records. This then leads to further corruption
1260
 
        # when a commit occurs, as the incorrect relocation gathers an
1261
 
        # incorrect absent in tree 1, and future changes go to pot.
1262
 
        tree1 = self.make_branch_and_tree('tree1')
1263
 
        self.build_tree(['tree1/b'])
1264
 
        tree1.lock_write()
1265
 
        try:
1266
 
            tree1.add(['b'], ['b-id'])
1267
 
            root_id = tree1.get_root_id()
1268
 
            inv = tree1.inventory
1269
 
            state = dirstate.DirState.initialize('dirstate')
1270
 
            try:
1271
 
                # Set the initial state with 'b'
1272
 
                state.set_state_from_inventory(inv)
1273
 
                inv.rename('b-id', root_id, 'a')
1274
 
                # Set the new state with 'a', which currently corrupts.
1275
 
                state.set_state_from_inventory(inv)
1276
 
                expected_result1 = [('', '', root_id, 'd'),
1277
 
                                    ('', 'a', 'b-id', 'f'),
1278
 
                                   ]
1279
 
                values = []
1280
 
                for entry in state._iter_entries():
1281
 
                    values.append(entry[0] + entry[1][0][:1])
1282
 
                self.assertEqual(expected_result1, values)
1283
 
            finally:
1284
 
                state.unlock()
1285
 
        finally:
1286
 
            tree1.unlock()
1287
 
 
1288
1177
 
1289
1178
class TestGetLines(TestCaseWithDirState):
1290
1179
 
1523
1412
        There is one parent tree, which has the same shape with the following variations:
1524
1413
        b/g in the parent is gone.
1525
1414
        b/h in the parent has a different id
1526
 
        b/i is new in the parent
 
1415
        b/i is new in the parent 
1527
1416
        c is renamed to b/j in the parent
1528
1417
 
1529
1418
        :return: The dirstate, still write-locked.
1619
1508
            list(state._iter_child_entries(1, '')))
1620
1509
 
1621
1510
 
1622
 
class TestDirstateSortOrder(tests.TestCaseWithTransport):
 
1511
class TestDirstateSortOrder(TestCaseWithTransport):
1623
1512
    """Test that DirState adds entries in the right order."""
1624
1513
 
1625
1514
    def test_add_sorting(self):
1674
1563
 
1675
1564
        # *really* cheesy way to just get an empty tree
1676
1565
        repo = self.make_repository('repo')
1677
 
        empty_tree = repo.revision_tree(_mod_revision.NULL_REVISION)
 
1566
        empty_tree = repo.revision_tree(None)
1678
1567
        state.set_parent_trees([('null:', empty_tree)], [])
1679
1568
 
1680
1569
        dirblock_names = [d[0] for d in state._dirblocks]
1684
1573
class InstrumentedDirState(dirstate.DirState):
1685
1574
    """An DirState with instrumented sha1 functionality."""
1686
1575
 
1687
 
    def __init__(self, path, sha1_provider):
1688
 
        super(InstrumentedDirState, self).__init__(path, sha1_provider)
 
1576
    def __init__(self, path):
 
1577
        super(InstrumentedDirState, self).__init__(path)
1689
1578
        self._time_offset = 0
1690
1579
        self._log = []
1691
1580
        # member is dynamically set in DirState.__init__ to turn on trace
1692
 
        self._sha1_provider = sha1_provider
1693
1581
        self._sha1_file = self._sha1_file_and_log
1694
1582
 
1695
1583
    def _sha_cutoff_time(self):
1698
1586
 
1699
1587
    def _sha1_file_and_log(self, abspath):
1700
1588
        self._log.append(('sha1', abspath))
1701
 
        return self._sha1_provider.sha1(abspath)
 
1589
        return osutils.sha_file_by_name(abspath)
1702
1590
 
1703
1591
    def _read_link(self, abspath, old_link):
1704
1592
        self._log.append(('read_link', abspath, old_link))
1735
1623
        self.st_ino = ino
1736
1624
        self.st_mode = mode
1737
1625
 
1738
 
    @staticmethod
1739
 
    def from_stat(st):
1740
 
        return _FakeStat(st.st_size, st.st_mtime, st.st_ctime, st.st_dev,
1741
 
            st.st_ino, st.st_mode)
1742
 
 
1743
 
 
1744
 
class TestPackStat(tests.TestCaseWithTransport):
 
1626
 
 
1627
class TestUpdateEntry(TestCaseWithDirState):
 
1628
    """Test the DirState.update_entry functions"""
 
1629
 
 
1630
    def get_state_with_a(self):
 
1631
        """Create a DirState tracking a single object named 'a'"""
 
1632
        state = InstrumentedDirState.initialize('dirstate')
 
1633
        self.addCleanup(state.unlock)
 
1634
        state.add('a', 'a-id', 'file', None, '')
 
1635
        entry = state._get_entry(0, path_utf8='a')
 
1636
        return state, entry
 
1637
 
 
1638
    def test_update_entry(self):
 
1639
        state, entry = self.get_state_with_a()
 
1640
        self.build_tree(['a'])
 
1641
        # Add one where we don't provide the stat or sha already
 
1642
        self.assertEqual(('', 'a', 'a-id'), entry[0])
 
1643
        self.assertEqual([('f', '', 0, False, dirstate.DirState.NULLSTAT)],
 
1644
                         entry[1])
 
1645
        # Flush the buffers to disk
 
1646
        state.save()
 
1647
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1648
                         state._dirblock_state)
 
1649
 
 
1650
        stat_value = os.lstat('a')
 
1651
        packed_stat = dirstate.pack_stat(stat_value)
 
1652
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1653
                                          stat_value=stat_value)
 
1654
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1655
                         link_or_sha1)
 
1656
 
 
1657
        # The dirblock entry should not cache the file's sha1
 
1658
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1659
                         entry[1])
 
1660
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1661
                         state._dirblock_state)
 
1662
        mode = stat_value.st_mode
 
1663
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False)], state._log)
 
1664
 
 
1665
        state.save()
 
1666
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1667
                         state._dirblock_state)
 
1668
 
 
1669
        # If we do it again right away, we don't know if the file has changed
 
1670
        # so we will re-read the file. Roll the clock back so the file is
 
1671
        # guaranteed to look too new.
 
1672
        state.adjust_time(-10)
 
1673
 
 
1674
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1675
                                          stat_value=stat_value)
 
1676
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1677
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1678
                         ], state._log)
 
1679
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1680
                         link_or_sha1)
 
1681
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1682
                         state._dirblock_state)
 
1683
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1684
                         entry[1])
 
1685
        state.save()
 
1686
 
 
1687
        # However, if we move the clock forward so the file is considered
 
1688
        # "stable", it should just cache the value.
 
1689
        state.adjust_time(+20)
 
1690
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1691
                                          stat_value=stat_value)
 
1692
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1693
                         link_or_sha1)
 
1694
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1695
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1696
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1697
                         ], state._log)
 
1698
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1699
                         entry[1])
 
1700
 
 
1701
        # Subsequent calls will just return the cached value
 
1702
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1703
                                          stat_value=stat_value)
 
1704
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1705
                         link_or_sha1)
 
1706
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1707
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1708
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1709
                         ], state._log)
 
1710
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1711
                         entry[1])
 
1712
 
 
1713
    def test_update_entry_symlink(self):
 
1714
        """Update entry should read symlinks."""
 
1715
        self.requireFeature(SymlinkFeature)
 
1716
        state, entry = self.get_state_with_a()
 
1717
        state.save()
 
1718
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1719
                         state._dirblock_state)
 
1720
        os.symlink('target', 'a')
 
1721
 
 
1722
        state.adjust_time(-10) # Make the symlink look new
 
1723
        stat_value = os.lstat('a')
 
1724
        packed_stat = dirstate.pack_stat(stat_value)
 
1725
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1726
                                          stat_value=stat_value)
 
1727
        self.assertEqual('target', link_or_sha1)
 
1728
        self.assertEqual([('read_link', 'a', '')], state._log)
 
1729
        # Dirblock is not updated (the link is too new)
 
1730
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1731
                         entry[1])
 
1732
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1733
                         state._dirblock_state)
 
1734
 
 
1735
        # Because the stat_value looks new, we should re-read the target
 
1736
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1737
                                          stat_value=stat_value)
 
1738
        self.assertEqual('target', link_or_sha1)
 
1739
        self.assertEqual([('read_link', 'a', ''),
 
1740
                          ('read_link', 'a', ''),
 
1741
                         ], state._log)
 
1742
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1743
                         entry[1])
 
1744
        state.adjust_time(+20) # Skip into the future, all files look old
 
1745
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1746
                                          stat_value=stat_value)
 
1747
        self.assertEqual('target', link_or_sha1)
 
1748
        # We need to re-read the link because only now can we cache it
 
1749
        self.assertEqual([('read_link', 'a', ''),
 
1750
                          ('read_link', 'a', ''),
 
1751
                          ('read_link', 'a', ''),
 
1752
                         ], state._log)
 
1753
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1754
                         entry[1])
 
1755
 
 
1756
        # Another call won't re-read the link
 
1757
        self.assertEqual([('read_link', 'a', ''),
 
1758
                          ('read_link', 'a', ''),
 
1759
                          ('read_link', 'a', ''),
 
1760
                         ], state._log)
 
1761
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1762
                                          stat_value=stat_value)
 
1763
        self.assertEqual('target', link_or_sha1)
 
1764
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1765
                         entry[1])
 
1766
 
 
1767
    def do_update_entry(self, state, entry, abspath):
 
1768
        stat_value = os.lstat(abspath)
 
1769
        return state.update_entry(entry, abspath, stat_value)
 
1770
 
 
1771
    def test_update_entry_dir(self):
 
1772
        state, entry = self.get_state_with_a()
 
1773
        self.build_tree(['a/'])
 
1774
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1775
 
 
1776
    def test_update_entry_dir_unchanged(self):
 
1777
        state, entry = self.get_state_with_a()
 
1778
        self.build_tree(['a/'])
 
1779
        state.adjust_time(+20)
 
1780
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1781
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1782
                         state._dirblock_state)
 
1783
        state.save()
 
1784
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1785
                         state._dirblock_state)
 
1786
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1787
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1788
                         state._dirblock_state)
 
1789
 
 
1790
    def test_update_entry_file_unchanged(self):
 
1791
        state, entry = self.get_state_with_a()
 
1792
        self.build_tree(['a'])
 
1793
        sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1794
        state.adjust_time(+20)
 
1795
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1796
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1797
                         state._dirblock_state)
 
1798
        state.save()
 
1799
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1800
                         state._dirblock_state)
 
1801
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1802
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1803
                         state._dirblock_state)
 
1804
 
 
1805
    def create_and_test_file(self, state, entry):
 
1806
        """Create a file at 'a' and verify the state finds it.
 
1807
 
 
1808
        The state should already be versioning *something* at 'a'. This makes
 
1809
        sure that state.update_entry recognizes it as a file.
 
1810
        """
 
1811
        self.build_tree(['a'])
 
1812
        stat_value = os.lstat('a')
 
1813
        packed_stat = dirstate.pack_stat(stat_value)
 
1814
 
 
1815
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1816
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1817
                         link_or_sha1)
 
1818
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1819
                         entry[1])
 
1820
        return packed_stat
 
1821
 
 
1822
    def create_and_test_dir(self, state, entry):
 
1823
        """Create a directory at 'a' and verify the state finds it.
 
1824
 
 
1825
        The state should already be versioning *something* at 'a'. This makes
 
1826
        sure that state.update_entry recognizes it as a directory.
 
1827
        """
 
1828
        self.build_tree(['a/'])
 
1829
        stat_value = os.lstat('a')
 
1830
        packed_stat = dirstate.pack_stat(stat_value)
 
1831
 
 
1832
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1833
        self.assertIs(None, link_or_sha1)
 
1834
        self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
 
1835
 
 
1836
        return packed_stat
 
1837
 
 
1838
    def create_and_test_symlink(self, state, entry):
 
1839
        """Create a symlink at 'a' and verify the state finds it.
 
1840
 
 
1841
        The state should already be versioning *something* at 'a'. This makes
 
1842
        sure that state.update_entry recognizes it as a symlink.
 
1843
 
 
1844
        This should not be called if this platform does not have symlink
 
1845
        support.
 
1846
        """
 
1847
        # caller should care about skipping test on platforms without symlinks
 
1848
        os.symlink('path/to/foo', 'a')
 
1849
 
 
1850
        stat_value = os.lstat('a')
 
1851
        packed_stat = dirstate.pack_stat(stat_value)
 
1852
 
 
1853
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1854
        self.assertEqual('path/to/foo', link_or_sha1)
 
1855
        self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
 
1856
                         entry[1])
 
1857
        return packed_stat
 
1858
 
 
1859
    def test_update_file_to_dir(self):
 
1860
        """If a file changes to a directory we return None for the sha.
 
1861
        We also update the inventory record.
 
1862
        """
 
1863
        state, entry = self.get_state_with_a()
 
1864
        # The file sha1 won't be cached unless the file is old
 
1865
        state.adjust_time(+10)
 
1866
        self.create_and_test_file(state, entry)
 
1867
        os.remove('a')
 
1868
        self.create_and_test_dir(state, entry)
 
1869
 
 
1870
    def test_update_file_to_symlink(self):
 
1871
        """File becomes a symlink"""
 
1872
        self.requireFeature(SymlinkFeature)
 
1873
        state, entry = self.get_state_with_a()
 
1874
        # The file sha1 won't be cached unless the file is old
 
1875
        state.adjust_time(+10)
 
1876
        self.create_and_test_file(state, entry)
 
1877
        os.remove('a')
 
1878
        self.create_and_test_symlink(state, entry)
 
1879
 
 
1880
    def test_update_dir_to_file(self):
 
1881
        """Directory becoming a file updates the entry."""
 
1882
        state, entry = self.get_state_with_a()
 
1883
        # The file sha1 won't be cached unless the file is old
 
1884
        state.adjust_time(+10)
 
1885
        self.create_and_test_dir(state, entry)
 
1886
        os.rmdir('a')
 
1887
        self.create_and_test_file(state, entry)
 
1888
 
 
1889
    def test_update_dir_to_symlink(self):
 
1890
        """Directory becomes a symlink"""
 
1891
        self.requireFeature(SymlinkFeature)
 
1892
        state, entry = self.get_state_with_a()
 
1893
        # The symlink target won't be cached if it isn't old
 
1894
        state.adjust_time(+10)
 
1895
        self.create_and_test_dir(state, entry)
 
1896
        os.rmdir('a')
 
1897
        self.create_and_test_symlink(state, entry)
 
1898
 
 
1899
    def test_update_symlink_to_file(self):
 
1900
        """Symlink becomes a file"""
 
1901
        self.requireFeature(SymlinkFeature)
 
1902
        state, entry = self.get_state_with_a()
 
1903
        # The symlink and file info won't be cached unless old
 
1904
        state.adjust_time(+10)
 
1905
        self.create_and_test_symlink(state, entry)
 
1906
        os.remove('a')
 
1907
        self.create_and_test_file(state, entry)
 
1908
 
 
1909
    def test_update_symlink_to_dir(self):
 
1910
        """Symlink becomes a directory"""
 
1911
        self.requireFeature(SymlinkFeature)
 
1912
        state, entry = self.get_state_with_a()
 
1913
        # The symlink target won't be cached if it isn't old
 
1914
        state.adjust_time(+10)
 
1915
        self.create_and_test_symlink(state, entry)
 
1916
        os.remove('a')
 
1917
        self.create_and_test_dir(state, entry)
 
1918
 
 
1919
    def test__is_executable_win32(self):
 
1920
        state, entry = self.get_state_with_a()
 
1921
        self.build_tree(['a'])
 
1922
 
 
1923
        # Make sure we are using the win32 implementation of _is_executable
 
1924
        state._is_executable = state._is_executable_win32
 
1925
 
 
1926
        # The file on disk is not executable, but we are marking it as though
 
1927
        # it is. With _is_executable_win32 we ignore what is on disk.
 
1928
        entry[1][0] = ('f', '', 0, True, dirstate.DirState.NULLSTAT)
 
1929
 
 
1930
        stat_value = os.lstat('a')
 
1931
        packed_stat = dirstate.pack_stat(stat_value)
 
1932
 
 
1933
        state.adjust_time(-10) # Make sure everything is new
 
1934
        state.update_entry(entry, abspath='a', stat_value=stat_value)
 
1935
 
 
1936
        # The row is updated, but the executable bit stays set.
 
1937
        self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
 
1938
                         entry[1])
 
1939
 
 
1940
        # Make the disk object look old enough to cache
 
1941
        state.adjust_time(+20)
 
1942
        digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1943
        state.update_entry(entry, abspath='a', stat_value=stat_value)
 
1944
        self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
 
1945
 
 
1946
 
 
1947
class TestPackStat(TestCaseWithTransport):
1745
1948
 
1746
1949
    def assertPackStat(self, expected, stat_value):
1747
1950
        """Check the packed and serialized form of a stat value."""
1812
2015
        # the end it would still be fairly arbitrary, and we don't want the
1813
2016
        # extra overhead if we can avoid it. So sort everything to make sure
1814
2017
        # equality is true
1815
 
        self.assertEqual(len(map_keys), len(paths))
 
2018
        assert len(map_keys) == len(paths)
1816
2019
        expected = {}
1817
2020
        for path, keys in zip(paths, map_keys):
1818
2021
            if keys is None:
1837
2040
        :param paths: A list of directories
1838
2041
        """
1839
2042
        result = state._bisect_dirblocks(paths)
1840
 
        self.assertEqual(len(map_keys), len(paths))
 
2043
        assert len(map_keys) == len(paths)
 
2044
 
1841
2045
        expected = {}
1842
2046
        for path, keys in zip(paths, map_keys):
1843
2047
            if keys is None:
2272
2476
        state._discard_merge_parents()
2273
2477
        state._validate()
2274
2478
        self.assertEqual(exp_dirblocks, state._dirblocks)
2275
 
 
2276
 
 
2277
 
class Test_InvEntryToDetails(tests.TestCase):
2278
 
 
2279
 
    def assertDetails(self, expected, inv_entry):
2280
 
        details = dirstate.DirState._inv_entry_to_details(inv_entry)
2281
 
        self.assertEqual(expected, details)
2282
 
        # details should always allow join() and always be a plain str when
2283
 
        # finished
2284
 
        (minikind, fingerprint, size, executable, tree_data) = details
2285
 
        self.assertIsInstance(minikind, str)
2286
 
        self.assertIsInstance(fingerprint, str)
2287
 
        self.assertIsInstance(tree_data, str)
2288
 
 
2289
 
    def test_unicode_symlink(self):
2290
 
        inv_entry = inventory.InventoryLink('link-file-id',
2291
 
                                            u'nam\N{Euro Sign}e',
2292
 
                                            'link-parent-id')
2293
 
        inv_entry.revision = 'link-revision-id'
2294
 
        target = u'link-targ\N{Euro Sign}t'
2295
 
        inv_entry.symlink_target = target
2296
 
        self.assertDetails(('l', target.encode('UTF-8'), 0, False,
2297
 
                            'link-revision-id'), inv_entry)
2298
 
 
2299
 
 
2300
 
class TestSHA1Provider(tests.TestCaseInTempDir):
2301
 
 
2302
 
    def test_sha1provider_is_an_interface(self):
2303
 
        p = dirstate.SHA1Provider()
2304
 
        self.assertRaises(NotImplementedError, p.sha1, "foo")
2305
 
        self.assertRaises(NotImplementedError, p.stat_and_sha1, "foo")
2306
 
 
2307
 
    def test_defaultsha1provider_sha1(self):
2308
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
2309
 
        self.build_tree_contents([('foo', text)])
2310
 
        expected_sha = osutils.sha_string(text)
2311
 
        p = dirstate.DefaultSHA1Provider()
2312
 
        self.assertEqual(expected_sha, p.sha1('foo'))
2313
 
 
2314
 
    def test_defaultsha1provider_stat_and_sha1(self):
2315
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
2316
 
        self.build_tree_contents([('foo', text)])
2317
 
        expected_sha = osutils.sha_string(text)
2318
 
        p = dirstate.DefaultSHA1Provider()
2319
 
        statvalue, sha1 = p.stat_and_sha1('foo')
2320
 
        self.assertTrue(len(statvalue) >= 10)
2321
 
        self.assertEqual(len(text), statvalue.st_size)
2322
 
        self.assertEqual(expected_sha, sha1)