← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

  • Committer: Andrew Bennetts
  • Date: 2010-10-08 08:15:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101008081514-dviqzrdfwyzsqbz2
Split NEWS into per-release doc/en/release-notes/bzr-*.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
3
 
#            and others
 
1
# Copyright (C) 2006-2010 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
14
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
16
 
19
17
"""Tests for the formatting and construction of errors."""
20
18
 
 
19
import inspect
 
20
import re
 
21
import socket
 
22
import sys
 
23
 
21
24
from bzrlib import (
22
25
    bzrdir,
23
26
    errors,
 
27
    osutils,
 
28
    symbol_versioning,
 
29
    urlutils,
24
30
    )
25
 
from bzrlib.tests import TestCase, TestCaseWithTransport
26
 
 
27
 
 
28
 
# TODO: Make sure builtin exception class formats are consistent - e.g. should
29
 
# or shouldn't end with a full stop, etc.
 
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
30
32
 
31
33
 
32
34
class TestErrors(TestCaseWithTransport):
33
35
 
 
36
    def test_no_arg_named_message(self):
 
37
        """Ensure the __init__ and _fmt in errors do not have "message" arg.
 
38
 
 
39
        This test fails if __init__ or _fmt in errors has an argument
 
40
        named "message" as this can cause errors in some Python versions.
 
41
        Python 2.5 uses a slot for StandardError.message.
 
42
        See bug #603461
 
43
        """
 
44
        fmt_pattern = re.compile("%\(message\)[sir]")
 
45
        subclasses_present = getattr(errors.BzrError, '__subclasses__', None)
 
46
        if not subclasses_present:
 
47
            raise TestSkipped('__subclasses__ attribute required for classes. '
 
48
                'Requires Python 2.5 or later.')
 
49
        for c in errors.BzrError.__subclasses__():
 
50
            init = getattr(c, '__init__', None)
 
51
            fmt = getattr(c, '_fmt', None)
 
52
            if init:
 
53
                args = inspect.getargspec(init)[0]
 
54
                self.assertFalse('message' in args,
 
55
                    ('Argument name "message" not allowed for '
 
56
                    '"errors.%s.__init__"' % c.__name__))
 
57
            if fmt and fmt_pattern.search(fmt):
 
58
                self.assertFalse(True, ('"message" not allowed in '
 
59
                    '"errors.%s._fmt"' % c.__name__))
 
60
 
 
61
    def test_bad_filename_encoding(self):
 
62
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
 
63
        self.assertEqualDiff(
 
64
            "Filename 'bad/filen\\xe5me' is not valid in your current"
 
65
            " filesystem encoding UTF-8",
 
66
            str(error))
 
67
 
 
68
    def test_corrupt_dirstate(self):
 
69
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
 
70
        self.assertEqualDiff(
 
71
            "Inconsistency in dirstate file path/to/dirstate.\n"
 
72
            "Error: the reason why",
 
73
            str(error))
 
74
 
 
75
    def test_dirstate_corrupt(self):
 
76
        error = errors.DirstateCorrupt('.bzr/checkout/dirstate',
 
77
                                       'trailing garbage: "x"')
 
78
        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
 
79
            " appears to be corrupt: trailing garbage: \"x\"",
 
80
            str(error))
 
81
 
34
82
    def test_disabled_method(self):
35
83
        error = errors.DisabledMethod("class name")
36
84
        self.assertEqualDiff(
46
94
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
47
95
            str(error))
48
96
 
 
97
    def test_ghost_revisions_have_no_revno(self):
 
98
        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
 
99
        self.assertEqualDiff("Could not determine revno for {target} because"
 
100
                             " its ancestry shows a ghost at {ghost_rev}",
 
101
                             str(error))
 
102
 
49
103
    def test_incompatibleAPI(self):
50
104
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
51
105
        self.assertEqualDiff(
53
107
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
54
108
            str(error))
55
109
 
 
110
    def test_inconsistent_delta(self):
 
111
        error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
 
112
        self.assertEqualDiff(
 
113
            "An inconsistent delta was supplied involving 'path', 'file-id'\n"
 
114
            "reason: reason for foo",
 
115
            str(error))
 
116
 
 
117
    def test_inconsistent_delta_delta(self):
 
118
        error = errors.InconsistentDeltaDelta([], 'reason')
 
119
        self.assertEqualDiff(
 
120
            "An inconsistent delta was supplied: []\nreason: reason",
 
121
            str(error))
 
122
 
56
123
    def test_in_process_transport(self):
57
124
        error = errors.InProcessTransport('fpp')
58
125
        self.assertEqualDiff(
59
126
            "The transport 'fpp' is only accessible within this process.",
60
127
            str(error))
61
128
 
 
129
    def test_invalid_http_range(self):
 
130
        error = errors.InvalidHttpRange('path',
 
131
                                        'Content-Range: potatoes 0-00/o0oo0',
 
132
                                        'bad range')
 
133
        self.assertEquals("Invalid http range"
 
134
                          " 'Content-Range: potatoes 0-00/o0oo0'"
 
135
                          " for path: bad range",
 
136
                          str(error))
 
137
 
 
138
    def test_invalid_range(self):
 
139
        error = errors.InvalidRange('path', 12, 'bad range')
 
140
        self.assertEquals("Invalid range access in path at 12: bad range",
 
141
                          str(error))
 
142
 
62
143
    def test_inventory_modified(self):
63
144
        error = errors.InventoryModified("a tree to be repred")
64
145
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
66
147
            "read without data loss.",
67
148
            str(error))
68
149
 
69
 
    def test_install_failed(self):
70
 
        error = errors.InstallFailed(['rev-one'])
71
 
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
72
 
        error = errors.InstallFailed(['rev-one', 'rev-two'])
73
 
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
74
 
                         str(error))
75
 
        error = errors.InstallFailed([None])
76
 
        self.assertEqual("Could not install revisions:\nNone", str(error))
 
150
    def test_jail_break(self):
 
151
        error = errors.JailBreak("some url")
 
152
        self.assertEqualDiff("An attempt to access a url outside the server"
 
153
            " jail was made: 'some url'.",
 
154
            str(error))
77
155
 
78
156
    def test_lock_active(self):
79
157
        error = errors.LockActive("lock description")
81
159
            "cannot be broken.",
82
160
            str(error))
83
161
 
 
162
    def test_lock_corrupt(self):
 
163
        error = errors.LockCorrupt("corruption info")
 
164
        self.assertEqualDiff("Lock is apparently held, but corrupted: "
 
165
            "corruption info\n"
 
166
            "Use 'bzr break-lock' to clear it",
 
167
            str(error))
 
168
 
84
169
    def test_knit_data_stream_incompatible(self):
85
170
        error = errors.KnitDataStreamIncompatible(
86
171
            'stream format', 'target format')
88
173
                         '"stream format" into knit of format '
89
174
                         '"target format".', str(error))
90
175
 
 
176
    def test_knit_data_stream_unknown(self):
 
177
        error = errors.KnitDataStreamUnknown(
 
178
            'stream format')
 
179
        self.assertEqual('Cannot parse knit data stream of format '
 
180
                         '"stream format".', str(error))
 
181
 
91
182
    def test_knit_header_error(self):
92
183
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
93
184
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
104
195
        error = errors.MediumNotConnected("a medium")
105
196
        self.assertEqualDiff(
106
197
            "The medium 'a medium' is not connected.", str(error))
107
 
        
 
198
 
 
199
    def test_no_public_branch(self):
 
200
        b = self.make_branch('.')
 
201
        error = errors.NoPublicBranch(b)
 
202
        url = urlutils.unescape_for_display(b.base, 'ascii')
 
203
        self.assertEqualDiff(
 
204
            'There is no public branch set for "%s".' % url, str(error))
 
205
 
108
206
    def test_no_repo(self):
109
207
        dir = bzrdir.BzrDir.create(self.get_url())
110
208
        error = errors.NoRepositoryPresent(dir)
111
209
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
112
210
        self.assertEqual(-1, str(error).find((dir.transport.base)))
113
 
        
 
211
 
114
212
    def test_no_smart_medium(self):
115
213
        error = errors.NoSmartMedium("a transport")
116
214
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
135
233
                             " tree atree.", str(error))
136
234
        self.assertIsInstance(error, errors.NoSuchRevision)
137
235
 
 
236
    def test_not_stacked(self):
 
237
        error = errors.NotStacked('a branch')
 
238
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
 
239
            str(error))
 
240
 
138
241
    def test_not_write_locked(self):
139
242
        error = errors.NotWriteLocked('a thing to repr')
140
243
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
141
244
            "to be.",
142
245
            str(error))
143
246
 
144
 
    def test_read_only_lock_error(self):
145
 
        error = errors.ReadOnlyLockError('filename', 'error message')
146
 
        self.assertEqualDiff("Cannot acquire write lock on filename."
147
 
                             " error message", str(error))
 
247
    def test_lock_failed(self):
 
248
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
 
249
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
 
250
            str(error))
 
251
        self.assertFalse(error.internal_error)
148
252
 
149
253
    def test_too_many_concurrent_requests(self):
150
254
        error = errors.TooManyConcurrentRequests("a medium")
153
257
            "the currently open request.",
154
258
            str(error))
155
259
 
 
260
    def test_unavailable_representation(self):
 
261
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
 
262
        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
 
263
            "('key',) which is encoded as 'fulltext'.",
 
264
            str(error))
 
265
 
156
266
    def test_unknown_hook(self):
157
267
        error = errors.UnknownHook("branch", "foo")
158
268
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
163
273
            " of bzrlib.",
164
274
            str(error))
165
275
 
 
276
    def test_unstackable_branch_format(self):
 
277
        format = u'foo'
 
278
        url = "/foo"
 
279
        error = errors.UnstackableBranchFormat(format, url)
 
280
        self.assertEqualDiff(
 
281
            "The branch '/foo'(foo) is not a stackable format. "
 
282
            "You will need to upgrade the branch to permit branch stacking.",
 
283
            str(error))
 
284
 
 
285
    def test_unstackable_location(self):
 
286
        error = errors.UnstackableLocationError('foo', 'bar')
 
287
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
 
288
            str(error))
 
289
 
 
290
    def test_unstackable_repository_format(self):
 
291
        format = u'foo'
 
292
        url = "/foo"
 
293
        error = errors.UnstackableRepositoryFormat(format, url)
 
294
        self.assertEqualDiff(
 
295
            "The repository '/foo'(foo) is not a stackable format. "
 
296
            "You will need to upgrade the repository to permit branch stacking.",
 
297
            str(error))
 
298
 
166
299
    def test_up_to_date(self):
167
300
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
168
 
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
169
 
                             "format 0.0.4 is already at the most "
 
301
        self.assertEqualDiff("The branch format All-in-one "
 
302
                             "format 4 is already at the most "
170
303
                             "recent format.",
171
304
                             str(error))
172
305
 
300
433
            host='ahost', port=444, msg='Unable to connect to ssh host',
301
434
            orig_error='my_error')
302
435
 
 
436
    def test_target_not_branch(self):
 
437
        """Test the formatting of TargetNotBranch."""
 
438
        error = errors.TargetNotBranch('foo')
 
439
        self.assertEqual(
 
440
            "Your branch does not have all of the revisions required in "
 
441
            "order to merge this merge directive and the target "
 
442
            "location specified in the merge directive is not a branch: "
 
443
            "foo.", str(error))
 
444
 
303
445
    def test_malformed_bug_identifier(self):
304
446
        """Test the formatting of MalformedBugIdentifier."""
305
447
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
306
448
        self.assertEqual(
307
 
            "Did not understand bug identifier bogus: reason for bogosity",
 
449
            'Did not understand bug identifier bogus: reason for bogosity. '
 
450
            'See "bzr help bugs" for more information on this feature.',
308
451
            str(error))
309
452
 
310
453
    def test_unknown_bug_tracker_abbreviation(self):
362
505
            "Container has multiple records with the same name: n\xc3\xa5me",
363
506
            str(e))
364
507
 
 
508
    def test_check_error(self):
 
509
        # This has a member called 'message', which is problematic in
 
510
        # python2.5 because that is a slot on the base Exception class
 
511
        e = errors.BzrCheckError('example check failure')
 
512
        self.assertEqual(
 
513
            "Internal check failed: example check failure",
 
514
            str(e))
 
515
        self.assertTrue(e.internal_error)
 
516
 
 
517
    def test_repository_data_stream_error(self):
 
518
        """Test the formatting of RepositoryDataStreamError."""
 
519
        e = errors.RepositoryDataStreamError(u"my reason")
 
520
        self.assertEqual(
 
521
            "Corrupt or incompatible data stream: my reason", str(e))
 
522
 
 
523
    def test_immortal_pending_deletion_message(self):
 
524
        err = errors.ImmortalPendingDeletion('foo')
 
525
        self.assertEquals(
 
526
            "Unable to delete transform temporary directory foo.  "
 
527
            "Please examine foo to see if it contains any files "
 
528
            "you wish to keep, and delete it when you are done.",
 
529
            str(err))
 
530
 
 
531
    def test_unable_create_symlink(self):
 
532
        err = errors.UnableCreateSymlink()
 
533
        self.assertEquals(
 
534
            "Unable to create symlink on this platform",
 
535
            str(err))
 
536
        err = errors.UnableCreateSymlink(path=u'foo')
 
537
        self.assertEquals(
 
538
            "Unable to create symlink 'foo' on this platform",
 
539
            str(err))
 
540
        err = errors.UnableCreateSymlink(path=u'\xb5')
 
541
        self.assertEquals(
 
542
            "Unable to create symlink u'\\xb5' on this platform",
 
543
            str(err))
 
544
 
 
545
    def test_invalid_url_join(self):
 
546
        """Test the formatting of InvalidURLJoin."""
 
547
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
 
548
        self.assertEqual(
 
549
            "Invalid URL join request: Reason: 'base path' + ('args',)",
 
550
            str(e))
 
551
 
 
552
    def test_incorrect_url(self):
 
553
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
 
554
        self.assertEquals(
 
555
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
 
556
             "http://bug.com/"),
 
557
            str(err))
 
558
 
 
559
    def test_unable_encode_path(self):
 
560
        err = errors.UnableEncodePath('foo', 'executable')
 
561
        self.assertEquals("Unable to encode executable path 'foo' in "
 
562
            "user encoding " + osutils.get_user_encoding(),
 
563
            str(err))
 
564
 
 
565
    def test_unknown_format(self):
 
566
        err = errors.UnknownFormatError('bar', kind='foo')
 
567
        self.assertEquals("Unknown foo format: 'bar'", str(err))
 
568
 
 
569
    def test_unknown_rules(self):
 
570
        err = errors.UnknownRules(['foo', 'bar'])
 
571
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
 
572
 
 
573
    def test_hook_failed(self):
 
574
        # Create an exc_info tuple by raising and catching an exception.
 
575
        try:
 
576
            1/0
 
577
        except ZeroDivisionError:
 
578
            exc_info = sys.exc_info()
 
579
        err = errors.HookFailed('hook stage', 'hook name', exc_info, warn=False)
 
580
        self.assertStartsWith(
 
581
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
 
582
        self.assertEndsWith(
 
583
            str(err), 'integer division or modulo by zero')
 
584
 
 
585
    def test_tip_change_rejected(self):
 
586
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
 
587
        self.assertEquals(
 
588
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
 
589
            unicode(err))
 
590
        self.assertEquals(
 
591
            'Tip change rejected: Unicode message\xe2\x80\xbd',
 
592
            str(err))
 
593
 
 
594
    def test_error_from_smart_server(self):
 
595
        error_tuple = ('error', 'tuple')
 
596
        err = errors.ErrorFromSmartServer(error_tuple)
 
597
        self.assertEquals(
 
598
            "Error received from smart server: ('error', 'tuple')", str(err))
 
599
 
 
600
    def test_untranslateable_error_from_smart_server(self):
 
601
        error_tuple = ('error', 'tuple')
 
602
        orig_err = errors.ErrorFromSmartServer(error_tuple)
 
603
        err = errors.UnknownErrorFromSmartServer(orig_err)
 
604
        self.assertEquals(
 
605
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
 
606
 
 
607
    def test_smart_message_handler_error(self):
 
608
        # Make an exc_info tuple.
 
609
        try:
 
610
            raise Exception("example error")
 
611
        except Exception:
 
612
            exc_info = sys.exc_info()
 
613
        err = errors.SmartMessageHandlerError(exc_info)
 
614
        self.assertStartsWith(
 
615
            str(err), "The message handler raised an exception:\n")
 
616
        self.assertEndsWith(str(err), "Exception: example error\n")
 
617
 
 
618
    def test_must_have_working_tree(self):
 
619
        err = errors.MustHaveWorkingTree('foo', 'bar')
 
620
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
 
621
                                   " working tree.")
 
622
 
 
623
    def test_no_such_view(self):
 
624
        err = errors.NoSuchView('foo')
 
625
        self.assertEquals("No such view: foo.", str(err))
 
626
 
 
627
    def test_views_not_supported(self):
 
628
        err = errors.ViewsNotSupported('atree')
 
629
        err_str = str(err)
 
630
        self.assertStartsWith(err_str, "Views are not supported by ")
 
631
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
 
632
            "tree to a later format.")
 
633
 
 
634
    def test_file_outside_view(self):
 
635
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
 
636
        self.assertEquals('Specified file "baz" is outside the current view: '
 
637
            'foo, bar', str(err))
 
638
 
 
639
    def test_invalid_shelf_id(self):
 
640
        invalid_id = "foo"
 
641
        err = errors.InvalidShelfId(invalid_id)
 
642
        self.assertEqual('"foo" is not a valid shelf id, '
 
643
            'try a number instead.', str(err))
 
644
 
 
645
    def test_unresumable_write_group(self):
 
646
        repo = "dummy repo"
 
647
        wg_tokens = ['token']
 
648
        reason = "a reason"
 
649
        err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
 
650
        self.assertEqual(
 
651
            "Repository dummy repo cannot resume write group "
 
652
            "['token']: a reason", str(err))
 
653
 
 
654
    def test_unsuspendable_write_group(self):
 
655
        repo = "dummy repo"
 
656
        err = errors.UnsuspendableWriteGroup(repo)
 
657
        self.assertEqual(
 
658
            'Repository dummy repo cannot suspend a write group.', str(err))
 
659
 
 
660
    def test_not_branch_no_args(self):
 
661
        err = errors.NotBranchError('path')
 
662
        self.assertEqual('Not a branch: "path".', str(err))
 
663
 
 
664
    def test_not_branch_bzrdir_with_repo(self):
 
665
        bzrdir = self.make_repository('repo').bzrdir
 
666
        err = errors.NotBranchError('path', bzrdir=bzrdir)
 
667
        self.assertEqual(
 
668
            'Not a branch: "path": location is a repository.', str(err))
 
669
 
 
670
    def test_not_branch_bzrdir_without_repo(self):
 
671
        bzrdir = self.make_bzrdir('bzrdir')
 
672
        err = errors.NotBranchError('path', bzrdir=bzrdir)
 
673
        self.assertEqual('Not a branch: "path".', str(err))
 
674
 
 
675
    def test_not_branch_laziness(self):
 
676
        real_bzrdir = self.make_bzrdir('path')
 
677
        class FakeBzrDir(object):
 
678
            def __init__(self):
 
679
                self.calls = []
 
680
            def open_repository(self):
 
681
                self.calls.append('open_repository')
 
682
                raise errors.NoRepositoryPresent(real_bzrdir)
 
683
        fake_bzrdir = FakeBzrDir()
 
684
        err = errors.NotBranchError('path', bzrdir=fake_bzrdir)
 
685
        self.assertEqual([], fake_bzrdir.calls)
 
686
        str(err)
 
687
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
688
        # Stringifying twice doesn't try to open a repository twice.
 
689
        str(err)
 
690
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
691
 
 
692
    def test_invalid_pattern(self):
 
693
        error = errors.InvalidPattern('Bad pattern msg.')
 
694
        self.assertEqualDiff("Invalid pattern(s) found. Bad pattern msg.",
 
695
            str(error))
 
696
 
 
697
    def test_recursive_bind(self):
 
698
        error = errors.RecursiveBind('foo_bar_branch')
 
699
        msg = ('Branch "foo_bar_branch" appears to be bound to itself. '
 
700
            'Please use `bzr unbind` to fix.')
 
701
        self.assertEqualDiff(msg, str(error))
 
702
 
365
703
 
366
704
class PassThroughError(errors.BzrError):
367
 
    
 
705
 
368
706
    _fmt = """Pass through %(foo)s and %(bar)s"""
369
707
 
370
708
    def __init__(self, foo, bar):
377
715
 
378
716
 
379
717
class ErrorWithNoFormat(errors.BzrError):
380
 
    """This class has a docstring but no format string."""
 
718
    __doc__ = """This class has a docstring but no format string."""
381
719
 
382
720
 
383
721
class TestErrorFormatting(TestCase):
384
 
    
 
722
 
385
723
    def test_always_str(self):
386
724
        e = PassThroughError(u'\xb5', 'bar')
387
725
        self.assertIsInstance(e.__str__(), str)
398
736
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
399
737
                lambda x: str(x), e)
400
738
        ## s = str(e)
401
 
        self.assertEqual(s, 
 
739
        self.assertEqual(s,
402
740
                "This class has a docstring but no format string.")
403
741
 
404
742
    def test_mismatched_format_args(self):
408
746
        e = ErrorWithBadFormat(not_thing='x')
409
747
        self.assertStartsWith(
410
748
            str(e), 'Unprintable exception ErrorWithBadFormat')
 
749
 
 
750
    def test_cannot_bind_address(self):
 
751
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
 
752
        e = errors.CannotBindAddress('example.com', 22,
 
753
            socket.error(13, 'Permission denied'))
 
754
        self.assertContainsRe(str(e),
 
755
            r'Cannot bind address "example\.com:22":.*Permission denied')
 
756
 
 
757
    def test_file_timestamp_unavailable(self):            
 
758
        e = errors.FileTimestampUnavailable("/path/foo")
 
759
        self.assertEquals("The filestamp for /path/foo is not available.",
 
760
            str(e))
 
761
            
 
762
    def test_transform_rename_failed(self):
 
763
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
 
764
        self.assertEquals(
 
765
            u"Failed to rename from to to: readonly file",
 
766
            str(e))