Issue #7449, part 8: don't skip the whole test_asynchat if threading is missing

TestFifo can be executed without the threading module

Lib/test/test_asynchat.py

@@ -1,99 +1,102 @@
 # test asynchat
 
-import asyncore, asynchat, socket, threading, time
+import asyncore, asynchat, socket, time
 import unittest
 import sys
 from test import test_support
-
+try:
-# Skip tests if thread module does not exist.
+    import threading
-test_support.import_module('thread')
+except ImportError:
+    threading = None
 
 HOST = test_support.HOST
 SERVER_QUIT = 'QUIT\n'
 
-class echo_server(threading.Thread):
+if threading:
-    # parameter to determine the number of bytes passed back to the
+    class echo_server(threading.Thread):
-    # client each send
+        # parameter to determine the number of bytes passed back to the
-    chunk_size = 1
+        # client each send
+        chunk_size = 1
 
-    def __init__(self, event):
+        def __init__(self, event):
-        threading.Thread.__init__(self)
+            threading.Thread.__init__(self)
-        self.event = event
+            self.event = event
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.port = test_support.bind_port(self.sock)
+            self.port = test_support.bind_port(self.sock)
-        # This will be set if the client wants us to wait before echoing data
+            # This will be set if the client wants us to wait before echoing data
-        # back.
+            # back.
-        self.start_resend_event = None
+            self.start_resend_event = None
 
-    def run(self):
+        def run(self):
-        self.sock.listen(1)
+            self.sock.listen(1)
-        self.event.set()
+            self.event.set()
-        conn, client = self.sock.accept()
+            conn, client = self.sock.accept()
-        self.buffer = ""
+            self.buffer = ""
-        # collect data until quit message is seen
+            # collect data until quit message is seen
-        while SERVER_QUIT not in self.buffer:
+            while SERVER_QUIT not in self.buffer:
-            data = conn.recv(1)
+                data = conn.recv(1)
-            if not data:
+                if not data:
-                break
+                    break
-            self.buffer = self.buffer + data
+                self.buffer = self.buffer + data
 
-        # remove the SERVER_QUIT message
+            # remove the SERVER_QUIT message
-        self.buffer = self.buffer.replace(SERVER_QUIT, '')
+            self.buffer = self.buffer.replace(SERVER_QUIT, '')
 
-        if self.start_resend_event:
+            if self.start_resend_event:
-            self.start_resend_event.wait()
+                self.start_resend_event.wait()
 
-        # re-send entire set of collected data
+            # re-send entire set of collected data
-        try:
+            try:
-            # this may fail on some tests, such as test_close_when_done, since
+                # this may fail on some tests, such as test_close_when_done, since
-            # the client closes the channel when it's done sending
+                # the client closes the channel when it's done sending
-            while self.buffer:
+                while self.buffer:
-                n = conn.send(self.buffer[:self.chunk_size])
+                    n = conn.send(self.buffer[:self.chunk_size])
-                time.sleep(0.001)
+                    time.sleep(0.001)
-                self.buffer = self.buffer[n:]
+                    self.buffer = self.buffer[n:]
-        except:
+            except:
+                pass
+
+            conn.close()
+            self.sock.close()
+
+    class echo_client(asynchat.async_chat):
+
+        def __init__(self, terminator, server_port):
+            asynchat.async_chat.__init__(self)
+            self.contents = []
+            self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.connect((HOST, server_port))
+            self.set_terminator(terminator)
+            self.buffer = ''
+
+        def handle_connect(self):
             pass
 
-        conn.close()
+        if sys.platform == 'darwin':
-        self.sock.close()
+            # select.poll returns a select.POLLHUP at the end of the tests
+            # on darwin, so just ignore it
+            def handle_expt(self):
+                pass
 
-class echo_client(asynchat.async_chat):
+        def collect_incoming_data(self, data):
+            self.buffer += data
 
-    def __init__(self, terminator, server_port):
+        def found_terminator(self):
-        asynchat.async_chat.__init__(self)
+            self.contents.append(self.buffer)
-        self.contents = []
+            self.buffer = ""
-        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.connect((HOST, server_port))
-        self.set_terminator(terminator)
-        self.buffer = ''
-
-    def handle_connect(self):
-        pass
-
-    if sys.platform == 'darwin':
-        # select.poll returns a select.POLLHUP at the end of the tests
-        # on darwin, so just ignore it
-        def handle_expt(self):
-            pass
-
-    def collect_incoming_data(self, data):
-        self.buffer += data
-
-    def found_terminator(self):
-        self.contents.append(self.buffer)
-        self.buffer = ""
 
 
-def start_echo_server():
+    def start_echo_server():
-    event = threading.Event()
+        event = threading.Event()
-    s = echo_server(event)
+        s = echo_server(event)
-    s.start()
+        s.start()
-    event.wait()
+        event.wait()
-    event.clear()
+        event.clear()
-    time.sleep(0.01) # Give server time to start accepting.
+        time.sleep(0.01) # Give server time to start accepting.
-    return s, event
+        return s, event
 
 
+@unittest.skipUnless(threading, 'Threading required for this test.')
 class TestAsynchat(unittest.TestCase):
     usepoll = False