← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test__dirstate_helpers.py

  • Committer: Robert Collins
  • Date: 2009-03-31 00:12:10 UTC
  • mto: This revision was merged to the branch mainline in revision 4219.
  • Revision ID: robertc@robertcollins.net-20090331001210-fufeq2heozx9jne0
Fix Tree.get_symlink_target to decode from the disk encoding to get a unicode encoded string.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test__dirstate_helpers.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007, 2008 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
27
27
    tests,
28
28
    )
29
29
from bzrlib.tests import (
30
 
    test_dirstate,
31
 
    test_osutils,
32
 
    )
33
 
 
34
 
try:
35
 
    from bzrlib import _dirstate_helpers_pyx
36
 
    has_dirstate_helpers_pyx = True
37
 
except ImportError:
38
 
    has_dirstate_helpers_pyx = False
39
 
 
40
 
 
41
 
compiled_dirstate_helpers_feature = tests.ModuleAvailableFeature(
42
 
                                'bzrlib._dirstate_helpers_pyx')
43
 
 
44
 
 
45
 
def load_tests(basic_tests, module, loader):
46
 
    # FIXME: we should also parametrize against SHA1Provider !
47
 
    suite = loader.suiteClass()
48
 
    remaining_tests = basic_tests
49
 
 
50
 
    dir_reader_scenarios = test_osutils.dir_reader_scenarios()
51
 
 
52
 
    ue_scenarios = [('dirstate_Python',
53
 
                     {'update_entry': dirstate.py_update_entry})]
54
 
    if compiled_dirstate_helpers_feature.available():
55
 
        update_entry = compiled_dirstate_helpers_feature.module.update_entry
56
 
        pyrex_scenario = ('dirstate_Pyrex', {'update_entry': update_entry})
57
 
        ue_scenarios.append(pyrex_scenario)
58
 
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
59
 
        remaining_tests, tests.condition_isinstance(TestUpdateEntry))
60
 
    tests.multiply_tests(process_entry_tests,
61
 
                         tests.multiply_scenarios(dir_reader_scenarios,
62
 
                                                  ue_scenarios),
63
 
                         suite)
64
 
 
65
 
    pe_scenarios = [('dirstate_Python',
66
 
                     {'_process_entry': dirstate.ProcessEntryPython})]
67
 
    if compiled_dirstate_helpers_feature.available():
68
 
        process_entry = compiled_dirstate_helpers_feature.module.ProcessEntryC
69
 
        pyrex_scenario = ('dirstate_Pyrex', {'_process_entry': process_entry})
70
 
        pe_scenarios.append(pyrex_scenario)
71
 
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
72
 
        remaining_tests, tests.condition_isinstance(TestProcessEntry))
73
 
    tests.multiply_tests(process_entry_tests,
74
 
                         tests.multiply_scenarios(dir_reader_scenarios,
75
 
                                                  pe_scenarios),
76
 
                         suite)
77
 
 
78
 
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
79
 
        remaining_tests, tests.condition_isinstance(
80
 
            test_dirstate.TestCaseWithDirState))
81
 
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios, suite)
82
 
    suite.addTest(remaining_tests)
83
 
 
84
 
    return suite
 
30
        SymlinkFeature,
 
31
        )
 
32
from bzrlib.tests import test_dirstate
 
33
 
 
34
 
 
35
class _CompiledDirstateHelpersFeature(tests.Feature):
 
36
    def _probe(self):
 
37
        try:
 
38
            import bzrlib._dirstate_helpers_c
 
39
        except ImportError:
 
40
            return False
 
41
        return True
 
42
 
 
43
    def feature_name(self):
 
44
        return 'bzrlib._dirstate_helpers_c'
 
45
 
 
46
CompiledDirstateHelpersFeature = _CompiledDirstateHelpersFeature()
85
47
 
86
48
 
87
49
class TestBisectPathMixin(object):
240
202
 
241
203
 
242
204
class TestBisectPathLeft(tests.TestCase, TestBisectPathMixin):
243
 
    """Run all Bisect Path tests against _bisect_path_left."""
 
205
    """Run all Bisect Path tests against _bisect_path_left_py."""
244
206
 
245
207
    def get_bisect_path(self):
246
 
        from bzrlib._dirstate_helpers_py import _bisect_path_left
247
 
        return _bisect_path_left
 
208
        from bzrlib._dirstate_helpers_py import _bisect_path_left_py
 
209
        return _bisect_path_left_py
248
210
 
249
211
    def get_bisect(self):
250
212
        return bisect.bisect_left, 0
251
213
 
252
214
 
253
215
class TestCompiledBisectPathLeft(TestBisectPathLeft):
254
 
    """Run all Bisect Path tests against _bisect_path_lect"""
 
216
    """Run all Bisect Path tests against _bisect_path_right_c"""
255
217
 
256
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
218
    _test_needs_features = [CompiledDirstateHelpersFeature]
257
219
 
258
220
    def get_bisect_path(self):
259
 
        from bzrlib._dirstate_helpers_pyx import _bisect_path_left
260
 
        return _bisect_path_left
 
221
        from bzrlib._dirstate_helpers_c import _bisect_path_left_c
 
222
        return _bisect_path_left_c
261
223
 
262
224
 
263
225
class TestBisectPathRight(tests.TestCase, TestBisectPathMixin):
264
 
    """Run all Bisect Path tests against _bisect_path_right"""
 
226
    """Run all Bisect Path tests against _bisect_path_right_py"""
265
227
 
266
228
    def get_bisect_path(self):
267
 
        from bzrlib._dirstate_helpers_py import _bisect_path_right
268
 
        return _bisect_path_right
 
229
        from bzrlib._dirstate_helpers_py import _bisect_path_right_py
 
230
        return _bisect_path_right_py
269
231
 
270
232
    def get_bisect(self):
271
233
        return bisect.bisect_right, -1
272
234
 
273
235
 
274
236
class TestCompiledBisectPathRight(TestBisectPathRight):
275
 
    """Run all Bisect Path tests against _bisect_path_right"""
 
237
    """Run all Bisect Path tests against _bisect_path_right_c"""
276
238
 
277
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
239
    _test_needs_features = [CompiledDirstateHelpersFeature]
278
240
 
279
241
    def get_bisect_path(self):
280
 
        from bzrlib._dirstate_helpers_pyx import _bisect_path_right
281
 
        return _bisect_path_right
 
242
        from bzrlib._dirstate_helpers_c import _bisect_path_right_c
 
243
        return _bisect_path_right_c
282
244
 
283
245
 
284
246
class TestBisectDirblock(tests.TestCase):
295
257
 
296
258
    def get_bisect_dirblock(self):
297
259
        """Return an implementation of bisect_dirblock"""
298
 
        from bzrlib._dirstate_helpers_py import bisect_dirblock
299
 
        return bisect_dirblock
 
260
        from bzrlib._dirstate_helpers_py import bisect_dirblock_py
 
261
        return bisect_dirblock_py
300
262
 
301
263
    def assertBisect(self, dirblocks, split_dirblocks, path, *args, **kwargs):
302
264
        """Assert that bisect_split works like bisect_left on the split paths.
386
348
    compiled version.
387
349
    """
388
350
 
389
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
351
    _test_needs_features = [CompiledDirstateHelpersFeature]
390
352
 
391
353
    def get_bisect_dirblock(self):
392
 
        from bzrlib._dirstate_helpers_pyx import bisect_dirblock
393
 
        return bisect_dirblock
 
354
        from bzrlib._dirstate_helpers_c import bisect_dirblock_c
 
355
        return bisect_dirblock_c
394
356
 
395
357
 
396
358
class TestCmpByDirs(tests.TestCase):
405
367
 
406
368
    def get_cmp_by_dirs(self):
407
369
        """Get a specific implementation of cmp_by_dirs."""
408
 
        from bzrlib._dirstate_helpers_py import cmp_by_dirs
409
 
        return cmp_by_dirs
 
370
        from bzrlib._dirstate_helpers_py import cmp_by_dirs_py
 
371
        return cmp_by_dirs_py
410
372
 
411
373
    def assertCmpByDirs(self, expected, str1, str2):
412
374
        """Compare the two strings, in both directions.
508
470
class TestCompiledCmpByDirs(TestCmpByDirs):
509
471
    """Test the pyrex implementation of cmp_by_dirs"""
510
472
 
511
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
473
    _test_needs_features = [CompiledDirstateHelpersFeature]
512
474
 
513
475
    def get_cmp_by_dirs(self):
514
 
        from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
515
 
        return cmp_by_dirs
 
476
        from bzrlib._dirstate_helpers_c import cmp_by_dirs_c
 
477
        return cmp_by_dirs_c
516
478
 
517
479
 
518
480
class TestCmpPathByDirblock(tests.TestCase):
527
489
 
528
490
    def get_cmp_path_by_dirblock(self):
529
491
        """Get a specific implementation of _cmp_path_by_dirblock."""
530
 
        from bzrlib._dirstate_helpers_py import _cmp_path_by_dirblock
531
 
        return _cmp_path_by_dirblock
 
492
        from bzrlib._dirstate_helpers_py import _cmp_path_by_dirblock_py
 
493
        return _cmp_path_by_dirblock_py
532
494
 
533
495
    def assertCmpPathByDirblock(self, paths):
534
496
        """Compare all paths and make sure they evaluate to the correct order.
659
621
class TestCompiledCmpPathByDirblock(TestCmpPathByDirblock):
660
622
    """Test the pyrex implementation of _cmp_path_by_dirblock"""
661
623
 
662
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
624
    _test_needs_features = [CompiledDirstateHelpersFeature]
663
625
 
664
626
    def get_cmp_by_dirs(self):
665
 
        from bzrlib._dirstate_helpers_pyx import _cmp_path_by_dirblock
666
 
        return _cmp_path_by_dirblock
 
627
        from bzrlib._dirstate_helpers_c import _cmp_path_by_dirblock_c
 
628
        return _cmp_path_by_dirblock_c
667
629
 
668
630
 
669
631
class TestMemRChr(tests.TestCase):
670
632
    """Test memrchr functionality"""
671
633
 
672
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
634
    _test_needs_features = [CompiledDirstateHelpersFeature]
673
635
 
674
636
    def assertMemRChr(self, expected, s, c):
675
 
        from bzrlib._dirstate_helpers_pyx import _py_memrchr
 
637
        from bzrlib._dirstate_helpers_c import _py_memrchr
676
638
        self.assertEqual(expected, _py_memrchr(s, c))
677
639
 
678
640
    def test_missing(self):
720
682
    """
721
683
 
722
684
    def get_read_dirblocks(self):
723
 
        from bzrlib._dirstate_helpers_py import _read_dirblocks
724
 
        return _read_dirblocks
 
685
        from bzrlib._dirstate_helpers_py import _read_dirblocks_py
 
686
        return _read_dirblocks_py
725
687
 
726
688
    def test_smoketest(self):
727
689
        """Make sure that we can create and read back a simple file."""
737
699
 
738
700
    def test_trailing_garbage(self):
739
701
        tree, state, expected = self.create_basic_dirstate()
740
 
        # On Unix, we can write extra data as long as we haven't read yet, but
741
 
        # on Win32, if you've opened the file with FILE_SHARE_READ, trying to
742
 
        # open it in append mode will fail.
743
 
        state.unlock()
 
702
        # We can modify the file as long as it hasn't been read yet.
744
703
        f = open('dirstate', 'ab')
745
704
        try:
746
705
            # Add bogus trailing garbage
747
706
            f.write('bogus\n')
748
707
        finally:
749
708
            f.close()
750
 
            state.lock_read()
751
709
        e = self.assertRaises(errors.DirstateCorrupt,
752
710
                              state._read_dirblocks_if_needed)
753
711
        # Make sure we mention the bogus characters in the error
757
715
class TestCompiledReadDirblocks(TestReadDirblocks):
758
716
    """Test the pyrex implementation of _read_dirblocks"""
759
717
 
760
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
718
    _test_needs_features = [CompiledDirstateHelpersFeature]
761
719
 
762
720
    def get_read_dirblocks(self):
763
 
        from bzrlib._dirstate_helpers_pyx import _read_dirblocks
764
 
        return _read_dirblocks
 
721
        from bzrlib._dirstate_helpers_c import _read_dirblocks_c
 
722
        return _read_dirblocks_c
765
723
 
766
724
 
767
725
class TestUsingCompiledIfAvailable(tests.TestCase):
768
726
    """Check that any compiled functions that are available are the default.
769
727
 
770
728
    It is possible to have typos, etc in the import line, such that
771
 
    _dirstate_helpers_pyx is actually available, but the compiled functions are
 
729
    _dirstate_helpers_c is actually available, but the compiled functions are
772
730
    not being used.
773
731
    """
774
732
 
775
733
    def test_bisect_dirblock(self):
776
 
        if compiled_dirstate_helpers_feature.available():
777
 
            from bzrlib._dirstate_helpers_pyx import bisect_dirblock
 
734
        if CompiledDirstateHelpersFeature.available():
 
735
            from bzrlib._dirstate_helpers_c import bisect_dirblock_c
 
736
            self.assertIs(bisect_dirblock_c, dirstate.bisect_dirblock)
778
737
        else:
779
 
            from bzrlib._dirstate_helpers_py import bisect_dirblock
780
 
        self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
 
738
            from bzrlib._dirstate_helpers_py import bisect_dirblock_py
 
739
            self.assertIs(bisect_dirblock_py, dirstate.bisect_dirblock)
781
740
 
782
741
    def test__bisect_path_left(self):
783
 
        if compiled_dirstate_helpers_feature.available():
784
 
            from bzrlib._dirstate_helpers_pyx import _bisect_path_left
 
742
        if CompiledDirstateHelpersFeature.available():
 
743
            from bzrlib._dirstate_helpers_c import _bisect_path_left_c
 
744
            self.assertIs(_bisect_path_left_c, dirstate._bisect_path_left)
785
745
        else:
786
 
            from bzrlib._dirstate_helpers_py import _bisect_path_left
787
 
        self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
 
746
            from bzrlib._dirstate_helpers_py import _bisect_path_left_py
 
747
            self.assertIs(_bisect_path_left_py, dirstate._bisect_path_left)
788
748
 
789
749
    def test__bisect_path_right(self):
790
 
        if compiled_dirstate_helpers_feature.available():
791
 
            from bzrlib._dirstate_helpers_pyx import _bisect_path_right
 
750
        if CompiledDirstateHelpersFeature.available():
 
751
            from bzrlib._dirstate_helpers_c import _bisect_path_right_c
 
752
            self.assertIs(_bisect_path_right_c, dirstate._bisect_path_right)
792
753
        else:
793
 
            from bzrlib._dirstate_helpers_py import _bisect_path_right
794
 
        self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
 
754
            from bzrlib._dirstate_helpers_py import _bisect_path_right_py
 
755
            self.assertIs(_bisect_path_right_py, dirstate._bisect_path_right)
795
756
 
796
757
    def test_cmp_by_dirs(self):
797
 
        if compiled_dirstate_helpers_feature.available():
798
 
            from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
 
758
        if CompiledDirstateHelpersFeature.available():
 
759
            from bzrlib._dirstate_helpers_c import cmp_by_dirs_c
 
760
            self.assertIs(cmp_by_dirs_c, dirstate.cmp_by_dirs)
799
761
        else:
800
 
            from bzrlib._dirstate_helpers_py import cmp_by_dirs
801
 
        self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
 
762
            from bzrlib._dirstate_helpers_py import cmp_by_dirs_py
 
763
            self.assertIs(cmp_by_dirs_py, dirstate.cmp_by_dirs)
802
764
 
803
765
    def test__read_dirblocks(self):
804
 
        if compiled_dirstate_helpers_feature.available():
805
 
            from bzrlib._dirstate_helpers_pyx import _read_dirblocks
 
766
        if CompiledDirstateHelpersFeature.available():
 
767
            from bzrlib._dirstate_helpers_c import _read_dirblocks_c
 
768
            self.assertIs(_read_dirblocks_c, dirstate._read_dirblocks)
806
769
        else:
807
 
            from bzrlib._dirstate_helpers_py import _read_dirblocks
808
 
        self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
 
770
            from bzrlib._dirstate_helpers_py import _read_dirblocks_py
 
771
            self.assertIs(_read_dirblocks_py, dirstate._read_dirblocks)
809
772
 
810
773
    def test_update_entry(self):
811
 
        if compiled_dirstate_helpers_feature.available():
812
 
            from bzrlib._dirstate_helpers_pyx import update_entry
 
774
        if CompiledDirstateHelpersFeature.available():
 
775
            from bzrlib._dirstate_helpers_c import update_entry
 
776
            self.assertIs(update_entry, dirstate.update_entry)
813
777
        else:
814
 
            from bzrlib.dirstate import update_entry
815
 
        self.assertIs(update_entry, dirstate.update_entry)
 
778
            from bzrlib.dirstate import py_update_entry
 
779
            self.assertIs(py_update_entry, dirstate.py_update_entry)
816
780
 
817
781
    def test_process_entry(self):
818
 
        if compiled_dirstate_helpers_feature.available():
819
 
            from bzrlib._dirstate_helpers_pyx import ProcessEntryC
 
782
        if CompiledDirstateHelpersFeature.available():
 
783
            from bzrlib._dirstate_helpers_c import ProcessEntryC
820
784
            self.assertIs(ProcessEntryC, dirstate._process_entry)
821
785
        else:
822
786
            from bzrlib.dirstate import ProcessEntryPython
826
790
class TestUpdateEntry(test_dirstate.TestCaseWithDirState):
827
791
    """Test the DirState.update_entry functions"""
828
792
 
829
 
    # Set by load_tests
830
 
    update_entry = None
831
 
 
832
 
    def setUp(self):
833
 
        super(TestUpdateEntry, self).setUp()
834
 
        self.overrideAttr(dirstate, 'update_entry', self.update_entry)
835
 
 
836
793
    def get_state_with_a(self):
837
794
        """Create a DirState tracking a single object named 'a'"""
838
795
        state = test_dirstate.InstrumentedDirState.initialize('dirstate')
839
796
        self.addCleanup(state.unlock)
840
797
        state.add('a', 'a-id', 'file', None, '')
841
798
        entry = state._get_entry(0, path_utf8='a')
 
799
        self.set_update_entry()
842
800
        return state, entry
843
801
 
 
802
    def set_update_entry(self):
 
803
        self.update_entry = dirstate.py_update_entry
 
804
 
844
805
    def test_observed_sha1_cachable(self):
845
806
        state, entry = self.get_state_with_a()
846
807
        atime = time.time() - 10
960
921
 
961
922
    def test_update_entry_symlink(self):
962
923
        """Update entry should read symlinks."""
963
 
        self.requireFeature(tests.SymlinkFeature)
 
924
        self.requireFeature(SymlinkFeature)
964
925
        state, entry = self.get_state_with_a()
965
926
        state.save()
966
927
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1061
1022
                         state._dirblock_state)
1062
1023
 
1063
1024
    def test_update_entry_tree_reference(self):
 
1025
        self.set_update_entry()
1064
1026
        state = test_dirstate.InstrumentedDirState.initialize('dirstate')
1065
1027
        self.addCleanup(state.unlock)
1066
1028
        state.add('r', 'r-id', 'tree-reference', None, '')
1102
1064
 
1103
1065
        return packed_stat
1104
1066
 
1105
 
    # FIXME: Add unicode version
1106
1067
    def create_and_test_symlink(self, state, entry):
1107
1068
        """Create a symlink at 'a' and verify the state finds it.
1108
1069
 
1137
1098
 
1138
1099
    def test_update_file_to_symlink(self):
1139
1100
        """File becomes a symlink"""
1140
 
        self.requireFeature(tests.SymlinkFeature)
 
1101
        self.requireFeature(SymlinkFeature)
1141
1102
        state, entry = self.get_state_with_a()
1142
1103
        # The file sha1 won't be cached unless the file is old
1143
1104
        state.adjust_time(+10)
1156
1117
 
1157
1118
    def test_update_dir_to_symlink(self):
1158
1119
        """Directory becomes a symlink"""
1159
 
        self.requireFeature(tests.SymlinkFeature)
 
1120
        self.requireFeature(SymlinkFeature)
1160
1121
        state, entry = self.get_state_with_a()
1161
1122
        # The symlink target won't be cached if it isn't old
1162
1123
        state.adjust_time(+10)
1166
1127
 
1167
1128
    def test_update_symlink_to_file(self):
1168
1129
        """Symlink becomes a file"""
1169
 
        self.requireFeature(tests.SymlinkFeature)
 
1130
        self.requireFeature(SymlinkFeature)
1170
1131
        state, entry = self.get_state_with_a()
1171
1132
        # The symlink and file info won't be cached unless old
1172
1133
        state.adjust_time(+10)
1176
1137
 
1177
1138
    def test_update_symlink_to_dir(self):
1178
1139
        """Symlink becomes a directory"""
1179
 
        self.requireFeature(tests.SymlinkFeature)
 
1140
        self.requireFeature(SymlinkFeature)
1180
1141
        state, entry = self.get_state_with_a()
1181
1142
        # The symlink target won't be cached if it isn't old
1182
1143
        state.adjust_time(+10)
1205
1166
        self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
1206
1167
                         entry[1])
1207
1168
 
1208
 
        # Make the disk object look old enough to cache (but it won't cache the
1209
 
        # sha as it is a new file).
 
1169
        # Make the disk object look old enough to cache (but it won't cache the sha
 
1170
        # as it is a new file).
1210
1171
        state.adjust_time(+20)
1211
1172
        digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
1212
1173
        self.update_entry(state, entry, abspath='a', stat_value=stat_value)
1233
1194
        entry = state._get_entry(0, path_utf8='a file')
1234
1195
        state._sha_cutoff_time()
1235
1196
        state._cutoff_time += 10
1236
 
        sha1 = self.update_entry(state, entry, 'tree/a file',
1237
 
                                 os.lstat('tree/a file'))
 
1197
        sha1 = dirstate.update_entry(state, entry, 'tree/a file',
 
1198
            os.lstat('tree/a file'))
1238
1199
        self.assertEqual(expected_sha, sha1)
1239
1200
 
1240
1201
    def test_sha1provider_stat_and_sha1_used(self):
1245
1206
        state._sha1_provider = UppercaseSHA1Provider()
1246
1207
        # If we used the standard provider, it would look like nothing has
1247
1208
        # changed
1248
 
        file_ids_changed = [change[0] for change
1249
 
                            in tree.iter_changes(tree.basis_tree())]
 
1209
        file_ids_changed = [change[0] for change 
 
1210
                in tree.iter_changes(tree.basis_tree())]
1250
1211
        self.assertEqual(['a-file-id'], file_ids_changed)
1251
1212
 
1252
1213
 
1267
1228
        return statvalue, sha1
1268
1229
 
1269
1230
 
1270
 
class TestProcessEntry(test_dirstate.TestCaseWithDirState):
1271
 
 
1272
 
    # Set by load_tests
1273
 
    _process_entry = None
 
1231
class TestCompiledUpdateEntry(TestUpdateEntry):
 
1232
    """Test the pyrex implementation of _read_dirblocks"""
 
1233
 
 
1234
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
1235
 
 
1236
    def set_update_entry(self):
 
1237
        from bzrlib._dirstate_helpers_c import update_entry
 
1238
        self.update_entry = update_entry
 
1239
 
 
1240
 
 
1241
class TestProcessEntryPython(test_dirstate.TestCaseWithDirState):
1274
1242
 
1275
1243
    def setUp(self):
1276
 
        super(TestProcessEntry, self).setUp()
1277
 
        self.overrideAttr(dirstate, '_process_entry', self._process_entry)
 
1244
        super(TestProcessEntryPython, self).setUp()
 
1245
        self.setup_process_entry()
 
1246
 
 
1247
    def setup_process_entry(self):
 
1248
        from bzrlib import dirstate
 
1249
        orig = dirstate._process_entry
 
1250
        def cleanup():
 
1251
            dirstate._process_entry = orig
 
1252
        self.addCleanup(cleanup)
 
1253
        dirstate._process_entry = dirstate.ProcessEntryPython
1278
1254
 
1279
1255
    def assertChangedFileIds(self, expected, tree):
1280
1256
        tree.lock_read()
1285
1261
            tree.unlock()
1286
1262
        self.assertEqual(sorted(expected), sorted(file_ids))
1287
1263
 
1288
 
    def test_exceptions_raised(self):
1289
 
        # This is a direct test of bug #495023, it relies on osutils.is_inside
1290
 
        # getting called in an inner function. Which makes it a bit brittle,
1291
 
        # but at least it does reproduce the bug.
1292
 
        tree = self.make_branch_and_tree('tree')
1293
 
        self.build_tree(['tree/file', 'tree/dir/', 'tree/dir/sub',
1294
 
                         'tree/dir2/', 'tree/dir2/sub2'])
1295
 
        tree.add(['file', 'dir', 'dir/sub', 'dir2', 'dir2/sub2'])
1296
 
        tree.commit('first commit')
1297
 
        tree.lock_read()
1298
 
        self.addCleanup(tree.unlock)
1299
 
        basis_tree = tree.basis_tree()
1300
 
        def is_inside_raises(*args, **kwargs):
1301
 
            raise RuntimeError('stop this')
1302
 
        self.overrideAttr(osutils, 'is_inside', is_inside_raises)
1303
 
        self.assertListRaises(RuntimeError, tree.iter_changes, basis_tree)
1304
 
 
1305
1264
    def test_simple_changes(self):
1306
1265
        tree = self.make_branch_and_tree('tree')
1307
1266
        self.build_tree(['tree/file'])
1321
1280
        state._sha1_provider = UppercaseSHA1Provider()
1322
1281
        self.assertChangedFileIds(['file-id'], tree)
1323
1282
 
 
1283
 
 
1284
class TestProcessEntryC(TestProcessEntryPython):
 
1285
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
1286
 
 
1287
    def setup_process_entry(self):
 
1288
        from bzrlib import _dirstate_helpers_c
 
1289
        orig = dirstate._process_entry
 
1290
        def cleanup():
 
1291
            dirstate._process_entry = orig
 
1292
        self.addCleanup(cleanup)
 
1293
        dirstate._process_entry = _dirstate_helpers_c.ProcessEntryC
 
1294