← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_dirstate.py

  • Committer: Martin Pool
  • Date: 2009-01-13 03:11:04 UTC
  • mto: This revision was merged to the branch mainline in revision 3937.
  • Revision ID: mbp@sourcefrog.net-20090113031104-03my054s02i9l2pe
Bump version to 1.12 and add news template

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