17.12

2019-12-17 14:09:10 +01:00
parent 66e908fc8a
commit 4791d00a43
2122 changed files with 423791 additions and 0 deletions
@@ -0,0 +1,61 @@
+# Copyright (c) Twisted Matrix Laboratories.
+# See LICENSE for details.
+
+"""
+Test cases for convenience functionality in L{twisted._threads._convenience}.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+from twisted.trial.unittest import SynchronousTestCase
+
+from .._convenience import Quit
+from .._ithreads import AlreadyQuit
+
+
+class QuitTests(SynchronousTestCase):
+    """
+    Tests for L{Quit}
+    """
+
+    def test_isInitiallySet(self):
+        """
+        L{Quit.isSet} starts as L{False}.
+        """
+        quit = Quit()
+        self.assertEqual(quit.isSet, False)
+
+
+    def test_setSetsSet(self):
+        """
+        L{Quit.set} sets L{Quit.isSet} to L{True}.
+        """
+        quit = Quit()
+        quit.set()
+        self.assertEqual(quit.isSet, True)
+
+
+    def test_checkDoesNothing(self):
+        """
+        L{Quit.check} initially does nothing and returns L{None}.
+        """
+        quit = Quit()
+        self.assertIs(quit.check(), None)
+
+
+    def test_checkAfterSetRaises(self):
+        """
+        L{Quit.check} raises L{AlreadyQuit} if L{Quit.set} has been called.
+        """
+        quit = Quit()
+        quit.set()
+        self.assertRaises(AlreadyQuit, quit.check)
+
+
+    def test_setTwiceRaises(self):
+        """
+        L{Quit.set} raises L{AlreadyQuit} if it has been called previously.
+        """
+        quit = Quit()
+        quit.set()
+        self.assertRaises(AlreadyQuit, quit.set)
@@ -0,0 +1,65 @@
+# Copyright (c) Twisted Matrix Laboratories.
+# See LICENSE for details.
+
+"""
+Tests for L{twisted._threads._memory}.
+"""
+from __future__ import absolute_import, division, print_function
+
+from zope.interface.verify import verifyObject
+
+from twisted.trial.unittest import SynchronousTestCase
+from .. import AlreadyQuit, IWorker, createMemoryWorker
+
+
+class MemoryWorkerTests(SynchronousTestCase):
+    """
+    Tests for L{MemoryWorker}.
+    """
+
+    def test_createWorkerAndPerform(self):
+        """
+        L{createMemoryWorker} creates an L{IWorker} and a callable that can
+        perform work on it.  The performer returns C{True} if it accomplished
+        useful work.
+        """
+        worker, performer = createMemoryWorker()
+        verifyObject(IWorker, worker)
+        done = []
+        worker.do(lambda: done.append(3))
+        worker.do(lambda: done.append(4))
+        self.assertEqual(done, [])
+        self.assertEqual(performer(), True)
+        self.assertEqual(done, [3])
+        self.assertEqual(performer(), True)
+        self.assertEqual(done, [3, 4])
+
+
+    def test_quitQuits(self):
+        """
+        Calling C{quit} on the worker returned by L{createMemoryWorker} causes
+        its C{do} and C{quit} methods to raise L{AlreadyQuit}; its C{perform}
+        callable will start raising L{AlreadyQuit} when the work already
+        provided to C{do} has been exhausted.
+        """
+        worker, performer = createMemoryWorker()
+        done = []
+        def moreWork():
+            done.append(7)
+        worker.do(moreWork)
+        worker.quit()
+        self.assertRaises(AlreadyQuit, worker.do, moreWork)
+        self.assertRaises(AlreadyQuit, worker.quit)
+        performer()
+        self.assertEqual(done, [7])
+        self.assertEqual(performer(), False)
+
+
+    def test_performWhenNothingToDoYet(self):
+        """
+        The C{perform} callable returned by L{createMemoryWorker} will return
+        no result when there's no work to do yet.  Since there is no work to
+        do, the performer returns C{False}.
+        """
+        worker, performer = createMemoryWorker()
+        self.assertEqual(performer(), False)