← 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: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

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