/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_errors.py

  • Committer: Robert Collins
  • Date: 2007-07-15 15:40:37 UTC
  • mto: (2592.3.33 repository)
  • mto: This revision was merged to the branch mainline in revision 2624.
  • Revision ID: robertc@robertcollins.net-20070715154037-3ar8g89decddc9su
Make GraphIndex accept nodes as key, value, references, so that the method
signature is closer to what a simple key->value index delivers. Also
change the behaviour when the reference list count is zero to accept
key, value as nodes, and emit key, value to make it identical in that case
to a simple key->value index. This may not be a good idea, but for now it
seems ok.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
 
2
#   Authors: Robert Collins <robert.collins@canonical.com>
 
3
#            and others
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
12
14
#
13
15
# You should have received a copy of the GNU General Public License
14
16
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
18
 
17
19
"""Tests for the formatting and construction of errors."""
18
20
 
19
 
import socket
20
 
import sys
21
 
 
22
21
from bzrlib import (
23
22
    bzrdir,
24
23
    errors,
25
 
    osutils,
26
 
    symbol_versioning,
27
 
    urlutils,
28
24
    )
29
25
from bzrlib.tests import TestCase, TestCaseWithTransport
30
26
 
31
27
 
 
28
# TODO: Make sure builtin exception class formats are consistent - e.g. should
 
29
# or shouldn't end with a full stop, etc.
 
30
 
 
31
 
32
32
class TestErrors(TestCaseWithTransport):
33
33
 
34
 
    def test_bad_filename_encoding(self):
35
 
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
36
 
        self.assertEqualDiff(
37
 
            "Filename 'bad/filen\\xe5me' is not valid in your current"
38
 
            " filesystem encoding UTF-8",
39
 
            str(error))
40
 
 
41
 
    def test_corrupt_dirstate(self):
42
 
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
43
 
        self.assertEqualDiff(
44
 
            "Inconsistency in dirstate file path/to/dirstate.\n"
45
 
            "Error: the reason why",
46
 
            str(error))
47
 
 
48
 
    def test_dirstate_corrupt(self):
49
 
        error = errors.DirstateCorrupt('.bzr/checkout/dirstate',
50
 
                                       'trailing garbage: "x"')
51
 
        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
52
 
            " appears to be corrupt: trailing garbage: \"x\"",
53
 
            str(error))
54
 
 
55
34
    def test_disabled_method(self):
56
35
        error = errors.DisabledMethod("class name")
57
36
        self.assertEqualDiff(
67
46
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
68
47
            str(error))
69
48
 
70
 
    def test_ghost_revisions_have_no_revno(self):
71
 
        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
72
 
        self.assertEqualDiff("Could not determine revno for {target} because"
73
 
                             " its ancestry shows a ghost at {ghost_rev}",
74
 
                             str(error))
75
 
 
76
49
    def test_incompatibleAPI(self):
77
50
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
78
51
        self.assertEqualDiff(
80
53
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
81
54
            str(error))
82
55
 
83
 
    def test_inconsistent_delta(self):
84
 
        error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
85
 
        self.assertEqualDiff(
86
 
            "An inconsistent delta was supplied involving 'path', 'file-id'\n"
87
 
            "reason: reason for foo",
88
 
            str(error))
89
 
 
90
 
    def test_inconsistent_delta_delta(self):
91
 
        error = errors.InconsistentDeltaDelta([], 'reason')
92
 
        self.assertEqualDiff(
93
 
            "An inconsistent delta was supplied: []\nreason: reason",
94
 
            str(error))
95
 
 
96
 
    def test_in_process_transport(self):
97
 
        error = errors.InProcessTransport('fpp')
98
 
        self.assertEqualDiff(
99
 
            "The transport 'fpp' is only accessible within this process.",
100
 
            str(error))
101
 
 
102
 
    def test_invalid_http_range(self):
103
 
        error = errors.InvalidHttpRange('path',
104
 
                                        'Content-Range: potatoes 0-00/o0oo0',
105
 
                                        'bad range')
106
 
        self.assertEquals("Invalid http range"
107
 
                          " 'Content-Range: potatoes 0-00/o0oo0'"
108
 
                          " for path: bad range",
109
 
                          str(error))
110
 
 
111
 
    def test_invalid_range(self):
112
 
        error = errors.InvalidRange('path', 12, 'bad range')
113
 
        self.assertEquals("Invalid range access in path at 12: bad range",
114
 
                          str(error))
115
 
 
116
56
    def test_inventory_modified(self):
117
57
        error = errors.InventoryModified("a tree to be repred")
118
58
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
120
60
            "read without data loss.",
121
61
            str(error))
122
62
 
123
 
    def test_jail_break(self):
124
 
        error = errors.JailBreak("some url")
125
 
        self.assertEqualDiff("An attempt to access a url outside the server"
126
 
            " jail was made: 'some url'.",
127
 
            str(error))
 
63
    def test_install_failed(self):
 
64
        error = errors.InstallFailed(['rev-one'])
 
65
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
 
66
        error = errors.InstallFailed(['rev-one', 'rev-two'])
 
67
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
 
68
                         str(error))
 
69
        error = errors.InstallFailed([None])
 
70
        self.assertEqual("Could not install revisions:\nNone", str(error))
128
71
 
129
72
    def test_lock_active(self):
130
73
        error = errors.LockActive("lock description")
132
75
            "cannot be broken.",
133
76
            str(error))
134
77
 
135
 
    def test_knit_data_stream_incompatible(self):
136
 
        error = errors.KnitDataStreamIncompatible(
137
 
            'stream format', 'target format')
138
 
        self.assertEqual('Cannot insert knit data stream of format '
139
 
                         '"stream format" into knit of format '
140
 
                         '"target format".', str(error))
141
 
 
142
 
    def test_knit_data_stream_unknown(self):
143
 
        error = errors.KnitDataStreamUnknown(
144
 
            'stream format')
145
 
        self.assertEqual('Cannot parse knit data stream of format '
146
 
                         '"stream format".', str(error))
147
 
 
148
78
    def test_knit_header_error(self):
149
79
        error = errors.KnitHeaderError('line foo\n', 'path/to/file')
150
80
        self.assertEqual("Knit header error: 'line foo\\n' unexpected"
151
 
                         " for file \"path/to/file\".", str(error))
 
81
                         " for file path/to/file", str(error))
152
82
 
153
83
    def test_knit_index_unknown_method(self):
154
84
        error = errors.KnitIndexUnknownMethod('http://host/foo.kndx',
161
91
        error = errors.MediumNotConnected("a medium")
162
92
        self.assertEqualDiff(
163
93
            "The medium 'a medium' is not connected.", str(error))
164
 
 
165
 
    def test_no_public_branch(self):
166
 
        b = self.make_branch('.')
167
 
        error = errors.NoPublicBranch(b)
168
 
        url = urlutils.unescape_for_display(b.base, 'ascii')
169
 
        self.assertEqualDiff(
170
 
            'There is no public branch set for "%s".' % url, str(error))
171
 
 
 
94
        
172
95
    def test_no_repo(self):
173
96
        dir = bzrdir.BzrDir.create(self.get_url())
174
97
        error = errors.NoRepositoryPresent(dir)
175
98
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
176
99
        self.assertEqual(-1, str(error).find((dir.transport.base)))
177
 
 
 
100
        
178
101
    def test_no_smart_medium(self):
179
102
        error = errors.NoSmartMedium("a transport")
180
103
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
189
112
 
190
113
    def test_no_such_id(self):
191
114
        error = errors.NoSuchId("atree", "anid")
192
 
        self.assertEqualDiff("The file id \"anid\" is not present in the tree "
 
115
        self.assertEqualDiff("The file id anid is not present in the tree "
193
116
            "atree.",
194
117
            str(error))
195
118
 
196
119
    def test_no_such_revision_in_tree(self):
197
120
        error = errors.NoSuchRevisionInTree("atree", "anid")
198
 
        self.assertEqualDiff("The revision id {anid} is not present in the"
199
 
                             " tree atree.", str(error))
 
121
        self.assertEqualDiff("The revision id anid is not present in the tree "
 
122
            "atree.",
 
123
            str(error))
200
124
        self.assertIsInstance(error, errors.NoSuchRevision)
201
125
 
202
 
    def test_not_stacked(self):
203
 
        error = errors.NotStacked('a branch')
204
 
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
205
 
            str(error))
206
 
 
207
126
    def test_not_write_locked(self):
208
127
        error = errors.NotWriteLocked('a thing to repr')
209
128
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
210
129
            "to be.",
211
130
            str(error))
212
131
 
213
 
    def test_lock_failed(self):
214
 
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
215
 
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
216
 
            str(error))
217
 
        self.assertFalse(error.internal_error)
 
132
    def test_read_only_lock_error(self):
 
133
        error = errors.ReadOnlyLockError('filename', 'error message')
 
134
        self.assertEqualDiff("Cannot acquire write lock on filename."
 
135
                             " error message", str(error))
218
136
 
219
137
    def test_too_many_concurrent_requests(self):
220
138
        error = errors.TooManyConcurrentRequests("a medium")
223
141
            "the currently open request.",
224
142
            str(error))
225
143
 
226
 
    def test_unavailable_representation(self):
227
 
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
228
 
        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
229
 
            "('key',) which is encoded as 'fulltext'.",
230
 
            str(error))
231
 
 
232
144
    def test_unknown_hook(self):
233
145
        error = errors.UnknownHook("branch", "foo")
234
146
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
239
151
            " of bzrlib.",
240
152
            str(error))
241
153
 
242
 
    def test_unstackable_branch_format(self):
243
 
        format = u'foo'
244
 
        url = "/foo"
245
 
        error = errors.UnstackableBranchFormat(format, url)
246
 
        self.assertEqualDiff(
247
 
            "The branch '/foo'(foo) is not a stackable format. "
248
 
            "You will need to upgrade the branch to permit branch stacking.",
249
 
            str(error))
250
 
 
251
 
    def test_unstackable_location(self):
252
 
        error = errors.UnstackableLocationError('foo', 'bar')
253
 
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
254
 
            str(error))
255
 
 
256
 
    def test_unstackable_repository_format(self):
257
 
        format = u'foo'
258
 
        url = "/foo"
259
 
        error = errors.UnstackableRepositoryFormat(format, url)
260
 
        self.assertEqualDiff(
261
 
            "The repository '/foo'(foo) is not a stackable format. "
262
 
            "You will need to upgrade the repository to permit branch stacking.",
263
 
            str(error))
264
 
 
265
154
    def test_up_to_date(self):
266
155
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
267
 
        self.assertEqualDiff("The branch format All-in-one "
268
 
                             "format 4 is already at the most "
 
156
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
 
157
                             "format 0.0.4 is already at the most "
269
158
                             "recent format.",
270
159
                             str(error))
271
160
 
399
288
            host='ahost', port=444, msg='Unable to connect to ssh host',
400
289
            orig_error='my_error')
401
290
 
402
 
    def test_target_not_branch(self):
403
 
        """Test the formatting of TargetNotBranch."""
404
 
        error = errors.TargetNotBranch('foo')
405
 
        self.assertEqual(
406
 
            "Your branch does not have all of the revisions required in "
407
 
            "order to merge this merge directive and the target "
408
 
            "location specified in the merge directive is not a branch: "
409
 
            "foo.", str(error))
410
 
 
411
291
    def test_malformed_bug_identifier(self):
412
292
        """Test the formatting of MalformedBugIdentifier."""
413
293
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
414
294
        self.assertEqual(
415
 
            'Did not understand bug identifier bogus: reason for bogosity. '
416
 
            'See "bzr help bugs" for more information on this feature.',
 
295
            "Did not understand bug identifier bogus: reason for bogosity",
417
296
            str(error))
418
297
 
419
298
    def test_unknown_bug_tracker_abbreviation(self):
468
347
        """Test the formatting of DuplicateRecordNameError."""
469
348
        e = errors.DuplicateRecordNameError(u"n\xe5me".encode('utf-8'))
470
349
        self.assertEqual(
471
 
            "Container has multiple records with the same name: n\xc3\xa5me",
472
 
            str(e))
473
 
 
474
 
    def test_check_error(self):
475
 
        # This has a member called 'message', which is problematic in
476
 
        # python2.5 because that is a slot on the base Exception class
477
 
        e = errors.BzrCheckError('example check failure')
478
 
        self.assertEqual(
479
 
            "Internal check failed: example check failure",
480
 
            str(e))
481
 
        self.assertTrue(e.internal_error)
482
 
 
483
 
    def test_repository_data_stream_error(self):
484
 
        """Test the formatting of RepositoryDataStreamError."""
485
 
        e = errors.RepositoryDataStreamError(u"my reason")
486
 
        self.assertEqual(
487
 
            "Corrupt or incompatible data stream: my reason", str(e))
488
 
 
489
 
    def test_immortal_pending_deletion_message(self):
490
 
        err = errors.ImmortalPendingDeletion('foo')
491
 
        self.assertEquals(
492
 
            "Unable to delete transform temporary directory foo.  "
493
 
            "Please examine foo to see if it contains any files "
494
 
            "you wish to keep, and delete it when you are done.",
495
 
            str(err))
496
 
 
497
 
    def test_unable_create_symlink(self):
498
 
        err = errors.UnableCreateSymlink()
499
 
        self.assertEquals(
500
 
            "Unable to create symlink on this platform",
501
 
            str(err))
502
 
        err = errors.UnableCreateSymlink(path=u'foo')
503
 
        self.assertEquals(
504
 
            "Unable to create symlink 'foo' on this platform",
505
 
            str(err))
506
 
        err = errors.UnableCreateSymlink(path=u'\xb5')
507
 
        self.assertEquals(
508
 
            "Unable to create symlink u'\\xb5' on this platform",
509
 
            str(err))
510
 
 
511
 
    def test_invalid_url_join(self):
512
 
        """Test the formatting of InvalidURLJoin."""
513
 
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
514
 
        self.assertEqual(
515
 
            "Invalid URL join request: Reason: 'base path' + ('args',)",
516
 
            str(e))
517
 
 
518
 
    def test_incorrect_url(self):
519
 
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
520
 
        self.assertEquals(
521
 
            ("The URL for bug tracker \"foo\" doesn't contain {id}: "
522
 
             "http://bug.com/"),
523
 
            str(err))
524
 
 
525
 
    def test_unable_encode_path(self):
526
 
        err = errors.UnableEncodePath('foo', 'executable')
527
 
        self.assertEquals("Unable to encode executable path 'foo' in "
528
 
            "user encoding " + osutils.get_user_encoding(),
529
 
            str(err))
530
 
 
531
 
    def test_unknown_format(self):
532
 
        err = errors.UnknownFormatError('bar', kind='foo')
533
 
        self.assertEquals("Unknown foo format: 'bar'", str(err))
534
 
 
535
 
    def test_unknown_rules(self):
536
 
        err = errors.UnknownRules(['foo', 'bar'])
537
 
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
538
 
 
539
 
    def test_hook_failed(self):
540
 
        # Create an exc_info tuple by raising and catching an exception.
541
 
        try:
542
 
            1/0
543
 
        except ZeroDivisionError:
544
 
            exc_info = sys.exc_info()
545
 
        err = errors.HookFailed('hook stage', 'hook name', exc_info, warn=False)
546
 
        self.assertStartsWith(
547
 
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
548
 
        self.assertEndsWith(
549
 
            str(err), 'integer division or modulo by zero')
550
 
 
551
 
    def test_tip_change_rejected(self):
552
 
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
553
 
        self.assertEquals(
554
 
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
555
 
            unicode(err))
556
 
        self.assertEquals(
557
 
            'Tip change rejected: Unicode message\xe2\x80\xbd',
558
 
            str(err))
559
 
 
560
 
    def test_error_from_smart_server(self):
561
 
        error_tuple = ('error', 'tuple')
562
 
        err = errors.ErrorFromSmartServer(error_tuple)
563
 
        self.assertEquals(
564
 
            "Error received from smart server: ('error', 'tuple')", str(err))
565
 
 
566
 
    def test_untranslateable_error_from_smart_server(self):
567
 
        error_tuple = ('error', 'tuple')
568
 
        orig_err = errors.ErrorFromSmartServer(error_tuple)
569
 
        err = errors.UnknownErrorFromSmartServer(orig_err)
570
 
        self.assertEquals(
571
 
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
572
 
 
573
 
    def test_smart_message_handler_error(self):
574
 
        # Make an exc_info tuple.
575
 
        try:
576
 
            raise Exception("example error")
577
 
        except Exception:
578
 
            exc_info = sys.exc_info()
579
 
        err = errors.SmartMessageHandlerError(exc_info)
580
 
        self.assertStartsWith(
581
 
            str(err), "The message handler raised an exception:\n")
582
 
        self.assertEndsWith(str(err), "Exception: example error\n")
583
 
 
584
 
    def test_must_have_working_tree(self):
585
 
        err = errors.MustHaveWorkingTree('foo', 'bar')
586
 
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
587
 
                                   " working tree.")
588
 
 
589
 
    def test_no_such_view(self):
590
 
        err = errors.NoSuchView('foo')
591
 
        self.assertEquals("No such view: foo.", str(err))
592
 
 
593
 
    def test_views_not_supported(self):
594
 
        err = errors.ViewsNotSupported('atree')
595
 
        err_str = str(err)
596
 
        self.assertStartsWith(err_str, "Views are not supported by ")
597
 
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
598
 
            "tree to a later format.")
599
 
 
600
 
    def test_file_outside_view(self):
601
 
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
602
 
        self.assertEquals('Specified file "baz" is outside the current view: '
603
 
            'foo, bar', str(err))
604
 
 
605
 
    def test_invalid_shelf_id(self):
606
 
        invalid_id = "foo"
607
 
        err = errors.InvalidShelfId(invalid_id)
608
 
        self.assertEqual('"foo" is not a valid shelf id, '
609
 
            'try a number instead.', str(err))
610
 
 
611
 
    def test_unresumable_write_group(self):
612
 
        repo = "dummy repo"
613
 
        wg_tokens = ['token']
614
 
        reason = "a reason"
615
 
        err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
616
 
        self.assertEqual(
617
 
            "Repository dummy repo cannot resume write group "
618
 
            "['token']: a reason", str(err))
619
 
 
620
 
    def test_unsuspendable_write_group(self):
621
 
        repo = "dummy repo"
622
 
        err = errors.UnsuspendableWriteGroup(repo)
623
 
        self.assertEqual(
624
 
            'Repository dummy repo cannot suspend a write group.', str(err))
625
 
 
626
 
    def test_not_branch_no_args(self):
627
 
        err = errors.NotBranchError('path')
628
 
        self.assertEqual('Not a branch: "path".', str(err))
629
 
 
630
 
    def test_not_branch_bzrdir_with_repo(self):
631
 
        bzrdir = self.make_repository('repo').bzrdir
632
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
633
 
        self.assertEqual(
634
 
            'Not a branch: "path": location is a repository.', str(err))
635
 
 
636
 
    def test_not_branch_bzrdir_without_repo(self):
637
 
        bzrdir = self.make_bzrdir('bzrdir')
638
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
639
 
        self.assertEqual('Not a branch: "path".', str(err))
640
 
 
641
 
    def test_not_branch_laziness(self):
642
 
        real_bzrdir = self.make_bzrdir('path')
643
 
        class FakeBzrDir(object):
644
 
            def __init__(self):
645
 
                self.calls = []
646
 
            def open_repository(self):
647
 
                self.calls.append('open_repository')
648
 
                raise errors.NoRepositoryPresent(real_bzrdir)
649
 
        fake_bzrdir = FakeBzrDir()
650
 
        err = errors.NotBranchError('path', bzrdir=fake_bzrdir)
651
 
        self.assertEqual([], fake_bzrdir.calls)
652
 
        str(err)
653
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
654
 
        # Stringifying twice doesn't try to open a repository twice.
655
 
        str(err)
656
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
 
350
            "Container has multiple records with the same name: \"n\xc3\xa5me\"",
 
351
            str(e))
657
352
 
658
353
 
659
354
class PassThroughError(errors.BzrError):
660
 
 
 
355
    
661
356
    _fmt = """Pass through %(foo)s and %(bar)s"""
662
357
 
663
358
    def __init__(self, foo, bar):
670
365
 
671
366
 
672
367
class ErrorWithNoFormat(errors.BzrError):
673
 
    __doc__ = """This class has a docstring but no format string."""
 
368
    """This class has a docstring but no format string."""
674
369
 
675
370
 
676
371
class TestErrorFormatting(TestCase):
677
 
 
 
372
    
678
373
    def test_always_str(self):
679
374
        e = PassThroughError(u'\xb5', 'bar')
680
375
        self.assertIsInstance(e.__str__(), str)
691
386
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
692
387
                lambda x: str(x), e)
693
388
        ## s = str(e)
694
 
        self.assertEqual(s,
 
389
        self.assertEqual(s, 
695
390
                "This class has a docstring but no format string.")
696
391
 
697
392
    def test_mismatched_format_args(self):
701
396
        e = ErrorWithBadFormat(not_thing='x')
702
397
        self.assertStartsWith(
703
398
            str(e), 'Unprintable exception ErrorWithBadFormat')
704
 
 
705
 
    def test_cannot_bind_address(self):
706
 
        # see <https://bugs.edge.launchpad.net/bzr/+bug/286871>
707
 
        e = errors.CannotBindAddress('example.com', 22,
708
 
            socket.error(13, 'Permission denied'))
709
 
        self.assertContainsRe(str(e),
710
 
            r'Cannot bind address "example\.com:22":.*Permission denied')
711
 
 
712
 
    def test_file_timestamp_unavailable(self):            
713
 
        e = errors.FileTimestampUnavailable("/path/foo")
714
 
        self.assertEquals("The filestamp for /path/foo is not available.",
715
 
            str(e))