1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
Test strerror
"""
import socket
import os
from twisted.trial.unittest import TestCase
from twisted.internet.tcp import ECONNABORTED
from twisted.python.win32 import _ErrorFormatter, formatError
from twisted.python.runtime import platform
class _MyWindowsException(OSError):
"""
An exception type like L{ctypes.WinError}, but available on all platforms.
"""
class ErrorFormatingTestCase(TestCase):
"""
Tests for C{_ErrorFormatter.formatError}.
"""
probeErrorCode = ECONNABORTED
probeMessage = "correct message value"
def test_strerrorFormatting(self):
"""
L{_ErrorFormatter.formatError} should use L{os.strerror} to format
error messages if it is constructed without any better mechanism.
"""
formatter = _ErrorFormatter(None, None, None)
message = formatter.formatError(self.probeErrorCode)
self.assertEqual(message, os.strerror(self.probeErrorCode))
def test_emptyErrorTab(self):
"""
L{_ErrorFormatter.formatError} should use L{os.strerror} to format
error messages if it is constructed with only an error tab which does
not contain the error code it is called with.
"""
error = 1
# Sanity check
self.assertNotEqual(self.probeErrorCode, error)
formatter = _ErrorFormatter(None, None, {error: 'wrong message'})
message = formatter.formatError(self.probeErrorCode)
self.assertEqual(message, os.strerror(self.probeErrorCode))
def test_errorTab(self):
"""
L{_ErrorFormatter.formatError} should use C{errorTab} if it is supplied
and contains the requested error code.
"""
formatter = _ErrorFormatter(
None, None, {self.probeErrorCode: self.probeMessage})
message = formatter.formatError(self.probeErrorCode)
self.assertEqual(message, self.probeMessage)
def test_formatMessage(self):
"""
L{_ErrorFormatter.formatError} should return the return value of
C{formatMessage} if it is supplied.
"""
formatCalls = []
def formatMessage(errorCode):
formatCalls.append(errorCode)
return self.probeMessage
formatter = _ErrorFormatter(
None, formatMessage, {self.probeErrorCode: 'wrong message'})
message = formatter.formatError(self.probeErrorCode)
self.assertEqual(message, self.probeMessage)
self.assertEqual(formatCalls, [self.probeErrorCode])
def test_winError(self):
"""
L{_ErrorFormatter.formatError} should return the message argument from
the exception L{winError} returns, if L{winError} is supplied.
"""
winCalls = []
def winError(errorCode):
winCalls.append(errorCode)
return _MyWindowsException(errorCode, self.probeMessage)
formatter = _ErrorFormatter(
winError,
lambda error: 'formatMessage: wrong message',
{self.probeErrorCode: 'errorTab: wrong message'})
message = formatter.formatError(self.probeErrorCode)
self.assertEqual(message, self.probeMessage)
def test_fromEnvironment(self):
"""
L{_ErrorFormatter.fromEnvironment} should create an L{_ErrorFormatter}
instance with attributes populated from available modules.
"""
formatter = _ErrorFormatter.fromEnvironment()
if formatter.winError is not None:
from ctypes import WinError
self.assertEqual(
formatter.formatError(self.probeErrorCode),
WinError(self.probeErrorCode).strerror)
formatter.winError = None
if formatter.formatMessage is not None:
from win32api import FormatMessage
self.assertEqual(
formatter.formatError(self.probeErrorCode),
FormatMessage(self.probeErrorCode))
formatter.formatMessage = None
if formatter.errorTab is not None:
from socket import errorTab
self.assertEqual(
formatter.formatError(self.probeErrorCode),
errorTab[self.probeErrorCode])
if platform.getType() != "win32":
test_fromEnvironment.skip = "Test will run only on Windows."
def test_correctLookups(self):
"""
Given an known-good errno, make sure that formatMessage gives results
matching either C{socket.errorTab}, C{ctypes.WinError}, or
C{win32api.FormatMessage}.
"""
acceptable = [socket.errorTab[ECONNABORTED]]
try:
from ctypes import WinError
acceptable.append(WinError(ECONNABORTED).strerror)
except ImportError:
pass
try:
from win32api import FormatMessage
acceptable.append(FormatMessage(ECONNABORTED))
except ImportError:
pass
self.assertIn(formatError(ECONNABORTED), acceptable)
if platform.getType() != "win32":
test_correctLookups.skip = "Test will run only on Windows."
|
