← 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: Ian Clatworthy
  • Date: 2007-12-11 02:07:30 UTC
  • mto: (3119.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3120.
  • Revision ID: ian.clatworthy@internode.on.net-20071211020730-sdj4kj794dw0628e
make help topics more discoverable

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_errors.py
1
 
# Copyright (C) 2006-2011 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 inspect
20
 
import re
21
 
import socket
22
 
import sys
23
 
 
24
21
from bzrlib import (
25
22
    bzrdir,
26
23
    errors,
27
 
    osutils,
28
 
    urlutils,
29
 
    )
30
 
from bzrlib.tests import (
31
 
    TestCase,
32
 
    TestCaseWithTransport,
33
 
    TestSkipped,
34
 
    )
 
24
    symbol_versioning,
 
25
    )
 
26
from bzrlib.tests import TestCase, TestCaseWithTransport
35
27
 
36
28
 
37
29
class TestErrors(TestCaseWithTransport):
38
30
 
39
 
    def test_no_arg_named_message(self):
40
 
        """Ensure the __init__ and _fmt in errors do not have "message" arg.
41
 
 
42
 
        This test fails if __init__ or _fmt in errors has an argument
43
 
        named "message" as this can cause errors in some Python versions.
44
 
        Python 2.5 uses a slot for StandardError.message.
45
 
        See bug #603461
46
 
        """
47
 
        fmt_pattern = re.compile("%\(message\)[sir]")
48
 
        subclasses_present = getattr(errors.BzrError, '__subclasses__', None)
49
 
        if not subclasses_present:
50
 
            raise TestSkipped('__subclasses__ attribute required for classes. '
51
 
                'Requires Python 2.5 or later.')
52
 
        for c in errors.BzrError.__subclasses__():
53
 
            init = getattr(c, '__init__', None)
54
 
            fmt = getattr(c, '_fmt', None)
55
 
            if init:
56
 
                args = inspect.getargspec(init)[0]
57
 
                self.assertFalse('message' in args,
58
 
                    ('Argument name "message" not allowed for '
59
 
                    '"errors.%s.__init__"' % c.__name__))
60
 
            if fmt and fmt_pattern.search(fmt):
61
 
                self.assertFalse(True, ('"message" not allowed in '
62
 
                    '"errors.%s._fmt"' % c.__name__))
63
 
 
64
 
    def test_bad_filename_encoding(self):
65
 
        error = errors.BadFilenameEncoding('bad/filen\xe5me', 'UTF-8')
66
 
        self.assertEqualDiff(
67
 
            "Filename 'bad/filen\\xe5me' is not valid in your current"
68
 
            " filesystem encoding UTF-8",
69
 
            str(error))
70
 
 
71
 
    def test_corrupt_dirstate(self):
72
 
        error = errors.CorruptDirstate('path/to/dirstate', 'the reason why')
73
 
        self.assertEqualDiff(
74
 
            "Inconsistency in dirstate file path/to/dirstate.\n"
75
 
            "Error: the reason why",
76
 
            str(error))
77
 
 
78
 
    def test_dirstate_corrupt(self):
79
 
        error = errors.DirstateCorrupt('.bzr/checkout/dirstate',
80
 
                                       'trailing garbage: "x"')
81
 
        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
82
 
            " appears to be corrupt: trailing garbage: \"x\"",
83
 
            str(error))
84
 
 
85
31
    def test_disabled_method(self):
86
32
        error = errors.DisabledMethod("class name")
87
33
        self.assertEqualDiff(
97
43
        self.assertEqualDiff('The prefix foo is in the help search path twice.',
98
44
            str(error))
99
45
 
100
 
    def test_ghost_revisions_have_no_revno(self):
101
 
        error = errors.GhostRevisionsHaveNoRevno('target', 'ghost_rev')
102
 
        self.assertEqualDiff("Could not determine revno for {target} because"
103
 
                             " its ancestry shows a ghost at {ghost_rev}",
104
 
                             str(error))
105
 
 
106
46
    def test_incompatibleAPI(self):
107
47
        error = errors.IncompatibleAPI("module", (1, 2, 3), (4, 5, 6), (7, 8, 9))
108
48
        self.assertEqualDiff(
110
50
            'It supports versions "(4, 5, 6)" to "(7, 8, 9)".',
111
51
            str(error))
112
52
 
113
 
    def test_inconsistent_delta(self):
114
 
        error = errors.InconsistentDelta('path', 'file-id', 'reason for foo')
115
 
        self.assertEqualDiff(
116
 
            "An inconsistent delta was supplied involving 'path', 'file-id'\n"
117
 
            "reason: reason for foo",
118
 
            str(error))
119
 
 
120
 
    def test_inconsistent_delta_delta(self):
121
 
        error = errors.InconsistentDeltaDelta([], 'reason')
122
 
        self.assertEqualDiff(
123
 
            "An inconsistent delta was supplied: []\nreason: reason",
124
 
            str(error))
125
 
 
126
53
    def test_in_process_transport(self):
127
54
        error = errors.InProcessTransport('fpp')
128
55
        self.assertEqualDiff(
129
56
            "The transport 'fpp' is only accessible within this process.",
130
57
            str(error))
131
58
 
132
 
    def test_invalid_http_range(self):
133
 
        error = errors.InvalidHttpRange('path',
134
 
                                        'Content-Range: potatoes 0-00/o0oo0',
135
 
                                        'bad range')
136
 
        self.assertEquals("Invalid http range"
137
 
                          " 'Content-Range: potatoes 0-00/o0oo0'"
138
 
                          " for path: bad range",
139
 
                          str(error))
140
 
 
141
 
    def test_invalid_range(self):
142
 
        error = errors.InvalidRange('path', 12, 'bad range')
143
 
        self.assertEquals("Invalid range access in path at 12: bad range",
144
 
                          str(error))
145
 
 
146
59
    def test_inventory_modified(self):
147
60
        error = errors.InventoryModified("a tree to be repred")
148
61
        self.assertEqualDiff("The current inventory for the tree 'a tree to "
150
63
            "read without data loss.",
151
64
            str(error))
152
65
 
153
 
    def test_jail_break(self):
154
 
        error = errors.JailBreak("some url")
155
 
        self.assertEqualDiff("An attempt to access a url outside the server"
156
 
            " jail was made: 'some url'.",
157
 
            str(error))
 
66
    def test_install_failed(self):
 
67
        error = errors.InstallFailed(['rev-one'])
 
68
        self.assertEqual("Could not install revisions:\nrev-one", str(error))
 
69
        error = errors.InstallFailed(['rev-one', 'rev-two'])
 
70
        self.assertEqual("Could not install revisions:\nrev-one, rev-two",
 
71
                         str(error))
 
72
        error = errors.InstallFailed([None])
 
73
        self.assertEqual("Could not install revisions:\nNone", str(error))
158
74
 
159
75
    def test_lock_active(self):
160
76
        error = errors.LockActive("lock description")
162
78
            "cannot be broken.",
163
79
            str(error))
164
80
 
165
 
    def test_lock_corrupt(self):
166
 
        error = errors.LockCorrupt("corruption info")
167
 
        self.assertEqualDiff("Lock is apparently held, but corrupted: "
168
 
            "corruption info\n"
169
 
            "Use 'bzr break-lock' to clear it",
170
 
            str(error))
171
 
 
172
81
    def test_knit_data_stream_incompatible(self):
173
82
        error = errors.KnitDataStreamIncompatible(
174
83
            'stream format', 'target format')
198
107
        error = errors.MediumNotConnected("a medium")
199
108
        self.assertEqualDiff(
200
109
            "The medium 'a medium' is not connected.", str(error))
201
 
 
202
 
    def test_no_public_branch(self):
203
 
        b = self.make_branch('.')
204
 
        error = errors.NoPublicBranch(b)
205
 
        url = urlutils.unescape_for_display(b.base, 'ascii')
206
 
        self.assertEqualDiff(
207
 
            'There is no public branch set for "%s".' % url, str(error))
208
 
 
 
110
        
209
111
    def test_no_repo(self):
210
112
        dir = bzrdir.BzrDir.create(self.get_url())
211
113
        error = errors.NoRepositoryPresent(dir)
212
114
        self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
213
115
        self.assertEqual(-1, str(error).find((dir.transport.base)))
214
 
 
 
116
        
215
117
    def test_no_smart_medium(self):
216
118
        error = errors.NoSmartMedium("a transport")
217
119
        self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
236
138
                             " tree atree.", str(error))
237
139
        self.assertIsInstance(error, errors.NoSuchRevision)
238
140
 
239
 
    def test_not_stacked(self):
240
 
        error = errors.NotStacked('a branch')
241
 
        self.assertEqualDiff("The branch 'a branch' is not stacked.",
242
 
            str(error))
243
 
 
244
141
    def test_not_write_locked(self):
245
142
        error = errors.NotWriteLocked('a thing to repr')
246
143
        self.assertEqualDiff("'a thing to repr' is not write locked but needs "
247
144
            "to be.",
248
145
            str(error))
249
146
 
 
147
    def test_read_only_lock_error(self):
 
148
        error = self.applyDeprecated(symbol_versioning.zero_ninetytwo,
 
149
            errors.ReadOnlyLockError, 'filename', 'error message')
 
150
        self.assertEqualDiff("Cannot acquire write lock on filename."
 
151
                             " error message", str(error))
 
152
 
250
153
    def test_lock_failed(self):
251
154
        error = errors.LockFailed('http://canonical.com/', 'readonly transport')
252
155
        self.assertEqualDiff("Cannot lock http://canonical.com/: readonly transport",
260
163
            "the currently open request.",
261
164
            str(error))
262
165
 
263
 
    def test_unavailable_representation(self):
264
 
        error = errors.UnavailableRepresentation(('key',), "mpdiff", "fulltext")
265
 
        self.assertEqualDiff("The encoding 'mpdiff' is not available for key "
266
 
            "('key',) which is encoded as 'fulltext'.",
267
 
            str(error))
268
 
 
269
166
    def test_unknown_hook(self):
270
167
        error = errors.UnknownHook("branch", "foo")
271
168
        self.assertEqualDiff("The branch hook 'foo' is unknown in this version"
276
173
            " of bzrlib.",
277
174
            str(error))
278
175
 
279
 
    def test_unstackable_branch_format(self):
280
 
        format = u'foo'
281
 
        url = "/foo"
282
 
        error = errors.UnstackableBranchFormat(format, url)
283
 
        self.assertEqualDiff(
284
 
            "The branch '/foo'(foo) is not a stackable format. "
285
 
            "You will need to upgrade the branch to permit branch stacking.",
286
 
            str(error))
287
 
 
288
 
    def test_unstackable_location(self):
289
 
        error = errors.UnstackableLocationError('foo', 'bar')
290
 
        self.assertEqualDiff("The branch 'foo' cannot be stacked on 'bar'.",
291
 
            str(error))
292
 
 
293
 
    def test_unstackable_repository_format(self):
294
 
        format = u'foo'
295
 
        url = "/foo"
296
 
        error = errors.UnstackableRepositoryFormat(format, url)
297
 
        self.assertEqualDiff(
298
 
            "The repository '/foo'(foo) is not a stackable format. "
299
 
            "You will need to upgrade the repository to permit branch stacking.",
300
 
            str(error))
301
 
 
302
176
    def test_up_to_date(self):
303
 
        error = errors.UpToDateFormat("someformat")
304
 
        self.assertEqualDiff(
305
 
            "The branch format someformat is already at the most "
306
 
            "recent format.", str(error))
 
177
        error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
 
178
        self.assertEqualDiff("The branch format Bazaar-NG branch, "
 
179
                             "format 0.0.4 is already at the most "
 
180
                             "recent format.",
 
181
                             str(error))
307
182
 
308
183
    def test_corrupt_repository(self):
309
184
        repo = self.make_repository('.')
435
310
            host='ahost', port=444, msg='Unable to connect to ssh host',
436
311
            orig_error='my_error')
437
312
 
438
 
    def test_target_not_branch(self):
439
 
        """Test the formatting of TargetNotBranch."""
440
 
        error = errors.TargetNotBranch('foo')
441
 
        self.assertEqual(
442
 
            "Your branch does not have all of the revisions required in "
443
 
            "order to merge this merge directive and the target "
444
 
            "location specified in the merge directive is not a branch: "
445
 
            "foo.", str(error))
446
 
 
447
313
    def test_malformed_bug_identifier(self):
448
314
        """Test the formatting of MalformedBugIdentifier."""
449
315
        error = errors.MalformedBugIdentifier('bogus', 'reason for bogosity')
450
316
        self.assertEqual(
451
 
            'Did not understand bug identifier bogus: reason for bogosity. '
452
 
            'See "bzr help bugs" for more information on this feature.',
 
317
            "Did not understand bug identifier bogus: reason for bogosity",
453
318
            str(error))
454
319
 
455
320
    def test_unknown_bug_tracker_abbreviation(self):
506
371
        self.assertEqual(
507
372
            "Container has multiple records with the same name: n\xc3\xa5me",
508
373
            str(e))
509
 
 
 
374
        
510
375
    def test_check_error(self):
511
376
        # This has a member called 'message', which is problematic in
512
377
        # python2.5 because that is a slot on the base Exception class
544
409
            "Unable to create symlink u'\\xb5' on this platform",
545
410
            str(err))
546
411
 
547
 
    def test_invalid_url_join(self):
548
 
        """Test the formatting of InvalidURLJoin."""
549
 
        e = errors.InvalidURLJoin('Reason', 'base path', ('args',))
550
 
        self.assertEqual(
551
 
            "Invalid URL join request: Reason: 'base path' + ('args',)",
552
 
            str(e))
553
 
 
554
412
    def test_incorrect_url(self):
555
413
        err = errors.InvalidBugTrackerURL('foo', 'http://bug.com/')
556
414
        self.assertEquals(
558
416
             "http://bug.com/"),
559
417
            str(err))
560
418
 
561
 
    def test_unable_encode_path(self):
562
 
        err = errors.UnableEncodePath('foo', 'executable')
563
 
        self.assertEquals("Unable to encode executable path 'foo' in "
564
 
            "user encoding " + osutils.get_user_encoding(),
565
 
            str(err))
566
 
 
567
 
    def test_unknown_format(self):
568
 
        err = errors.UnknownFormatError('bar', kind='foo')
569
 
        self.assertEquals("Unknown foo format: 'bar'", str(err))
570
 
 
571
 
    def test_unknown_rules(self):
572
 
        err = errors.UnknownRules(['foo', 'bar'])
573
 
        self.assertEquals("Unknown rules detected: foo, bar.", str(err))
574
 
 
575
 
    def test_hook_failed(self):
576
 
        # Create an exc_info tuple by raising and catching an exception.
577
 
        try:
578
 
            1/0
579
 
        except ZeroDivisionError:
580
 
            exc_info = sys.exc_info()
581
 
        err = errors.HookFailed('hook stage', 'hook name', exc_info, warn=False)
582
 
        self.assertStartsWith(
583
 
            str(err), 'Hook \'hook name\' during hook stage failed:\n')
584
 
        self.assertEndsWith(
585
 
            str(err), 'integer division or modulo by zero')
586
 
 
587
 
    def test_tip_change_rejected(self):
588
 
        err = errors.TipChangeRejected(u'Unicode message\N{INTERROBANG}')
589
 
        self.assertEquals(
590
 
            u'Tip change rejected: Unicode message\N{INTERROBANG}',
591
 
            unicode(err))
592
 
        self.assertEquals(
593
 
            'Tip change rejected: Unicode message\xe2\x80\xbd',
594
 
            str(err))
595
 
 
596
 
    def test_error_from_smart_server(self):
597
 
        error_tuple = ('error', 'tuple')
598
 
        err = errors.ErrorFromSmartServer(error_tuple)
599
 
        self.assertEquals(
600
 
            "Error received from smart server: ('error', 'tuple')", str(err))
601
 
 
602
 
    def test_untranslateable_error_from_smart_server(self):
603
 
        error_tuple = ('error', 'tuple')
604
 
        orig_err = errors.ErrorFromSmartServer(error_tuple)
605
 
        err = errors.UnknownErrorFromSmartServer(orig_err)
606
 
        self.assertEquals(
607
 
            "Server sent an unexpected error: ('error', 'tuple')", str(err))
608
 
 
609
 
    def test_smart_message_handler_error(self):
610
 
        # Make an exc_info tuple.
611
 
        try:
612
 
            raise Exception("example error")
613
 
        except Exception:
614
 
            exc_info = sys.exc_info()
615
 
        err = errors.SmartMessageHandlerError(exc_info)
616
 
        self.assertStartsWith(
617
 
            str(err), "The message handler raised an exception:\n")
618
 
        self.assertEndsWith(str(err), "Exception: example error\n")
619
 
 
620
 
    def test_must_have_working_tree(self):
621
 
        err = errors.MustHaveWorkingTree('foo', 'bar')
622
 
        self.assertEqual(str(err), "Branching 'bar'(foo) must create a"
623
 
                                   " working tree.")
624
 
 
625
 
    def test_no_such_view(self):
626
 
        err = errors.NoSuchView('foo')
627
 
        self.assertEquals("No such view: foo.", str(err))
628
 
 
629
 
    def test_views_not_supported(self):
630
 
        err = errors.ViewsNotSupported('atree')
631
 
        err_str = str(err)
632
 
        self.assertStartsWith(err_str, "Views are not supported by ")
633
 
        self.assertEndsWith(err_str, "; use 'bzr upgrade' to change your "
634
 
            "tree to a later format.")
635
 
 
636
 
    def test_file_outside_view(self):
637
 
        err = errors.FileOutsideView('baz', ['foo', 'bar'])
638
 
        self.assertEquals('Specified file "baz" is outside the current view: '
639
 
            'foo, bar', str(err))
640
 
 
641
 
    def test_invalid_shelf_id(self):
642
 
        invalid_id = "foo"
643
 
        err = errors.InvalidShelfId(invalid_id)
644
 
        self.assertEqual('"foo" is not a valid shelf id, '
645
 
            'try a number instead.', str(err))
646
 
 
647
 
    def test_unresumable_write_group(self):
648
 
        repo = "dummy repo"
649
 
        wg_tokens = ['token']
650
 
        reason = "a reason"
651
 
        err = errors.UnresumableWriteGroup(repo, wg_tokens, reason)
652
 
        self.assertEqual(
653
 
            "Repository dummy repo cannot resume write group "
654
 
            "['token']: a reason", str(err))
655
 
 
656
 
    def test_unsuspendable_write_group(self):
657
 
        repo = "dummy repo"
658
 
        err = errors.UnsuspendableWriteGroup(repo)
659
 
        self.assertEqual(
660
 
            'Repository dummy repo cannot suspend a write group.', str(err))
661
 
 
662
 
    def test_not_branch_no_args(self):
663
 
        err = errors.NotBranchError('path')
664
 
        self.assertEqual('Not a branch: "path".', str(err))
665
 
 
666
 
    def test_not_branch_bzrdir_with_repo(self):
667
 
        bzrdir = self.make_repository('repo').bzrdir
668
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
669
 
        self.assertEqual(
670
 
            'Not a branch: "path": location is a repository.', str(err))
671
 
 
672
 
    def test_not_branch_bzrdir_without_repo(self):
673
 
        bzrdir = self.make_bzrdir('bzrdir')
674
 
        err = errors.NotBranchError('path', bzrdir=bzrdir)
675
 
        self.assertEqual('Not a branch: "path".', str(err))
676
 
 
677
 
    def test_not_branch_bzrdir_with_recursive_not_branch_error(self):
678
 
        class FakeBzrDir(object):
679
 
            def open_repository(self):
680
 
                # str() on the NotBranchError will trigger a call to this,
681
 
                # which in turn will another, identical NotBranchError.
682
 
                raise errors.NotBranchError('path', bzrdir=FakeBzrDir())
683
 
        err = errors.NotBranchError('path', bzrdir=FakeBzrDir())
684
 
        self.assertEqual('Not a branch: "path".', str(err))
685
 
 
686
 
    def test_not_branch_laziness(self):
687
 
        real_bzrdir = self.make_bzrdir('path')
688
 
        class FakeBzrDir(object):
689
 
            def __init__(self):
690
 
                self.calls = []
691
 
            def open_repository(self):
692
 
                self.calls.append('open_repository')
693
 
                raise errors.NoRepositoryPresent(real_bzrdir)
694
 
        fake_bzrdir = FakeBzrDir()
695
 
        err = errors.NotBranchError('path', bzrdir=fake_bzrdir)
696
 
        self.assertEqual([], fake_bzrdir.calls)
697
 
        str(err)
698
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
699
 
        # Stringifying twice doesn't try to open a repository twice.
700
 
        str(err)
701
 
        self.assertEqual(['open_repository'], fake_bzrdir.calls)
702
 
 
703
 
    def test_invalid_pattern(self):
704
 
        error = errors.InvalidPattern('Bad pattern msg.')
705
 
        self.assertEqualDiff("Invalid pattern(s) found. Bad pattern msg.",
706
 
            str(error))
707
 
 
708
 
    def test_recursive_bind(self):
709
 
        error = errors.RecursiveBind('foo_bar_branch')
710
 
        msg = ('Branch "foo_bar_branch" appears to be bound to itself. '
711
 
            'Please use `bzr unbind` to fix.')
712
 
        self.assertEqualDiff(msg, str(error))
713
 
 
714
419
 
715
420
class PassThroughError(errors.BzrError):
716
 
 
 
421
    
717
422
    _fmt = """Pass through %(foo)s and %(bar)s"""
718
423
 
719
424
    def __init__(self, foo, bar):
726
431
 
727
432
 
728
433
class ErrorWithNoFormat(errors.BzrError):
729
 
    __doc__ = """This class has a docstring but no format string."""
 
434
    """This class has a docstring but no format string."""
730
435
 
731
436
 
732
437
class TestErrorFormatting(TestCase):
733
 
 
 
438
    
734
439
    def test_always_str(self):
735
440
        e = PassThroughError(u'\xb5', 'bar')
736
441
        self.assertIsInstance(e.__str__(), str)
747
452
                ['ErrorWithNoFormat uses its docstring as a format, it should use _fmt instead'],
748
453
                lambda x: str(x), e)
749
454
        ## s = str(e)
750
 
        self.assertEqual(s,
 
455
        self.assertEqual(s, 
751
456
                "This class has a docstring but no format string.")
752
457
 
753
458
    def test_mismatched_format_args(self):
757
462
        e = ErrorWithBadFormat(not_thing='x')
758
463
        self.assertStartsWith(
759
464
            str(e), 'Unprintable exception ErrorWithBadFormat')
760
 
 
761
 
    def test_cannot_bind_address(self):
762
 
        # see <https://bugs.launchpad.net/bzr/+bug/286871>
763
 
        e = errors.CannotBindAddress('example.com', 22,
764
 
            socket.error(13, 'Permission denied'))
765
 
        self.assertContainsRe(str(e),
766
 
            r'Cannot bind address "example\.com:22":.*Permission denied')
767
 
 
768
 
    def test_file_timestamp_unavailable(self):            
769
 
        e = errors.FileTimestampUnavailable("/path/foo")
770
 
        self.assertEquals("The filestamp for /path/foo is not available.",
771
 
            str(e))
772
 
            
773
 
    def test_transform_rename_failed(self):
774
 
        e = errors.TransformRenameFailed(u"from", u"to", "readonly file", 2)
775
 
        self.assertEquals(
776
 
            u"Failed to rename from to to: readonly file",
777
 
            str(e))