151 lines
5.1 KiB
Python
151 lines
5.1 KiB
Python
# 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 ErrorFormatingTests(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 a 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."
|