← 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: John Arbash Meinel
  • Date: 2009-06-16 13:57:14 UTC
  • mto: This revision was merged to the branch mainline in revision 4449.
  • Revision ID: john@arbash-meinel.com-20090616135714-8o7jdtqqsfuv914z
The new code removes a get_parent_map call.

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
32
32
    )
33
33
 
34
34
try:
35
 
    from bzrlib import _dirstate_helpers_pyx
36
 
    has_dirstate_helpers_pyx = True
 
35
    from bzrlib import _dirstate_helpers_c
 
36
    has_dirstate_helpers_c = True
37
37
except ImportError:
38
 
    has_dirstate_helpers_pyx = False
39
 
 
40
 
 
41
 
compiled_dirstate_helpers_feature = tests.ModuleAvailableFeature(
42
 
                                'bzrlib._dirstate_helpers_pyx')
 
38
    has_dirstate_helpers_c = False
 
39
 
 
40
 
 
41
class _CompiledDirstateHelpersFeature(tests.Feature):
 
42
    def _probe(self):
 
43
        return has_dirstate_helpers_c
 
44
 
 
45
    def feature_name(self):
 
46
        return 'bzrlib._dirstate_helpers_c'
 
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})
57
 
        ue_scenarios.append(pyrex_scenario)
 
59
    if has_dirstate_helpers_c:
 
60
        c_scenario = ('dirstate_C',
 
61
                     {'update_entry': _dirstate_helpers_c.update_entry})
 
62
        ue_scenarios.append(c_scenario)
58
63
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
59
64
        remaining_tests, tests.condition_isinstance(TestUpdateEntry))
60
65
    tests.multiply_tests(process_entry_tests,
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})
70
 
        pe_scenarios.append(pyrex_scenario)
 
72
    if has_dirstate_helpers_c:
 
73
        c_scenario = ('dirstate_C',
 
74
                     {'_process_entry': _dirstate_helpers_c.ProcessEntryC})
 
75
        pe_scenarios.append(c_scenario)
71
76
    process_entry_tests, remaining_tests = tests.split_suite_by_condition(
72
77
        remaining_tests, tests.condition_isinstance(TestProcessEntry))
73
78
    tests.multiply_tests(process_entry_tests,
240
245
 
241
246
 
242
247
class TestBisectPathLeft(tests.TestCase, TestBisectPathMixin):
243
 
    """Run all Bisect Path tests against _bisect_path_left."""
 
248
    """Run all Bisect Path tests against _bisect_path_left_py."""
244
249
 
245
250
    def get_bisect_path(self):
246
 
        from bzrlib._dirstate_helpers_py import _bisect_path_left
247
 
        return _bisect_path_left
 
251
        from bzrlib._dirstate_helpers_py import _bisect_path_left_py
 
252
        return _bisect_path_left_py
248
253
 
249
254
    def get_bisect(self):
250
255
        return bisect.bisect_left, 0
251
256
 
252
257
 
253
258
class TestCompiledBisectPathLeft(TestBisectPathLeft):
254
 
    """Run all Bisect Path tests against _bisect_path_lect"""
 
259
    """Run all Bisect Path tests against _bisect_path_right_c"""
255
260
 
256
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
261
    _test_needs_features = [CompiledDirstateHelpersFeature]
257
262
 
258
263
    def get_bisect_path(self):
259
 
        from bzrlib._dirstate_helpers_pyx import _bisect_path_left
260
 
        return _bisect_path_left
 
264
        from bzrlib._dirstate_helpers_c import _bisect_path_left_c
 
265
        return _bisect_path_left_c
261
266
 
262
267
 
263
268
class TestBisectPathRight(tests.TestCase, TestBisectPathMixin):
264
 
    """Run all Bisect Path tests against _bisect_path_right"""
 
269
    """Run all Bisect Path tests against _bisect_path_right_py"""
265
270
 
266
271
    def get_bisect_path(self):
267
 
        from bzrlib._dirstate_helpers_py import _bisect_path_right
268
 
        return _bisect_path_right
 
272
        from bzrlib._dirstate_helpers_py import _bisect_path_right_py
 
273
        return _bisect_path_right_py
269
274
 
270
275
    def get_bisect(self):
271
276
        return bisect.bisect_right, -1
272
277
 
273
278
 
274
279
class TestCompiledBisectPathRight(TestBisectPathRight):
275
 
    """Run all Bisect Path tests against _bisect_path_right"""
 
280
    """Run all Bisect Path tests against _bisect_path_right_c"""
276
281
 
277
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
282
    _test_needs_features = [CompiledDirstateHelpersFeature]
278
283
 
279
284
    def get_bisect_path(self):
280
 
        from bzrlib._dirstate_helpers_pyx import _bisect_path_right
281
 
        return _bisect_path_right
 
285
        from bzrlib._dirstate_helpers_c import _bisect_path_right_c
 
286
        return _bisect_path_right_c
282
287
 
283
288
 
284
289
class TestBisectDirblock(tests.TestCase):
295
300
 
296
301
    def get_bisect_dirblock(self):
297
302
        """Return an implementation of bisect_dirblock"""
298
 
        from bzrlib._dirstate_helpers_py import bisect_dirblock
299
 
        return bisect_dirblock
 
303
        from bzrlib._dirstate_helpers_py import bisect_dirblock_py
 
304
        return bisect_dirblock_py
300
305
 
301
306
    def assertBisect(self, dirblocks, split_dirblocks, path, *args, **kwargs):
302
307
        """Assert that bisect_split works like bisect_left on the split paths.
386
391
    compiled version.
387
392
    """
388
393
 
389
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
394
    _test_needs_features = [CompiledDirstateHelpersFeature]
390
395
 
391
396
    def get_bisect_dirblock(self):
392
 
        from bzrlib._dirstate_helpers_pyx import bisect_dirblock
393
 
        return bisect_dirblock
 
397
        from bzrlib._dirstate_helpers_c import bisect_dirblock_c
 
398
        return bisect_dirblock_c
394
399
 
395
400
 
396
401
class TestCmpByDirs(tests.TestCase):
405
410
 
406
411
    def get_cmp_by_dirs(self):
407
412
        """Get a specific implementation of cmp_by_dirs."""
408
 
        from bzrlib._dirstate_helpers_py import cmp_by_dirs
409
 
        return cmp_by_dirs
 
413
        from bzrlib._dirstate_helpers_py import cmp_by_dirs_py
 
414
        return cmp_by_dirs_py
410
415
 
411
416
    def assertCmpByDirs(self, expected, str1, str2):
412
417
        """Compare the two strings, in both directions.
508
513
class TestCompiledCmpByDirs(TestCmpByDirs):
509
514
    """Test the pyrex implementation of cmp_by_dirs"""
510
515
 
511
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
516
    _test_needs_features = [CompiledDirstateHelpersFeature]
512
517
 
513
518
    def get_cmp_by_dirs(self):
514
 
        from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
515
 
        return cmp_by_dirs
 
519
        from bzrlib._dirstate_helpers_c import cmp_by_dirs_c
 
520
        return cmp_by_dirs_c
516
521
 
517
522
 
518
523
class TestCmpPathByDirblock(tests.TestCase):
527
532
 
528
533
    def get_cmp_path_by_dirblock(self):
529
534
        """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
 
535
        from bzrlib._dirstate_helpers_py import _cmp_path_by_dirblock_py
 
536
        return _cmp_path_by_dirblock_py
532
537
 
533
538
    def assertCmpPathByDirblock(self, paths):
534
539
        """Compare all paths and make sure they evaluate to the correct order.
659
664
class TestCompiledCmpPathByDirblock(TestCmpPathByDirblock):
660
665
    """Test the pyrex implementation of _cmp_path_by_dirblock"""
661
666
 
662
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
667
    _test_needs_features = [CompiledDirstateHelpersFeature]
663
668
 
664
669
    def get_cmp_by_dirs(self):
665
 
        from bzrlib._dirstate_helpers_pyx import _cmp_path_by_dirblock
666
 
        return _cmp_path_by_dirblock
 
670
        from bzrlib._dirstate_helpers_c import _cmp_path_by_dirblock_c
 
671
        return _cmp_path_by_dirblock_c
667
672
 
668
673
 
669
674
class TestMemRChr(tests.TestCase):
670
675
    """Test memrchr functionality"""
671
676
 
672
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
677
    _test_needs_features = [CompiledDirstateHelpersFeature]
673
678
 
674
679
    def assertMemRChr(self, expected, s, c):
675
 
        from bzrlib._dirstate_helpers_pyx import _py_memrchr
 
680
        from bzrlib._dirstate_helpers_c import _py_memrchr
676
681
        self.assertEqual(expected, _py_memrchr(s, c))
677
682
 
678
683
    def test_missing(self):
720
725
    """
721
726
 
722
727
    def get_read_dirblocks(self):
723
 
        from bzrlib._dirstate_helpers_py import _read_dirblocks
724
 
        return _read_dirblocks
 
728
        from bzrlib._dirstate_helpers_py import _read_dirblocks_py
 
729
        return _read_dirblocks_py
725
730
 
726
731
    def test_smoketest(self):
727
732
        """Make sure that we can create and read back a simple file."""
737
742
 
738
743
    def test_trailing_garbage(self):
739
744
        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()
 
745
        # We can modify the file as long as it hasn't been read yet.
744
746
        f = open('dirstate', 'ab')
745
747
        try:
746
748
            # Add bogus trailing garbage
747
749
            f.write('bogus\n')
748
750
        finally:
749
751
            f.close()
750
 
            state.lock_read()
751
752
        e = self.assertRaises(errors.DirstateCorrupt,
752
753
                              state._read_dirblocks_if_needed)
753
754
        # Make sure we mention the bogus characters in the error
757
758
class TestCompiledReadDirblocks(TestReadDirblocks):
758
759
    """Test the pyrex implementation of _read_dirblocks"""
759
760
 
760
 
    _test_needs_features = [compiled_dirstate_helpers_feature]
 
761
    _test_needs_features = [CompiledDirstateHelpersFeature]
761
762
 
762
763
    def get_read_dirblocks(self):
763
 
        from bzrlib._dirstate_helpers_pyx import _read_dirblocks
764
 
        return _read_dirblocks
 
764
        from bzrlib._dirstate_helpers_c import _read_dirblocks_c
 
765
        return _read_dirblocks_c
765
766
 
766
767
 
767
768
class TestUsingCompiledIfAvailable(tests.TestCase):
768
769
    """Check that any compiled functions that are available are the default.
769
770
 
770
771
    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
 
772
    _dirstate_helpers_c is actually available, but the compiled functions are
772
773
    not being used.
773
774
    """
774
775
 
775
776
    def test_bisect_dirblock(self):
776
 
        if compiled_dirstate_helpers_feature.available():
777
 
            from bzrlib._dirstate_helpers_pyx import bisect_dirblock
 
777
        if CompiledDirstateHelpersFeature.available():
 
778
            from bzrlib._dirstate_helpers_c import bisect_dirblock_c
 
779
            self.assertIs(bisect_dirblock_c, dirstate.bisect_dirblock)
778
780
        else:
779
 
            from bzrlib._dirstate_helpers_py import bisect_dirblock
780
 
        self.assertIs(bisect_dirblock, dirstate.bisect_dirblock)
 
781
            from bzrlib._dirstate_helpers_py import bisect_dirblock_py
 
782
            self.assertIs(bisect_dirblock_py, dirstate.bisect_dirblock)
781
783
 
782
784
    def test__bisect_path_left(self):
783
 
        if compiled_dirstate_helpers_feature.available():
784
 
            from bzrlib._dirstate_helpers_pyx import _bisect_path_left
 
785
        if CompiledDirstateHelpersFeature.available():
 
786
            from bzrlib._dirstate_helpers_c import _bisect_path_left_c
 
787
            self.assertIs(_bisect_path_left_c, dirstate._bisect_path_left)
785
788
        else:
786
 
            from bzrlib._dirstate_helpers_py import _bisect_path_left
787
 
        self.assertIs(_bisect_path_left, dirstate._bisect_path_left)
 
789
            from bzrlib._dirstate_helpers_py import _bisect_path_left_py
 
790
            self.assertIs(_bisect_path_left_py, dirstate._bisect_path_left)
788
791
 
789
792
    def test__bisect_path_right(self):
790
 
        if compiled_dirstate_helpers_feature.available():
791
 
            from bzrlib._dirstate_helpers_pyx import _bisect_path_right
 
793
        if CompiledDirstateHelpersFeature.available():
 
794
            from bzrlib._dirstate_helpers_c import _bisect_path_right_c
 
795
            self.assertIs(_bisect_path_right_c, dirstate._bisect_path_right)
792
796
        else:
793
 
            from bzrlib._dirstate_helpers_py import _bisect_path_right
794
 
        self.assertIs(_bisect_path_right, dirstate._bisect_path_right)
 
797
            from bzrlib._dirstate_helpers_py import _bisect_path_right_py
 
798
            self.assertIs(_bisect_path_right_py, dirstate._bisect_path_right)
795
799
 
796
800
    def test_cmp_by_dirs(self):
797
 
        if compiled_dirstate_helpers_feature.available():
798
 
            from bzrlib._dirstate_helpers_pyx import cmp_by_dirs
 
801
        if CompiledDirstateHelpersFeature.available():
 
802
            from bzrlib._dirstate_helpers_c import cmp_by_dirs_c
 
803
            self.assertIs(cmp_by_dirs_c, dirstate.cmp_by_dirs)
799
804
        else:
800
 
            from bzrlib._dirstate_helpers_py import cmp_by_dirs
801
 
        self.assertIs(cmp_by_dirs, dirstate.cmp_by_dirs)
 
805
            from bzrlib._dirstate_helpers_py import cmp_by_dirs_py
 
806
            self.assertIs(cmp_by_dirs_py, dirstate.cmp_by_dirs)
802
807
 
803
808
    def test__read_dirblocks(self):
804
 
        if compiled_dirstate_helpers_feature.available():
805
 
            from bzrlib._dirstate_helpers_pyx import _read_dirblocks
 
809
        if CompiledDirstateHelpersFeature.available():
 
810
            from bzrlib._dirstate_helpers_c import _read_dirblocks_c
 
811
            self.assertIs(_read_dirblocks_c, dirstate._read_dirblocks)
806
812
        else:
807
 
            from bzrlib._dirstate_helpers_py import _read_dirblocks
808
 
        self.assertIs(_read_dirblocks, dirstate._read_dirblocks)
 
813
            from bzrlib._dirstate_helpers_py import _read_dirblocks_py
 
814
            self.assertIs(_read_dirblocks_py, dirstate._read_dirblocks)
809
815
 
810
816
    def test_update_entry(self):
811
 
        if compiled_dirstate_helpers_feature.available():
812
 
            from bzrlib._dirstate_helpers_pyx import update_entry
 
817
        if CompiledDirstateHelpersFeature.available():
 
818
            from bzrlib._dirstate_helpers_c import update_entry
 
819
            self.assertIs(update_entry, dirstate.update_entry)
813
820
        else:
814
 
            from bzrlib.dirstate import update_entry
815
 
        self.assertIs(update_entry, dirstate.update_entry)
 
821
            from bzrlib.dirstate import py_update_entry
 
822
            self.assertIs(py_update_entry, dirstate.py_update_entry)
816
823
 
817
824
    def test_process_entry(self):
818
 
        if compiled_dirstate_helpers_feature.available():
819
 
            from bzrlib._dirstate_helpers_pyx import ProcessEntryC
 
825
        if CompiledDirstateHelpersFeature.available():
 
826
            from bzrlib._dirstate_helpers_c import ProcessEntryC
820
827
            self.assertIs(ProcessEntryC, dirstate._process_entry)
821
828
        else:
822
829
            from bzrlib.dirstate import ProcessEntryPython
831
838
 
832
839
    def setUp(self):
833
840
        super(TestUpdateEntry, self).setUp()
834
 
        self.overrideAttr(dirstate, 'update_entry', self.update_entry)
 
841
        orig = dirstate.update_entry
 
842
        def cleanup():
 
843
            dirstate.update_entry = orig
 
844
        self.addCleanup(cleanup)
 
845
        dirstate.update_entry = self.update_entry
835
846
 
836
847
    def get_state_with_a(self):
837
848
        """Create a DirState tracking a single object named 'a'"""
1274
1285
 
1275
1286
    def setUp(self):
1276
1287
        super(TestProcessEntry, self).setUp()
1277
 
        self.overrideAttr(dirstate, '_process_entry', self._process_entry)
 
1288
        orig = dirstate._process_entry
 
1289
        def cleanup():
 
1290
            dirstate._process_entry = orig
 
1291
        self.addCleanup(cleanup)
 
1292
        dirstate._process_entry = self._process_entry
1278
1293
 
1279
1294
    def assertChangedFileIds(self, expected, tree):
1280
1295
        tree.lock_read()
1285
1300
            tree.unlock()
1286
1301
        self.assertEqual(sorted(expected), sorted(file_ids))
1287
1302
 
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
1303
    def test_simple_changes(self):
1306
1304
        tree = self.make_branch_and_tree('tree')
1307
1305
        self.build_tree(['tree/file'])