← 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: Brian de Alwis
  • Date: 2009-09-24 19:51:37 UTC
  • mto: (4715.4.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4727.
  • Revision ID: bsd@acm.org-20090924195137-wubyeqv515mkigi8
Introduce new mailer to support MacOS X's Mail.app

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
38
38
    has_dirstate_helpers_pyx = False
39
39
 
40
40
 
41
 
compiled_dirstate_helpers_feature = tests.ModuleAvailableFeature(
42
 
                                'bzrlib._dirstate_helpers_pyx')
 
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()
43
48
 
44
49
 
45
50
def load_tests(basic_tests, module, loader):
51
56
 
52
57
    ue_scenarios = [('dirstate_Python',
53
58
                     {'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})
 
59
    if has_dirstate_helpers_pyx:
 
60
        pyrex_scenario = ('dirstate_Pyrex',
 
61
                          {'update_entry': _dirstate_helpers_pyx.update_entry})
57
62
        ue_scenarios.append(pyrex_scenario)
58
63
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
59
64
        remaining_tests, tests.condition_isinstance(TestUpdateEntry))
64
69
 
65
70
    pe_scenarios = [('dirstate_Python',
66
71
                     {'_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})
 
72
    if has_dirstate_helpers_pyx:
 
73
        pyrex_scenario = (
 
74
            'dirstate_Pyrex',
 
75
            {'_process_entry': _dirstate_helpers_pyx.ProcessEntryC})
70
76
        pe_scenarios.append(pyrex_scenario)
71
77
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
72
78
        remaining_tests, tests.condition_isinstance(TestProcessEntry))
253
259
class TestCompiledBisectPathLeft(TestBisectPathLeft):
254
260
    """Run all Bisect Path tests against _bisect_path_lect"""
255
261
 
256
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
262
    _test_needs_features = [CompiledDirstateHelpersFeature]
257
263
 
258
264
    def get_bisect_path(self):
259
265
        from bzrlib._dirstate_helpers_pyx import _bisect_path_left
274
280
class TestCompiledBisectPathRight(TestBisectPathRight):
275
281
    """Run all Bisect Path tests against _bisect_path_right"""
276
282
 
277
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
283
    _test_needs_features = [CompiledDirstateHelpersFeature]
278
284
 
279
285
    def get_bisect_path(self):
280
286
        from bzrlib._dirstate_helpers_pyx import _bisect_path_right
386
392
    compiled version.
387
393
    """
388
394
 
389
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
395
    _test_needs_features = [CompiledDirstateHelpersFeature]
390
396
 
391
397
    def get_bisect_dirblock(self):
392
398
        from bzrlib._dirstate_helpers_pyx import bisect_dirblock
508
514
class TestCompiledCmpByDirs(TestCmpByDirs):
509
515
    """Test the pyrex implementation of cmp_by_dirs"""
510
516
 
511
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
517
    _test_needs_features = [CompiledDirstateHelpersFeature]
512
518
 
513
519
    def get_cmp_by_dirs(self):
514
520
        from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
659
665
class TestCompiledCmpPathByDirblock(TestCmpPathByDirblock):
660
666
    """Test the pyrex implementation of _cmp_path_by_dirblock"""
661
667
 
662
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
668
    _test_needs_features = [CompiledDirstateHelpersFeature]
663
669
 
664
670
    def get_cmp_by_dirs(self):
665
671
        from bzrlib._dirstate_helpers_pyx import _cmp_path_by_dirblock
669
675
class TestMemRChr(tests.TestCase):
670
676
    """Test memrchr functionality"""
671
677
 
672
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
678
    _test_needs_features = [CompiledDirstateHelpersFeature]
673
679
 
674
680
    def assertMemRChr(self, expected, s, c):
675
681
        from bzrlib._dirstate_helpers_pyx import _py_memrchr
737
743
 
738
744
    def test_trailing_garbage(self):
739
745
        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()
 
746
        # We can modify the file as long as it hasn't been read yet.
744
747
        f = open('dirstate', 'ab')
745
748
        try:
746
749
            # Add bogus trailing garbage
747
750
            f.write('bogus\n')
748
751
        finally:
749
752
            f.close()
750
 
            state.lock_read()
751
753
        e = self.assertRaises(errors.DirstateCorrupt,
752
754
                              state._read_dirblocks_if_needed)
753
755
        # Make sure we mention the bogus characters in the error
757
759
class TestCompiledReadDirblocks(TestReadDirblocks):
758
760
    """Test the pyrex implementation of _read_dirblocks"""
759
761
 
760
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
762
    _test_needs_features = [CompiledDirstateHelpersFeature]
761
763
 
762
764
    def get_read_dirblocks(self):
763
765
        from bzrlib._dirstate_helpers_pyx import _read_dirblocks
773
775
    """
774
776
 
775
777
    def test_bisect_dirblock(self):
776
 
        if compiled_dirstate_helpers_feature.available():
 
778
        if CompiledDirstateHelpersFeature.available():
777
779
            from bzrlib._dirstate_helpers_pyx import bisect_dirblock
778
780
        else:
779
781
            from bzrlib._dirstate_helpers_py import bisect_dirblock
780
782
        self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
781
783
 
782
784
    def test__bisect_path_left(self):
783
 
        if compiled_dirstate_helpers_feature.available():
 
785
        if CompiledDirstateHelpersFeature.available():
784
786
            from bzrlib._dirstate_helpers_pyx import _bisect_path_left
785
787
        else:
786
788
            from bzrlib._dirstate_helpers_py import _bisect_path_left
787
789
        self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
788
790
 
789
791
    def test__bisect_path_right(self):
790
 
        if compiled_dirstate_helpers_feature.available():
 
792
        if CompiledDirstateHelpersFeature.available():
791
793
            from bzrlib._dirstate_helpers_pyx import _bisect_path_right
792
794
        else:
793
795
            from bzrlib._dirstate_helpers_py import _bisect_path_right
794
796
        self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
795
797
 
796
798
    def test_cmp_by_dirs(self):
797
 
        if compiled_dirstate_helpers_feature.available():
 
799
        if CompiledDirstateHelpersFeature.available():
798
800
            from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
799
801
        else:
800
802
            from bzrlib._dirstate_helpers_py import cmp_by_dirs
801
803
        self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
802
804
 
803
805
    def test__read_dirblocks(self):
804
 
        if compiled_dirstate_helpers_feature.available():
 
806
        if CompiledDirstateHelpersFeature.available():
805
807
            from bzrlib._dirstate_helpers_pyx import _read_dirblocks
806
808
        else:
807
809
            from bzrlib._dirstate_helpers_py import _read_dirblocks
808
810
        self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
809
811
 
810
812
    def test_update_entry(self):
811
 
        if compiled_dirstate_helpers_feature.available():
 
813
        if CompiledDirstateHelpersFeature.available():
812
814
            from bzrlib._dirstate_helpers_pyx import update_entry
813
815
        else:
814
816
            from bzrlib.dirstate import update_entry
815
817
        self.assertIs(update_entry, dirstate.update_entry)
816
818
 
817
819
    def test_process_entry(self):
818
 
        if compiled_dirstate_helpers_feature.available():
 
820
        if CompiledDirstateHelpersFeature.available():
819
821
            from bzrlib._dirstate_helpers_pyx import ProcessEntryC
820
822
            self.assertIs(ProcessEntryC, dirstate._process_entry)
821
823
        else:
831
833
 
832
834
    def setUp(self):
833
835
        super(TestUpdateEntry, self).setUp()
834
 
        self.overrideAttr(dirstate, 'update_entry', self.update_entry)
 
836
        orig = dirstate.update_entry
 
837
        def cleanup():
 
838
            dirstate.update_entry = orig
 
839
        self.addCleanup(cleanup)
 
840
        dirstate.update_entry = self.update_entry
835
841
 
836
842
    def get_state_with_a(self):
837
843
        """Create a DirState tracking a single object named 'a'"""
1274
1280
 
1275
1281
    def setUp(self):
1276
1282
        super(TestProcessEntry, self).setUp()
1277
 
        self.overrideAttr(dirstate, '_process_entry', self._process_entry)
 
1283
        orig = dirstate._process_entry
 
1284
        def cleanup():
 
1285
            dirstate._process_entry = orig
 
1286
        self.addCleanup(cleanup)
 
1287
        dirstate._process_entry = self._process_entry
1278
1288
 
1279
1289
    def assertChangedFileIds(self, expected, tree):
1280
1290
        tree.lock_read()
1285
1295
            tree.unlock()
1286
1296
        self.assertEqual(sorted(expected), sorted(file_ids))
1287
1297
 
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
1298
    def test_simple_changes(self):
1306
1299
        tree = self.make_branch_and_tree('tree')
1307
1300
        self.build_tree(['tree/file'])