← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_branch.py

Put in place a structure for the admin-guide

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_branch.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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
22
22
also see this file.
23
23
"""
24
24
 
25
 
from cStringIO import StringIO
 
25
from StringIO import StringIO
26
26
 
27
27
from bzrlib import (
28
28
    branch as _mod_branch,
29
29
    bzrdir,
30
30
    config,
31
31
    errors,
32
 
    tests,
33
32
    trace,
34
 
    transport,
35
33
    urlutils,
36
34
    )
37
 
 
38
 
 
39
 
class TestDefaultFormat(tests.TestCase):
 
35
from bzrlib.branch import (
 
36
    Branch,
 
37
    BranchHooks,
 
38
    BranchFormat,
 
39
    BranchReferenceFormat,
 
40
    BzrBranch5,
 
41
    BzrBranchFormat5,
 
42
    BzrBranchFormat6,
 
43
    BzrBranchFormat7,
 
44
    PullResult,
 
45
    _run_with_write_locked_target,
 
46
    )
 
47
from bzrlib.bzrdir import (BzrDirMetaFormat1, BzrDirMeta1,
 
48
                           BzrDir, BzrDirFormat)
 
49
from bzrlib.errors import (NotBranchError,
 
50
                           UnknownFormatError,
 
51
                           UnknownHook,
 
52
                           UnsupportedFormatError,
 
53
                           )
 
54
 
 
55
from bzrlib.tests import TestCase, TestCaseWithTransport
 
56
from bzrlib.transport import get_transport
 
57
 
 
58
 
 
59
class TestDefaultFormat(TestCase):
40
60
 
41
61
    def test_default_format(self):
42
62
        # update this if you change the default branch format
43
 
        self.assertIsInstance(_mod_branch.BranchFormat.get_default_format(),
44
 
                _mod_branch.BzrBranchFormat7)
 
63
        self.assertIsInstance(BranchFormat.get_default_format(),
 
64
                BzrBranchFormat7)
45
65
 
46
66
    def test_default_format_is_same_as_bzrdir_default(self):
47
67
        # XXX: it might be nice if there was only one place the default was
48
68
        # set, but at the moment that's not true -- mbp 20070814 --
49
69
        # https://bugs.launchpad.net/bzr/+bug/132376
50
 
        self.assertEqual(
51
 
            _mod_branch.BranchFormat.get_default_format(),
52
 
            bzrdir.BzrDirFormat.get_default_format().get_branch_format())
 
70
        self.assertEqual(BranchFormat.get_default_format(),
 
71
                BzrDirFormat.get_default_format().get_branch_format())
53
72
 
54
73
    def test_get_set_default_format(self):
55
74
        # set the format and then set it back again
56
 
        old_format = _mod_branch.BranchFormat.get_default_format()
57
 
        _mod_branch.BranchFormat.set_default_format(SampleBranchFormat())
 
75
        old_format = BranchFormat.get_default_format()
 
76
        BranchFormat.set_default_format(SampleBranchFormat())
58
77
        try:
59
78
            # the default branch format is used by the meta dir format
60
79
            # which is not the default bzrdir format at this point
61
 
            dir = bzrdir.BzrDirMetaFormat1().initialize('memory:///')
 
80
            dir = BzrDirMetaFormat1().initialize('memory:///')
62
81
            result = dir.create_branch()
63
82
            self.assertEqual(result, 'A branch')
64
83
        finally:
65
 
            _mod_branch.BranchFormat.set_default_format(old_format)
66
 
        self.assertEqual(old_format,
67
 
                         _mod_branch.BranchFormat.get_default_format())
68
 
 
69
 
 
70
 
class TestBranchFormat5(tests.TestCaseWithTransport):
 
84
            BranchFormat.set_default_format(old_format)
 
85
        self.assertEqual(old_format, BranchFormat.get_default_format())
 
86
 
 
87
 
 
88
class TestBranchFormat5(TestCaseWithTransport):
71
89
    """Tests specific to branch format 5"""
72
90
 
73
91
    def test_branch_format_5_uses_lockdir(self):
74
92
        url = self.get_url()
75
 
        bdir = bzrdir.BzrDirMetaFormat1().initialize(url)
76
 
        bdir.create_repository()
77
 
        branch = bdir.create_branch()
 
93
        bzrdir = BzrDirMetaFormat1().initialize(url)
 
94
        bzrdir.create_repository()
 
95
        branch = bzrdir.create_branch()
78
96
        t = self.get_transport()
79
97
        self.log("branch instance is %r" % branch)
80
 
        self.assert_(isinstance(branch, _mod_branch.BzrBranch5))
 
98
        self.assert_(isinstance(branch, BzrBranch5))
81
99
        self.assertIsDirectory('.', t)
82
100
        self.assertIsDirectory('.bzr/branch', t)
83
101
        self.assertIsDirectory('.bzr/branch/lock', t)
84
102
        branch.lock_write()
85
 
        self.addCleanup(branch.unlock)
86
 
        self.assertIsDirectory('.bzr/branch/lock/held', t)
 
103
        try:
 
104
            self.assertIsDirectory('.bzr/branch/lock/held', t)
 
105
        finally:
 
106
            branch.unlock()
87
107
 
88
108
    def test_set_push_location(self):
89
109
        from bzrlib.config import (locations_config_filename,
112
132
    # recursive section - that is, it appends the branch name.
113
133
 
114
134
 
115
 
class SampleBranchFormat(_mod_branch.BranchFormat):
 
135
class SampleBranchFormat(BranchFormat):
116
136
    """A sample format
117
137
 
118
138
    this format is initializable, unsupported to aid in testing the
123
143
        """See BzrBranchFormat.get_format_string()."""
124
144
        return "Sample branch format."
125
145
 
126
 
    def initialize(self, a_bzrdir, name=None):
 
146
    def initialize(self, a_bzrdir):
127
147
        """Format 4 branches cannot be created."""
128
 
        t = a_bzrdir.get_branch_transport(self, name=name)
 
148
        t = a_bzrdir.get_branch_transport(self)
129
149
        t.put_bytes('format', self.get_format_string())
130
150
        return 'A branch'
131
151
 
132
152
    def is_supported(self):
133
153
        return False
134
154
 
135
 
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
 
155
    def open(self, transport, _found=False, ignore_fallbacks=False):
136
156
        return "opened branch."
137
157
 
138
158
 
139
 
# Demonstrating how lazy loading is often implemented:
140
 
# A constant string is created.
141
 
SampleSupportedBranchFormatString = "Sample supported branch format."
142
 
 
143
 
# And the format class can then reference the constant to avoid skew.
144
 
class SampleSupportedBranchFormat(_mod_branch.BranchFormat):
145
 
    """A sample supported format."""
146
 
 
147
 
    def get_format_string(self):
148
 
        """See BzrBranchFormat.get_format_string()."""
149
 
        return SampleSupportedBranchFormatString
150
 
 
151
 
    def initialize(self, a_bzrdir, name=None):
152
 
        t = a_bzrdir.get_branch_transport(self, name=name)
153
 
        t.put_bytes('format', self.get_format_string())
154
 
        return 'A branch'
155
 
 
156
 
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
157
 
        return "opened supported branch."
158
 
 
159
 
 
160
 
class TestBzrBranchFormat(tests.TestCaseWithTransport):
 
159
class TestBzrBranchFormat(TestCaseWithTransport):
161
160
    """Tests for the BzrBranchFormat facility."""
162
161
 
163
162
    def test_find_format(self):
169
168
            dir = format._matchingbzrdir.initialize(url)
170
169
            dir.create_repository()
171
170
            format.initialize(dir)
172
 
            found_format = _mod_branch.BranchFormat.find_format(dir)
 
171
            found_format = BranchFormat.find_format(dir)
173
172
            self.failUnless(isinstance(found_format, format.__class__))
174
 
        check_format(_mod_branch.BzrBranchFormat5(), "bar")
175
 
 
176
 
    def test_find_format_factory(self):
177
 
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
178
 
        SampleSupportedBranchFormat().initialize(dir)
179
 
        factory = _mod_branch.MetaDirBranchFormatFactory(
180
 
            SampleSupportedBranchFormatString,
181
 
            "bzrlib.tests.test_branch", "SampleSupportedBranchFormat")
182
 
        _mod_branch.BranchFormat.register_format(factory)
183
 
        self.addCleanup(_mod_branch.BranchFormat.unregister_format, factory)
184
 
        b = _mod_branch.Branch.open(self.get_url())
185
 
        self.assertEqual(b, "opened supported branch.")
 
173
        check_format(BzrBranchFormat5(), "bar")
186
174
 
187
175
    def test_find_format_not_branch(self):
188
176
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
189
 
        self.assertRaises(errors.NotBranchError,
190
 
                          _mod_branch.BranchFormat.find_format,
 
177
        self.assertRaises(NotBranchError,
 
178
                          BranchFormat.find_format,
191
179
                          dir)
192
180
 
193
181
    def test_find_format_unknown_format(self):
194
182
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
195
183
        SampleBranchFormat().initialize(dir)
196
 
        self.assertRaises(errors.UnknownFormatError,
197
 
                          _mod_branch.BranchFormat.find_format,
 
184
        self.assertRaises(UnknownFormatError,
 
185
                          BranchFormat.find_format,
198
186
                          dir)
199
187
 
200
188
    def test_register_unregister_format(self):
204
192
        # make a branch
205
193
        format.initialize(dir)
206
194
        # register a format for it.
207
 
        _mod_branch.BranchFormat.register_format(format)
 
195
        BranchFormat.register_format(format)
208
196
        # which branch.Open will refuse (not supported)
209
 
        self.assertRaises(errors.UnsupportedFormatError,
210
 
                          _mod_branch.Branch.open, self.get_url())
 
197
        self.assertRaises(UnsupportedFormatError, Branch.open, self.get_url())
211
198
        self.make_branch_and_tree('foo')
212
199
        # but open_downlevel will work
213
 
        self.assertEqual(
214
 
            format.open(dir),
215
 
            bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
 
200
        self.assertEqual(format.open(dir), bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
216
201
        # unregister the format
217
 
        _mod_branch.BranchFormat.unregister_format(format)
 
202
        BranchFormat.unregister_format(format)
218
203
        self.make_branch_and_tree('bar')
219
204
 
220
205
 
221
 
#Used by TestMetaDirBranchFormatFactory 
222
 
FakeLazyFormat = None
223
 
 
224
 
 
225
 
class TestMetaDirBranchFormatFactory(tests.TestCase):
226
 
 
227
 
    def test_get_format_string_does_not_load(self):
228
 
        """Formats have a static format string."""
229
 
        factory = _mod_branch.MetaDirBranchFormatFactory("yo", None, None)
230
 
        self.assertEqual("yo", factory.get_format_string())
231
 
 
232
 
    def test_call_loads(self):
233
 
        # __call__ is used by the network_format_registry interface to get a
234
 
        # Format.
235
 
        global FakeLazyFormat
236
 
        del FakeLazyFormat
237
 
        factory = _mod_branch.MetaDirBranchFormatFactory(None,
238
 
            "bzrlib.tests.test_branch", "FakeLazyFormat")
239
 
        self.assertRaises(AttributeError, factory)
240
 
 
241
 
    def test_call_returns_call_of_referenced_object(self):
242
 
        global FakeLazyFormat
243
 
        FakeLazyFormat = lambda:'called'
244
 
        factory = _mod_branch.MetaDirBranchFormatFactory(None,
245
 
            "bzrlib.tests.test_branch", "FakeLazyFormat")
246
 
        self.assertEqual('called', factory())
247
 
 
248
 
 
249
206
class TestBranch67(object):
250
207
    """Common tests for both branch 6 and 7 which are mostly the same."""
251
208
 
259
216
        raise NotImplementedError(self.get_class)
260
217
 
261
218
    def test_creation(self):
262
 
        format = bzrdir.BzrDirMetaFormat1()
 
219
        format = BzrDirMetaFormat1()
263
220
        format.set_branch_format(_mod_branch.BzrBranchFormat6())
264
221
        branch = self.make_branch('a', format=format)
265
222
        self.assertIsInstance(branch, self.get_class())
352
309
                         'locations.conf')
353
310
 
354
311
 
355
 
class TestBranch6(TestBranch67, tests.TestCaseWithTransport):
 
312
class TestBranch6(TestBranch67, TestCaseWithTransport):
356
313
 
357
314
    def get_class(self):
358
315
        return _mod_branch.BzrBranch6
373
330
        self.assertRaises(errors.UnstackableBranchFormat, branch.get_stacked_on_url)
374
331
 
375
332
 
376
 
class TestBranch7(TestBranch67, tests.TestCaseWithTransport):
 
333
class TestBranch7(TestBranch67, TestCaseWithTransport):
377
334
 
378
335
    def get_class(self):
379
336
        return _mod_branch.BzrBranch7
423
380
        self.assertTrue(branch.repository.has_revision(revid))
424
381
 
425
382
 
426
 
class BzrBranch8(tests.TestCaseWithTransport):
 
383
class BzrBranch8(TestCaseWithTransport):
427
384
 
428
385
    def make_branch(self, location, format=None):
429
386
        if format is None:
430
387
            format = bzrdir.format_registry.make_bzrdir('1.9')
431
388
            format.set_branch_format(_mod_branch.BzrBranchFormat8())
432
 
        return tests.TestCaseWithTransport.make_branch(
433
 
            self, location, format=format)
 
389
        return TestCaseWithTransport.make_branch(self, location, format=format)
434
390
 
435
391
    def create_branch_with_reference(self):
436
392
        branch = self.make_branch('branch')
480
436
        branch.lock_write()
481
437
        branch.set_reference_info('file-id', 'path2', 'location2')
482
438
        branch.unlock()
483
 
        doppelganger = _mod_branch.Branch.open('branch')
 
439
        doppelganger = Branch.open('branch')
484
440
        doppelganger.set_reference_info('file-id', 'path3', 'location3')
485
441
        self.assertEqual(('path3', 'location3'),
486
442
                         branch.get_reference_info('file-id'))
487
443
 
488
 
class TestBranchReference(tests.TestCaseWithTransport):
 
444
class TestBranchReference(TestCaseWithTransport):
489
445
    """Tests for the branch reference facility."""
490
446
 
491
447
    def test_create_open_reference(self):
492
448
        bzrdirformat = bzrdir.BzrDirMetaFormat1()
493
 
        t = transport.get_transport(self.get_url('.'))
 
449
        t = get_transport(self.get_url('.'))
494
450
        t.mkdir('repo')
495
451
        dir = bzrdirformat.initialize(self.get_url('repo'))
496
452
        dir.create_repository()
497
453
        target_branch = dir.create_branch()
498
454
        t.mkdir('branch')
499
455
        branch_dir = bzrdirformat.initialize(self.get_url('branch'))
500
 
        made_branch = _mod_branch.BranchReferenceFormat().initialize(
501
 
            branch_dir, target_branch=target_branch)
 
456
        made_branch = BranchReferenceFormat().initialize(branch_dir, target_branch)
502
457
        self.assertEqual(made_branch.base, target_branch.base)
503
458
        opened_branch = branch_dir.open_branch()
504
459
        self.assertEqual(opened_branch.base, target_branch.base)
515
470
            _mod_branch.BranchReferenceFormat().get_reference(checkout.bzrdir))
516
471
 
517
472
 
518
 
class TestHooks(tests.TestCaseWithTransport):
 
473
class TestHooks(TestCase):
519
474
 
520
475
    def test_constructor(self):
521
476
        """Check that creating a BranchHooks instance has the right defaults."""
522
 
        hooks = _mod_branch.BranchHooks()
 
477
        hooks = BranchHooks()
523
478
        self.assertTrue("set_rh" in hooks, "set_rh not in %s" % hooks)
524
479
        self.assertTrue("post_push" in hooks, "post_push not in %s" % hooks)
525
480
        self.assertTrue("post_commit" in hooks, "post_commit not in %s" % hooks)
526
481
        self.assertTrue("pre_commit" in hooks, "pre_commit not in %s" % hooks)
527
482
        self.assertTrue("post_pull" in hooks, "post_pull not in %s" % hooks)
528
 
        self.assertTrue("post_uncommit" in hooks,
529
 
                        "post_uncommit not in %s" % hooks)
 
483
        self.assertTrue("post_uncommit" in hooks, "post_uncommit not in %s" % hooks)
530
484
        self.assertTrue("post_change_branch_tip" in hooks,
531
485
                        "post_change_branch_tip not in %s" % hooks)
532
 
        self.assertTrue("post_branch_init" in hooks,
533
 
                        "post_branch_init not in %s" % hooks)
534
 
        self.assertTrue("post_switch" in hooks,
535
 
                        "post_switch not in %s" % hooks)
536
486
 
537
487
    def test_installed_hooks_are_BranchHooks(self):
538
488
        """The installed hooks object should be a BranchHooks."""
539
489
        # the installed hooks are saved in self._preserved_hooks.
540
490
        self.assertIsInstance(self._preserved_hooks[_mod_branch.Branch][1],
541
 
                              _mod_branch.BranchHooks)
542
 
 
543
 
    def test_post_branch_init_hook(self):
544
 
        calls = []
545
 
        _mod_branch.Branch.hooks.install_named_hook('post_branch_init',
546
 
            calls.append, None)
547
 
        self.assertLength(0, calls)
548
 
        branch = self.make_branch('a')
549
 
        self.assertLength(1, calls)
550
 
        params = calls[0]
551
 
        self.assertIsInstance(params, _mod_branch.BranchInitHookParams)
552
 
        self.assertTrue(hasattr(params, 'bzrdir'))
553
 
        self.assertTrue(hasattr(params, 'branch'))
554
 
 
555
 
    def test_post_switch_hook(self):
556
 
        from bzrlib import switch
557
 
        calls = []
558
 
        _mod_branch.Branch.hooks.install_named_hook('post_switch',
559
 
            calls.append, None)
560
 
        tree = self.make_branch_and_tree('branch-1')
561
 
        self.build_tree(['branch-1/file-1'])
562
 
        tree.add('file-1')
563
 
        tree.commit('rev1')
564
 
        to_branch = tree.bzrdir.sprout('branch-2').open_branch()
565
 
        self.build_tree(['branch-1/file-2'])
566
 
        tree.add('file-2')
567
 
        tree.remove('file-1')
568
 
        tree.commit('rev2')
569
 
        checkout = tree.branch.create_checkout('checkout')
570
 
        self.assertLength(0, calls)
571
 
        switch.switch(checkout.bzrdir, to_branch)
572
 
        self.assertLength(1, calls)
573
 
        params = calls[0]
574
 
        self.assertIsInstance(params, _mod_branch.SwitchHookParams)
575
 
        self.assertTrue(hasattr(params, 'to_branch'))
576
 
        self.assertTrue(hasattr(params, 'revision_id'))
577
 
 
578
 
 
579
 
class TestBranchOptions(tests.TestCaseWithTransport):
580
 
 
581
 
    def setUp(self):
582
 
        super(TestBranchOptions, self).setUp()
583
 
        self.branch = self.make_branch('.')
584
 
        self.config = self.branch.get_config()
585
 
 
586
 
    def check_append_revisions_only(self, expected_value, value=None):
587
 
        """Set append_revisions_only in config and check its interpretation."""
588
 
        if value is not None:
589
 
            self.config.set_user_option('append_revisions_only', value)
590
 
        self.assertEqual(expected_value,
591
 
                         self.branch._get_append_revisions_only())
592
 
 
593
 
    def test_valid_append_revisions_only(self):
594
 
        self.assertEquals(None,
595
 
                          self.config.get_user_option('append_revisions_only'))
596
 
        self.check_append_revisions_only(None)
597
 
        self.check_append_revisions_only(False, 'False')
598
 
        self.check_append_revisions_only(True, 'True')
599
 
        # The following values will cause compatibility problems on projects
600
 
        # using older bzr versions (<2.2) but are accepted
601
 
        self.check_append_revisions_only(False, 'false')
602
 
        self.check_append_revisions_only(True, 'true')
603
 
 
604
 
    def test_invalid_append_revisions_only(self):
605
 
        """Ensure warning is noted on invalid settings"""
606
 
        self.warnings = []
607
 
        def warning(*args):
608
 
            self.warnings.append(args[0] % args[1:])
609
 
        self.overrideAttr(trace, 'warning', warning)
610
 
        self.check_append_revisions_only(None, 'not-a-bool')
611
 
        self.assertLength(1, self.warnings)
612
 
        self.assertEqual(
613
 
            'Value "not-a-bool" is not a boolean for "append_revisions_only"',
614
 
            self.warnings[0])
615
 
 
616
 
 
617
 
class TestPullResult(tests.TestCase):
 
491
            BranchHooks)
 
492
 
 
493
 
 
494
class TestPullResult(TestCase):
618
495
 
619
496
    def test_pull_result_to_int(self):
620
497
        # to support old code, the pull result can be used as an int
621
 
        r = _mod_branch.PullResult()
 
498
        r = PullResult()
622
499
        r.old_revno = 10
623
500
        r.new_revno = 20
624
501
        # this usage of results is not recommended for new code (because it
628
505
        self.assertEqual(a, "10 revisions pulled")
629
506
 
630
507
    def test_report_changed(self):
631
 
        r = _mod_branch.PullResult()
 
508
        r = PullResult()
632
509
        r.old_revid = "old-revid"
633
510
        r.old_revno = 10
634
511
        r.new_revid = "new-revid"
638
515
        self.assertEqual("Now on revision 20.\n", f.getvalue())
639
516
 
640
517
    def test_report_unchanged(self):
641
 
        r = _mod_branch.PullResult()
 
518
        r = PullResult()
642
519
        r.old_revid = "same-revid"
643
520
        r.new_revid = "same-revid"
644
521
        f = StringIO()
670
547
    """Helper for TestRunWithWriteLockedTarget."""
671
548
 
672
549
 
673
 
class TestRunWithWriteLockedTarget(tests.TestCase):
 
550
class TestRunWithWriteLockedTarget(TestCase):
674
551
    """Tests for _run_with_write_locked_target."""
675
552
 
676
553
    def setUp(self):
677
 
        tests.TestCase.setUp(self)
 
554
        TestCase.setUp(self)
678
555
        self._calls = []
679
556
 
680
557
    def func_that_returns_ok(self):
687
564
 
688
565
    def test_success_unlocks(self):
689
566
        lockable = _StubLockable(self._calls)
690
 
        result = _mod_branch._run_with_write_locked_target(
 
567
        result = _run_with_write_locked_target(
691
568
            lockable, self.func_that_returns_ok)
692
569
        self.assertEqual('ok', result)
693
570
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
695
572
    def test_exception_unlocks_and_propagates(self):
696
573
        lockable = _StubLockable(self._calls)
697
574
        self.assertRaises(_ErrorFromCallable,
698
 
                          _mod_branch._run_with_write_locked_target,
699
 
                          lockable, self.func_that_raises)
 
575
            _run_with_write_locked_target, lockable, self.func_that_raises)
700
576
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
701
577
 
702
578
    def test_callable_succeeds_but_error_during_unlock(self):
703
579
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
704
580
        self.assertRaises(_ErrorFromUnlock,
705
 
                          _mod_branch._run_with_write_locked_target,
706
 
                          lockable, self.func_that_returns_ok)
 
581
            _run_with_write_locked_target, lockable, self.func_that_returns_ok)
707
582
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
708
583
 
709
584
    def test_error_during_unlock_does_not_mask_original_error(self):
710
585
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
711
586
        self.assertRaises(_ErrorFromCallable,
712
 
                          _mod_branch._run_with_write_locked_target,
713
 
                          lockable, self.func_that_raises)
 
587
            _run_with_write_locked_target, lockable, self.func_that_raises)
714
588
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
715
589
 
716
590