/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: Andrew Bennetts
  • Date: 2010-04-13 04:33:55 UTC
  • mfrom: (5147 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5149.
  • Revision ID: andrew.bennetts@canonical.com-20100413043355-lg3id0uwtju0k3zs
Merge lp:bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_dirstate.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests of the dirstate functionality being built for WorkingTreeFormat4."""
18
18
 
23
23
    dirstate,
24
24
    errors,
25
25
    inventory,
 
26
    memorytree,
26
27
    osutils,
27
28
    revision as _mod_revision,
 
29
    tests,
28
30
    )
29
 
from bzrlib.memorytree import MemoryTree
30
 
from bzrlib.tests import (
31
 
        SymlinkFeature,
32
 
        TestCase,
33
 
        TestCaseWithTransport,
34
 
        )
 
31
from bzrlib.tests import test_osutils
35
32
 
36
33
 
37
34
# TODO:
47
44
# set_path_id  setting id when state is in memory modified
48
45
 
49
46
 
50
 
class TestCaseWithDirState(TestCaseWithTransport):
 
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):
51
58
    """Helper functions for creating DirState objects with various content."""
52
59
 
 
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
 
53
70
    def create_empty_dirstate(self):
54
71
        """Return a locked but empty dirstate"""
55
72
        state = dirstate.DirState.initialize('dirstate')
396
413
            (('', '', tree.get_root_id()), # common details
397
414
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
398
415
              ('d', '', 0, False, rev_id), # first parent details
399
 
              ('d', '', 0, False, rev_id2), # second parent details
 
416
              ('d', '', 0, False, rev_id), # second parent details
400
417
             ])])
401
418
        state = dirstate.DirState.from_tree(tree, 'dirstate')
402
419
        self.check_state_with_reopen(expected_result, state)
477
494
            (('', '', tree.get_root_id()), # common details
478
495
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
479
496
              ('d', '', 0, False, rev_id), # first parent details
480
 
              ('d', '', 0, False, rev_id2), # second parent details
 
497
              ('d', '', 0, False, rev_id), # second parent details
481
498
             ]),
482
499
            (('', 'a file', 'a-file-id'), # common
483
500
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
639
656
                state2.unlock()
640
657
        finally:
641
658
            state.unlock()
642
 
        
 
659
 
643
660
        # The file on disk should not be modified.
644
661
        state = dirstate.DirState.on_file('dirstate')
645
662
        state.lock_read()
745
762
        # https://bugs.launchpad.net/bzr/+bug/146176
746
763
        # set_state_from_inventory should preserve the stat and hash value for
747
764
        # workingtree files that are not changed by the inventory.
748
 
       
 
765
 
749
766
        tree = self.make_branch_and_tree('.')
750
767
        # depends on the default format using dirstate...
751
768
        tree.lock_write()
752
769
        try:
753
 
            # make a dirstate with some valid hashcache data 
 
770
            # make a dirstate with some valid hashcache data
754
771
            # file on disk, but that's not needed for this test
755
772
            foo_contents = 'contents of foo'
756
773
            self.build_tree_contents([('foo', foo_contents)])
776
793
                (('', 'foo', 'foo-id',),
777
794
                 [('f', foo_sha, foo_size, False, foo_packed)]),
778
795
                tree._dirstate._get_entry(0, 'foo-id'))
779
 
           
 
796
 
780
797
            # extract the inventory, and add something to it
781
798
            inv = tree._get_inventory()
782
799
            # should see the file we poked in...
804
821
        finally:
805
822
            tree.unlock()
806
823
 
807
 
 
808
824
    def test_set_state_from_inventory_mixed_paths(self):
809
825
        tree1 = self.make_branch_and_tree('tree1')
810
826
        self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
851
867
        state = dirstate.DirState.initialize('dirstate')
852
868
        try:
853
869
            # check precondition to be sure the state does change appropriately.
854
 
            self.assertEqual(
855
 
                [(('', '', 'TREE_ROOT'), [('d', '', 0, False,
856
 
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])],
857
 
                list(state._iter_entries()))
858
 
            state.set_path_id('', 'foobarbaz')
859
 
            expected_rows = [
860
 
                (('', '', 'foobarbaz'), [('d', '', 0, False,
861
 
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])]
 
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]
862
881
            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'))
863
887
            # should work across save too
864
888
            state.save()
865
889
        finally:
883
907
        state._validate()
884
908
        try:
885
909
            state.set_parent_trees([('parent-revid', rt)], ghosts=[])
886
 
            state.set_path_id('', 'foobarbaz')
 
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')
887
919
            state._validate()
888
920
            # now see that it is what we expected
889
 
            expected_rows = [
890
 
                (('', '', 'TREE_ROOT'),
891
 
                    [('a', '', 0, False, ''),
892
 
                     ('d', '', 0, False, 'parent-revid'),
893
 
                     ]),
894
 
                (('', '', 'foobarbaz'),
895
 
                    [('d', '', 0, False, ''),
896
 
                     ('a', '', 0, False, ''),
897
 
                     ]),
898
 
                ]
 
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]
899
928
            state._validate()
900
929
            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'))
901
940
            # should work across save too
902
941
            state.save()
903
942
        finally:
919
958
        finally:
920
959
            state.unlock()
921
960
 
922
 
 
923
961
    def test_set_parent_trees_no_content(self):
924
962
        # set_parent_trees is a slow but important api to support.
925
963
        tree1 = self.make_branch_and_memory_tree('tree1')
930
968
        finally:
931
969
            tree1.unlock()
932
970
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
933
 
        tree2 = MemoryTree.create_on_branch(branch2)
 
971
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
934
972
        tree2.lock_write()
935
973
        try:
936
974
            revid2 = tree2.commit('foo')
979
1017
                [(('', '', root_id), [
980
1018
                  ('d', '', 0, False, dirstate.DirState.NULLSTAT),
981
1019
                  ('d', '', 0, False, revid1),
982
 
                  ('d', '', 0, False, revid2)
 
1020
                  ('d', '', 0, False, revid1)
983
1021
                  ])],
984
1022
                list(state._iter_entries()))
985
1023
        finally:
1000
1038
        finally:
1001
1039
            tree1.unlock()
1002
1040
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1003
 
        tree2 = MemoryTree.create_on_branch(branch2)
 
1041
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
1004
1042
        tree2.lock_write()
1005
1043
        try:
1006
1044
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1013
1051
            (('', '', root_id), [
1014
1052
             ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1015
1053
             ('d', '', 0, False, revid1.encode('utf8')),
1016
 
             ('d', '', 0, False, revid2.encode('utf8'))
 
1054
             ('d', '', 0, False, revid1.encode('utf8'))
1017
1055
             ]),
1018
1056
            (('', 'a file', 'file-id'), [
1019
1057
             ('a', '', 0, False, ''),
1065
1103
            state.unlock()
1066
1104
        state = dirstate.DirState.on_file('dirstate')
1067
1105
        state.lock_read()
1068
 
        try:
1069
 
            self.assertEqual(expected_entries, list(state._iter_entries()))
1070
 
        finally:
1071
 
            state.unlock()
 
1106
        self.addCleanup(state.unlock)
 
1107
        self.assertEqual(expected_entries, list(state._iter_entries()))
1072
1108
 
1073
1109
    def test_add_path_to_unversioned_directory(self):
1074
1110
        """Adding a path to an unversioned directory should error.
1079
1115
        """
1080
1116
        self.build_tree(['unversioned/', 'unversioned/a file'])
1081
1117
        state = dirstate.DirState.initialize('dirstate')
1082
 
        try:
1083
 
            self.assertRaises(errors.NotVersionedError, state.add,
1084
 
                'unversioned/a file', 'a-file-id', 'file', None, None)
1085
 
        finally:
1086
 
            state.unlock()
 
1118
        self.addCleanup(state.unlock)
 
1119
        self.assertRaises(errors.NotVersionedError, state.add,
 
1120
                          'unversioned/a file', 'a-file-id', 'file', None, None)
1087
1121
 
1088
1122
    def test_add_directory_to_root_no_parents_all_data(self):
1089
1123
        # The most trivial addition of a dir is when there are no parents and
1109
1143
            state.unlock()
1110
1144
        state = dirstate.DirState.on_file('dirstate')
1111
1145
        state.lock_read()
 
1146
        self.addCleanup(state.unlock)
1112
1147
        state._validate()
1113
 
        try:
1114
 
            self.assertEqual(expected_entries, list(state._iter_entries()))
1115
 
        finally:
1116
 
            state.unlock()
 
1148
        self.assertEqual(expected_entries, list(state._iter_entries()))
1117
1149
 
1118
 
    def test_add_symlink_to_root_no_parents_all_data(self):
 
1150
    def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
1119
1151
        # The most trivial addition of a symlink when there are no parents and
1120
1152
        # its in the root and all data about the file is supplied
1121
1153
        # bzr doesn't support fake symlinks on windows, yet.
1122
 
        self.requireFeature(SymlinkFeature)
1123
 
        os.symlink('target', 'a link')
1124
 
        stat = os.lstat('a link')
 
1154
        self.requireFeature(tests.SymlinkFeature)
 
1155
        os.symlink(target, link_name)
 
1156
        stat = os.lstat(link_name)
1125
1157
        expected_entries = [
1126
1158
            (('', '', 'TREE_ROOT'), [
1127
1159
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1128
1160
             ]),
1129
 
            (('', 'a link', 'a link id'), [
1130
 
             ('l', 'target', 6, False, dirstate.pack_stat(stat)), # current tree
 
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
1131
1164
             ]),
1132
1165
            ]
1133
1166
        state = dirstate.DirState.initialize('dirstate')
1134
1167
        try:
1135
 
            state.add('a link', 'a link id', 'symlink', stat, 'target')
 
1168
            state.add(link_name, 'a link id', 'symlink', stat,
 
1169
                      target.encode('UTF-8'))
1136
1170
            # having added it, it should be in the output of iter_entries.
1137
1171
            self.assertEqual(expected_entries, list(state._iter_entries()))
1138
1172
            # saving and reloading should not affect this.
1141
1175
            state.unlock()
1142
1176
        state = dirstate.DirState.on_file('dirstate')
1143
1177
        state.lock_read()
1144
 
        try:
1145
 
            self.assertEqual(expected_entries, list(state._iter_entries()))
1146
 
        finally:
1147
 
            state.unlock()
 
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')
1148
1188
 
1149
1189
    def test_add_directory_and_child_no_parents_all_data(self):
1150
1190
        # after adding a directory, we should be able to add children to it.
1175
1215
            state.unlock()
1176
1216
        state = dirstate.DirState.on_file('dirstate')
1177
1217
        state.lock_read()
1178
 
        try:
1179
 
            self.assertEqual(expected_entries, list(state._iter_entries()))
1180
 
        finally:
1181
 
            state.unlock()
 
1218
        self.addCleanup(state.unlock)
 
1219
        self.assertEqual(expected_entries, list(state._iter_entries()))
1182
1220
 
1183
1221
    def test_add_tree_reference(self):
1184
1222
        # make a dirstate and add a tree reference
1198
1236
            state.unlock()
1199
1237
        # now check we can read it back
1200
1238
        state.lock_read()
 
1239
        self.addCleanup(state.unlock)
1201
1240
        state._validate()
1202
 
        try:
1203
 
            entry2 = state._get_entry(0, 'subdir-id', 'subdir')
1204
 
            self.assertEqual(entry, entry2)
1205
 
            self.assertEqual(entry, expected_entry)
1206
 
            # and lookup by id should work too
1207
 
            entry2 = state._get_entry(0, fileid_utf8='subdir-id')
1208
 
            self.assertEqual(entry, expected_entry)
1209
 
        finally:
1210
 
            state.unlock()
 
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)
1211
1247
 
1212
1248
    def test_add_forbidden_names(self):
1213
1249
        state = dirstate.DirState.initialize('dirstate')
1217
1253
        self.assertRaises(errors.BzrError,
1218
1254
            state.add, '..', 'ass-id', 'directory', None, None)
1219
1255
 
 
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
 
1220
1288
 
1221
1289
class TestGetLines(TestCaseWithDirState):
1222
1290
 
1455
1523
        There is one parent tree, which has the same shape with the following variations:
1456
1524
        b/g in the parent is gone.
1457
1525
        b/h in the parent has a different id
1458
 
        b/i is new in the parent 
 
1526
        b/i is new in the parent
1459
1527
        c is renamed to b/j in the parent
1460
1528
 
1461
1529
        :return: The dirstate, still write-locked.
1551
1619
            list(state._iter_child_entries(1, '')))
1552
1620
 
1553
1621
 
1554
 
class TestDirstateSortOrder(TestCaseWithTransport):
 
1622
class TestDirstateSortOrder(tests.TestCaseWithTransport):
1555
1623
    """Test that DirState adds entries in the right order."""
1556
1624
 
1557
1625
    def test_add_sorting(self):
1616
1684
class InstrumentedDirState(dirstate.DirState):
1617
1685
    """An DirState with instrumented sha1 functionality."""
1618
1686
 
1619
 
    def __init__(self, path):
1620
 
        super(InstrumentedDirState, self).__init__(path)
 
1687
    def __init__(self, path, sha1_provider):
 
1688
        super(InstrumentedDirState, self).__init__(path, sha1_provider)
1621
1689
        self._time_offset = 0
1622
1690
        self._log = []
1623
1691
        # member is dynamically set in DirState.__init__ to turn on trace
 
1692
        self._sha1_provider = sha1_provider
1624
1693
        self._sha1_file = self._sha1_file_and_log
1625
1694
 
1626
1695
    def _sha_cutoff_time(self):
1629
1698
 
1630
1699
    def _sha1_file_and_log(self, abspath):
1631
1700
        self._log.append(('sha1', abspath))
1632
 
        return osutils.sha_file_by_name(abspath)
 
1701
        return self._sha1_provider.sha1(abspath)
1633
1702
 
1634
1703
    def _read_link(self, abspath, old_link):
1635
1704
        self._log.append(('read_link', abspath, old_link))
1666
1735
        self.st_ino = ino
1667
1736
        self.st_mode = mode
1668
1737
 
1669
 
 
1670
 
class TestPackStat(TestCaseWithTransport):
 
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):
1671
1745
 
1672
1746
    def assertPackStat(self, expected, stat_value):
1673
1747
        """Check the packed and serialized form of a stat value."""
2200
2274
        self.assertEqual(exp_dirblocks, state._dirblocks)
2201
2275
 
2202
2276
 
2203
 
class Test_InvEntryToDetails(TestCaseWithDirState):
 
2277
class Test_InvEntryToDetails(tests.TestCase):
2204
2278
 
2205
2279
    def assertDetails(self, expected, inv_entry):
2206
2280
        details = dirstate.DirState._inv_entry_to_details(inv_entry)
2213
2287
        self.assertIsInstance(tree_data, str)
2214
2288
 
2215
2289
    def test_unicode_symlink(self):
2216
 
        # In general, the code base doesn't support a target that contains
2217
 
        # non-ascii characters. So we just assert tha 
2218
 
        inv_entry = inventory.InventoryLink('link-file-id', 'name',
 
2290
        inv_entry = inventory.InventoryLink('link-file-id',
 
2291
                                            u'nam\N{Euro Sign}e',
2219
2292
                                            'link-parent-id')
2220
2293
        inv_entry.revision = 'link-revision-id'
2221
 
        inv_entry.symlink_target = u'link-target'
2222
 
        details = self.assertDetails(('l', 'link-target', 0, False,
2223
 
                                      'link-revision-id'), inv_entry)
 
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)