Remove third_party/twisted_8_1

third_party/twisted_8_1/twisted/test/test_strerror.py

Index: third_party/twisted_8_1/twisted/test/test_strerror.py
diff --git a/third_party/twisted_8_1/twisted/test/test_strerror.py b/third_party/twisted_8_1/twisted/test/test_strerror.py
deleted file mode 100644
index 8918cf5c8370083e1b99690c6c2bda0f332a63f3..0000000000000000000000000000000000000000
--- a/third_party/twisted_8_1/twisted/test/test_strerror.py
+++ /dev/null
@@ -1,145 +0,0 @@
-# Copyright (c) 2007 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 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 (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)[1])
-            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 = "This error lookup only works 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)[1])
-        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 = "This error lookup only works on Windows"