FM / test

/usr/lib/python3/dist-packages/twisted/internet/test/

/usr/lib/python3/dist-packages/twisted/internet/test

Name	Size	Mode	Actions
fake_CAs/	-	0755	rm
__pycache__/	-	0755	rm
connectionmixins.py	20442	0644	edit dl rm
fakeendpoint.py	1555	0644	edit dl rm
modulehelpers.py	1726	0644	edit dl rm
process_cli.py	664	0644	edit dl rm
process_connectionlost.py	119	0644	edit dl rm
process_gireactornocompat.py	721	0644	edit dl rm
process_helper.py	1081	0644	edit dl rm
reactormixins.py	14054	0644	edit dl rm
test_abstract.py	2032	0644	edit dl rm
test_address.py	8598	0644	edit dl rm
test_asyncioreactor.py	1331	0644	edit dl rm
test_base.py	13369	0644	edit dl rm
test_baseprocess.py	2613	0644	edit dl rm
test_core.py	11262	0644	edit dl rm
test_coroutines.py	1787	0644	edit dl rm
test_default.py	3540	0644	edit dl rm
test_endpoints.py	148723	0644	edit dl rm
test_epollreactor.py	7336	0644	edit dl rm
test_fdset.py	13501	0644	edit dl rm
test_filedescriptor.py	2808	0644	edit dl rm
test_gireactor.py	9042	0644	edit dl rm
test_glibbase.py	2284	0644	edit dl rm
test_inlinecb.py	11599	0644	edit dl rm
test_inotify.py	16686	0644	edit dl rm
test_iocp.py	5170	0644	edit dl rm
test_kqueuereactor.py	1916	0644	edit dl rm
test_main.py	1436	0644	edit dl rm
test_newtls.py	6693	0644	edit dl rm
test_pollingfile.py	1278	0644	edit dl rm
test_posixbase.py	9536	0644	edit dl rm
test_posixprocess.py	11166	0644	edit dl rm
test_process.py	32045	0644	edit dl rm
test_protocol.py	18727	0644	edit dl rm
test_resolver.py	20047	0644	edit dl rm
test_serialport.py	1948	0644	edit dl rm
test_sigchld.py	3935	0644	edit dl rm
test_socket.py	9329	0644	edit dl rm
test_stdio.py	6449	0644	edit dl rm
test_tcp.py	108446	0644	edit dl rm
test_threads.py	8582	0644	edit dl rm
test_time.py	3717	0644	edit dl rm
test_tls.py	13459	0644	edit dl rm
test_udp.py	17140	0644	edit dl rm
test_udp_internals.py	4909	0644	edit dl rm
test_unix.py	35712	0644	edit dl rm
test_win32events.py	6500	0644	edit dl rm
test_win32serialport.py	5282	0644	edit dl rm
_awaittests.py.3only	6180	0644	edit dl rm
_posixifaces.py	4689	0644	edit dl rm
_win32ifaces.py	3883	0644	edit dl rm
_yieldfromtests.py.3only	4338	0644	edit dl rm
__init__.py	112	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/twisted/internet/test/test_gireactor.py (9042B)

# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
GI/GTK3 reactor tests.
"""

from __future__ import division, absolute_import, print_function

import sys, os
try:
    from twisted.internet import gireactor
    from gi.repository import Gio
except ImportError:
    gireactor = None
    gtk3reactor = None
else:
    # gtk3reactor may be unavailable even if gireactor is available; in
    # particular in pygobject 3.4/gtk 3.6, when no X11 DISPLAY is found.
    try:
        from twisted.internet import gtk3reactor
    except ImportError:
        gtk3reactor = None
    else:
        from gi.repository import Gtk

from twisted.python.filepath import FilePath
from twisted.python.runtime import platform
from twisted.internet.defer import Deferred
from twisted.internet.error import ReactorAlreadyRunning
from twisted.internet.protocol import ProcessProtocol
from twisted.trial.unittest import TestCase, SkipTest
from twisted.internet.test.reactormixins import ReactorBuilder
from twisted.test.test_twisted import SetAsideModule
from twisted.internet.interfaces import IReactorProcess
from twisted.python.compat import _PY3

# Skip all tests if gi is unavailable:
if gireactor is None:
    skip = "gtk3/gi not importable"

class GApplicationRegistrationTests(ReactorBuilder, TestCase):
    """
    GtkApplication and GApplication are supported by
    L{twisted.internet.gtk3reactor} and L{twisted.internet.gireactor}.

We inherit from L{ReactorBuilder} in order to use some of its
    reactor-running infrastructure, but don't need its test-creation
    functionality.
    """
    def runReactor(self, app, reactor):
        """
        Register the app, run the reactor, make sure app was activated, and
        that reactor was running, and that reactor can be stopped.
        """
        if not hasattr(app, "quit"):
            raise SkipTest("Version of PyGObject is too old.")

result = []
        def stop():
            result.append("stopped")
            reactor.stop()
        def activate(widget):
            result.append("activated")
            reactor.callLater(0, stop)
        app.connect('activate', activate)

# We want reactor.stop() to *always* stop the event loop, even if
        # someone has called hold() on the application and never done the
        # corresponding release() -- for more details see
        # http://developer.gnome.org/gio/unstable/GApplication.html.
        app.hold()

reactor.registerGApplication(app)
        ReactorBuilder.runReactor(self, reactor)
        self.assertEqual(result, ["activated", "stopped"])

def test_gApplicationActivate(self):
        """
        L{Gio.Application} instances can be registered with a gireactor.
        """
        reactor = gireactor.GIReactor(useGtk=False)
        self.addCleanup(self.unbuildReactor, reactor)
        app = Gio.Application(
            application_id='com.twistedmatrix.trial.gireactor',
            flags=Gio.ApplicationFlags.FLAGS_NONE)

self.runReactor(app, reactor)

def test_gtkApplicationActivate(self):
        """
        L{Gtk.Application} instances can be registered with a gtk3reactor.
        """
        reactor = gtk3reactor.Gtk3Reactor()
        self.addCleanup(self.unbuildReactor, reactor)
        app = Gtk.Application(
            application_id='com.twistedmatrix.trial.gtk3reactor',
            flags=Gio.ApplicationFlags.FLAGS_NONE)

self.runReactor(app, reactor)

if gtk3reactor is None:
        test_gtkApplicationActivate.skip = (
            "Gtk unavailable (may require running with X11 DISPLAY env set)")

def test_portable(self):
        """
        L{gireactor.PortableGIReactor} doesn't support application
        registration at this time.
        """
        reactor = gireactor.PortableGIReactor()
        self.addCleanup(self.unbuildReactor, reactor)
        app = Gio.Application(
            application_id='com.twistedmatrix.trial.gireactor',
            flags=Gio.ApplicationFlags.FLAGS_NONE)
        self.assertRaises(NotImplementedError,
                          reactor.registerGApplication, app)

def test_noQuit(self):
        """
        Older versions of PyGObject lack C{Application.quit}, and so won't
        allow registration.
        """
        reactor = gireactor.GIReactor(useGtk=False)
        self.addCleanup(self.unbuildReactor, reactor)
        # An app with no "quit" method:
        app = object()
        exc = self.assertRaises(RuntimeError, reactor.registerGApplication, app)
        self.assertTrue(exc.args[0].startswith(
                "Application registration is not"))

def test_cantRegisterAfterRun(self):
        """
        It is not possible to register a C{Application} after the reactor has
        already started.
        """
        reactor = gireactor.GIReactor(useGtk=False)
        self.addCleanup(self.unbuildReactor, reactor)
        app = Gio.Application(
            application_id='com.twistedmatrix.trial.gireactor',
            flags=Gio.ApplicationFlags.FLAGS_NONE)

def tryRegister():
            exc = self.assertRaises(ReactorAlreadyRunning,
                                    reactor.registerGApplication, app)
            self.assertEqual(exc.args[0],
                             "Can't register application after reactor was started.")
            reactor.stop()
        reactor.callLater(0, tryRegister)
        ReactorBuilder.runReactor(self, reactor)

def test_cantRegisterTwice(self):
        """
        It is not possible to register more than one C{Application}.
        """
        reactor = gireactor.GIReactor(useGtk=False)
        self.addCleanup(self.unbuildReactor, reactor)
        app = Gio.Application(
            application_id='com.twistedmatrix.trial.gireactor',
            flags=Gio.ApplicationFlags.FLAGS_NONE)
        reactor.registerGApplication(app)
        app2 = Gio.Application(
            application_id='com.twistedmatrix.trial.gireactor2',
            flags=Gio.ApplicationFlags.FLAGS_NONE)
        exc = self.assertRaises(RuntimeError,
                                    reactor.registerGApplication, app2)
        self.assertEqual(exc.args[0],
                         "Can't register more than one application instance.")

class PygtkCompatibilityTests(TestCase):
    """
    pygtk imports are either prevented, or a compatibility layer is used if
    possible.
    """
    def test_noCompatibilityLayer(self):
        """
        If no compatibility layer is present, imports of gobject and friends
        are disallowed.

We do this by running a process where we make sure gi.pygtkcompat
        isn't present.
        """
        if _PY3:
            raise SkipTest("Python3 always has the compatibility layer.")

from twisted.internet import reactor
        if not IReactorProcess.providedBy(reactor):
            raise SkipTest("No process support available in this reactor.")

result = Deferred()
        class Stdout(ProcessProtocol):
            data = b""

def errReceived(self, err):
                print(err)

def outReceived(self, data):
                self.data += data

def processExited(self, reason):
                result.callback(self.data)

path = FilePath(__file__).sibling(b"process_gireactornocompat.py").path
        pyExe = FilePath(sys.executable)._asBytesPath()
        # Pass in a PYTHONPATH that is the test runner's os.path, to make sure
        # we're running from a checkout
        reactor.spawnProcess(Stdout(), pyExe, [pyExe, path],
                             env={"PYTHONPATH": ":".join(sys.path)})
        result.addCallback(self.assertEqual, b"success")
        return result

def test_compatibilityLayer(self):
        """
        If compatibility layer is present, importing gobject uses the gi
        compatibility layer.
        """
        if "gi.pygtkcompat" not in sys.modules:
            raise SkipTest("This version of gi doesn't include pygtkcompat.")
        import gobject
        self.assertTrue(gobject.__name__.startswith("gi."))

class Gtk3ReactorTests(TestCase):
    """
    Tests for L{gtk3reactor}.
    """

def test_requiresDISPLAY(self):
        """
        On X11, L{gtk3reactor} is unimportable if the C{DISPLAY} environment
        variable is not set.
        """
        display = os.environ.get("DISPLAY", None)
        if display is not None:
            self.addCleanup(os.environ.__setitem__, "DISPLAY", display)
            del os.environ["DISPLAY"]
        with SetAsideModule("twisted.internet.gtk3reactor"):
            exc = self.assertRaises(ImportError,
                                    __import__, "twisted.internet.gtk3reactor")
            self.assertEqual(
                exc.args[0],
                "Gtk3 requires X11, and no DISPLAY environment variable is set")

if platform.getType() != "posix" or platform.isMacOSX():
        test_requiresDISPLAY.skip = "This test is only relevant when using X11"

cmd: