← 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: Jelmer Vernooij
  • Date: 2010-12-20 11:57:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5577.
  • Revision ID: jelmer@samba.org-20101220115714-2ru3hfappjweeg7q
Don't use no-plugins.

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
28
28
    )
29
29
from bzrlib.tests import (
30
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
 
class _CompiledDirstateHelpersFeature(tests.Feature):
42
 
    def _probe(self):
43
 
        return has_dirstate_helpers_pyx
44
 
 
45
 
    def feature_name(self):
46
 
        return 'bzrlib._dirstate_helpers_pyx'
47
 
CompiledDirstateHelpersFeature = _CompiledDirstateHelpersFeature()
48
 
 
49
 
 
50
 
def load_tests(basic_tests, module, loader):
51
 
    # FIXME: we should also parametrize against SHA1Provider !
52
 
    suite = loader.suiteClass()
53
 
    remaining_tests = basic_tests
54
 
 
55
 
    dir_reader_scenarios = test_osutils.dir_reader_scenarios()
56
 
 
57
 
    ue_scenarios = [('dirstate_Python',
58
 
                     {'update_entry': dirstate.py_update_entry})]
59
 
    if has_dirstate_helpers_pyx:
60
 
        pyrex_scenario = ('dirstate_Pyrex',
61
 
                          {'update_entry': _dirstate_helpers_pyx.update_entry})
62
 
        ue_scenarios.append(pyrex_scenario)
63
 
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
64
 
        remaining_tests, tests.condition_isinstance(TestUpdateEntry))
65
 
    tests.multiply_tests(process_entry_tests,
66
 
                         tests.multiply_scenarios(dir_reader_scenarios,
67
 
                                                  ue_scenarios),
68
 
                         suite)
69
 
 
70
 
    pe_scenarios = [('dirstate_Python',
71
 
                     {'_process_entry': dirstate.ProcessEntryPython})]
72
 
    if has_dirstate_helpers_pyx:
73
 
        pyrex_scenario = (
74
 
            'dirstate_Pyrex',
75
 
            {'_process_entry': _dirstate_helpers_pyx.ProcessEntryC})
76
 
        pe_scenarios.append(pyrex_scenario)
77
 
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
78
 
        remaining_tests, tests.condition_isinstance(TestProcessEntry))
79
 
    tests.multiply_tests(process_entry_tests,
80
 
                         tests.multiply_scenarios(dir_reader_scenarios,
81
 
                                                  pe_scenarios),
82
 
                         suite)
83
 
 
84
 
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
85
 
        remaining_tests, tests.condition_isinstance(
86
 
            test_dirstate.TestCaseWithDirState))
87
 
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios, suite)
88
 
    suite.addTest(remaining_tests)
89
 
 
90
 
    return suite
 
31
    )
 
32
from bzrlib.tests.test_osutils import dir_reader_scenarios
 
33
from bzrlib.tests.scenarios import (
 
34
    load_tests_apply_scenarios,
 
35
    multiply_scenarios,
 
36
    )
 
37
 
 
38
 
 
39
load_tests = load_tests_apply_scenarios
 
40
 
 
41
 
 
42
compiled_dirstate_helpers_feature = tests.ModuleAvailableFeature(
 
43
    'bzrlib._dirstate_helpers_pyx')
 
44
 
 
45
 
 
46
# FIXME: we should also parametrize against SHA1Provider !
 
47
 
 
48
ue_scenarios = [('dirstate_Python',
 
49
    {'update_entry': dirstate.py_update_entry})]
 
50
if compiled_dirstate_helpers_feature.available():
 
51
    update_entry = compiled_dirstate_helpers_feature.module.update_entry
 
52
    ue_scenarios.append(('dirstate_Pyrex', {'update_entry': update_entry}))
 
53
 
 
54
pe_scenarios = [('dirstate_Python',
 
55
    {'_process_entry': dirstate.ProcessEntryPython})]
 
56
if compiled_dirstate_helpers_feature.available():
 
57
    process_entry = compiled_dirstate_helpers_feature.module.ProcessEntryC
 
58
    pe_scenarios.append(('dirstate_Pyrex', {'_process_entry': process_entry}))
91
59
 
92
60
 
93
61
class TestBisectPathMixin(object):
259
227
class TestCompiledBisectPathLeft(TestBisectPathLeft):
260
228
    """Run all Bisect Path tests against _bisect_path_lect"""
261
229
 
262
 
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
230
    _test_needs_features = [compiled_dirstate_helpers_feature]
263
231
 
264
232
    def get_bisect_path(self):
265
233
        from bzrlib._dirstate_helpers_pyx import _bisect_path_left
280
248
class TestCompiledBisectPathRight(TestBisectPathRight):
281
249
    """Run all Bisect Path tests against _bisect_path_right"""
282
250
 
283
 
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
251
    _test_needs_features = [compiled_dirstate_helpers_feature]
284
252
 
285
253
    def get_bisect_path(self):
286
254
        from bzrlib._dirstate_helpers_pyx import _bisect_path_right
392
360
    compiled version.
393
361
    """
394
362
 
395
 
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
363
    _test_needs_features = [compiled_dirstate_helpers_feature]
396
364
 
397
365
    def get_bisect_dirblock(self):
398
366
        from bzrlib._dirstate_helpers_pyx import bisect_dirblock
514
482
class TestCompiledCmpByDirs(TestCmpByDirs):
515
483
    """Test the pyrex implementation of cmp_by_dirs"""
516
484
 
517
 
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
485
    _test_needs_features = [compiled_dirstate_helpers_feature]
518
486
 
519
487
    def get_cmp_by_dirs(self):
520
488
        from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
665
633
class TestCompiledCmpPathByDirblock(TestCmpPathByDirblock):
666
634
    """Test the pyrex implementation of _cmp_path_by_dirblock"""
667
635
 
668
 
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
636
    _test_needs_features = [compiled_dirstate_helpers_feature]
669
637
 
670
638
    def get_cmp_by_dirs(self):
671
639
        from bzrlib._dirstate_helpers_pyx import _cmp_path_by_dirblock
675
643
class TestMemRChr(tests.TestCase):
676
644
    """Test memrchr functionality"""
677
645
 
678
 
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
646
    _test_needs_features = [compiled_dirstate_helpers_feature]
679
647
 
680
648
    def assertMemRChr(self, expected, s, c):
681
649
        from bzrlib._dirstate_helpers_pyx import _py_memrchr
725
693
    implementation.
726
694
    """
727
695
 
 
696
    # inherits scenarios from test_dirstate
 
697
 
728
698
    def get_read_dirblocks(self):
729
699
        from bzrlib._dirstate_helpers_py import _read_dirblocks
730
700
        return _read_dirblocks
743
713
 
744
714
    def test_trailing_garbage(self):
745
715
        tree, state, expected = self.create_basic_dirstate()
746
 
        # We can modify the file as long as it hasn't been read yet.
 
716
        # On Unix, we can write extra data as long as we haven't read yet, but
 
717
        # on Win32, if you've opened the file with FILE_SHARE_READ, trying to
 
718
        # open it in append mode will fail.
 
719
        state.unlock()
747
720
        f = open('dirstate', 'ab')
748
721
        try:
749
722
            # Add bogus trailing garbage
750
723
            f.write('bogus\n')
751
724
        finally:
752
725
            f.close()
 
726
            state.lock_read()
753
727
        e = self.assertRaises(errors.DirstateCorrupt,
754
728
                              state._read_dirblocks_if_needed)
755
729
        # Make sure we mention the bogus characters in the error
759
733
class TestCompiledReadDirblocks(TestReadDirblocks):
760
734
    """Test the pyrex implementation of _read_dirblocks"""
761
735
 
762
 
    _test_needs_features = [CompiledDirstateHelpersFeature]
 
736
    _test_needs_features = [compiled_dirstate_helpers_feature]
763
737
 
764
738
    def get_read_dirblocks(self):
765
739
        from bzrlib._dirstate_helpers_pyx import _read_dirblocks
775
749
    """
776
750
 
777
751
    def test_bisect_dirblock(self):
778
 
        if CompiledDirstateHelpersFeature.available():
 
752
        if compiled_dirstate_helpers_feature.available():
779
753
            from bzrlib._dirstate_helpers_pyx import bisect_dirblock
780
754
        else:
781
755
            from bzrlib._dirstate_helpers_py import bisect_dirblock
782
756
        self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
783
757
 
784
758
    def test__bisect_path_left(self):
785
 
        if CompiledDirstateHelpersFeature.available():
 
759
        if compiled_dirstate_helpers_feature.available():
786
760
            from bzrlib._dirstate_helpers_pyx import _bisect_path_left
787
761
        else:
788
762
            from bzrlib._dirstate_helpers_py import _bisect_path_left
789
763
        self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
790
764
 
791
765
    def test__bisect_path_right(self):
792
 
        if CompiledDirstateHelpersFeature.available():
 
766
        if compiled_dirstate_helpers_feature.available():
793
767
            from bzrlib._dirstate_helpers_pyx import _bisect_path_right
794
768
        else:
795
769
            from bzrlib._dirstate_helpers_py import _bisect_path_right
796
770
        self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
797
771
 
798
772
    def test_cmp_by_dirs(self):
799
 
        if CompiledDirstateHelpersFeature.available():
 
773
        if compiled_dirstate_helpers_feature.available():
800
774
            from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
801
775
        else:
802
776
            from bzrlib._dirstate_helpers_py import cmp_by_dirs
803
777
        self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
804
778
 
805
779
    def test__read_dirblocks(self):
806
 
        if CompiledDirstateHelpersFeature.available():
 
780
        if compiled_dirstate_helpers_feature.available():
807
781
            from bzrlib._dirstate_helpers_pyx import _read_dirblocks
808
782
        else:
809
783
            from bzrlib._dirstate_helpers_py import _read_dirblocks
810
784
        self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
811
785
 
812
786
    def test_update_entry(self):
813
 
        if CompiledDirstateHelpersFeature.available():
 
787
        if compiled_dirstate_helpers_feature.available():
814
788
            from bzrlib._dirstate_helpers_pyx import update_entry
815
789
        else:
816
790
            from bzrlib.dirstate import update_entry
817
791
        self.assertIs(update_entry, dirstate.update_entry)
818
792
 
819
793
    def test_process_entry(self):
820
 
        if CompiledDirstateHelpersFeature.available():
 
794
        if compiled_dirstate_helpers_feature.available():
821
795
            from bzrlib._dirstate_helpers_pyx import ProcessEntryC
822
796
            self.assertIs(ProcessEntryC, dirstate._process_entry)
823
797
        else:
828
802
class TestUpdateEntry(test_dirstate.TestCaseWithDirState):
829
803
    """Test the DirState.update_entry functions"""
830
804
 
 
805
    scenarios = multiply_scenarios(
 
806
        dir_reader_scenarios(), ue_scenarios)
 
807
 
831
808
    # Set by load_tests
832
809
    update_entry = None
833
810
 
834
811
    def setUp(self):
835
812
        super(TestUpdateEntry, self).setUp()
836
 
        orig = dirstate.update_entry
837
 
        def cleanup():
838
 
            dirstate.update_entry = orig
839
 
        self.addCleanup(cleanup)
840
 
        dirstate.update_entry = self.update_entry
 
813
        self.overrideAttr(dirstate, 'update_entry', self.update_entry)
841
814
 
842
815
    def get_state_with_a(self):
843
816
        """Create a DirState tracking a single object named 'a'"""
1275
1248
 
1276
1249
class TestProcessEntry(test_dirstate.TestCaseWithDirState):
1277
1250
 
 
1251
    scenarios = multiply_scenarios(dir_reader_scenarios(), pe_scenarios)
 
1252
 
1278
1253
    # Set by load_tests
1279
1254
    _process_entry = None
1280
1255
 
1281
1256
    def setUp(self):
1282
1257
        super(TestProcessEntry, self).setUp()
1283
 
        orig = dirstate._process_entry
1284
 
        def cleanup():
1285
 
            dirstate._process_entry = orig
1286
 
        self.addCleanup(cleanup)
1287
 
        dirstate._process_entry = self._process_entry
 
1258
        self.overrideAttr(dirstate, '_process_entry', self._process_entry)
1288
1259
 
1289
1260
    def assertChangedFileIds(self, expected, tree):
1290
1261
        tree.lock_read()
1295
1266
            tree.unlock()
1296
1267
        self.assertEqual(sorted(expected), sorted(file_ids))
1297
1268
 
 
1269
    def test_exceptions_raised(self):
 
1270
        # This is a direct test of bug #495023, it relies on osutils.is_inside
 
1271
        # getting called in an inner function. Which makes it a bit brittle,
 
1272
        # but at least it does reproduce the bug.
 
1273
        tree = self.make_branch_and_tree('tree')
 
1274
        self.build_tree(['tree/file', 'tree/dir/', 'tree/dir/sub',
 
1275
                         'tree/dir2/', 'tree/dir2/sub2'])
 
1276
        tree.add(['file', 'dir', 'dir/sub', 'dir2', 'dir2/sub2'])
 
1277
        tree.commit('first commit')
 
1278
        tree.lock_read()
 
1279
        self.addCleanup(tree.unlock)
 
1280
        basis_tree = tree.basis_tree()
 
1281
        def is_inside_raises(*args, **kwargs):
 
1282
            raise RuntimeError('stop this')
 
1283
        self.overrideAttr(osutils, 'is_inside', is_inside_raises)
 
1284
        self.assertListRaises(RuntimeError, tree.iter_changes, basis_tree)
 
1285
 
1298
1286
    def test_simple_changes(self):
1299
1287
        tree = self.make_branch_and_tree('tree')
1300
1288
        self.build_tree(['tree/file'])