FM / test

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

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

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
cert.pem.no_trailing_newline	1414	0644	edit dl rm
crash_test_dummy.py	543	0644	edit dl rm
iosim.py	17843	0644	edit dl rm
key.pem.no_trailing_newline	1707	0644	edit dl rm
mock_win32process.py	1499	0644	edit dl rm
myrebuilder1.py	158	0644	edit dl rm
myrebuilder2.py	158	0644	edit dl rm
plugin_basic.py	943	0644	edit dl rm
plugin_extra1.py	407	0644	edit dl rm
plugin_extra2.py	579	0644	edit dl rm
process_cmdline.py	162	0644	edit dl rm
process_echoer.py	214	0644	edit dl rm
process_fds.py	945	0644	edit dl rm
process_getargv.py	283	0644	edit dl rm
process_getenv.py	268	0644	edit dl rm
process_linger.py	286	0644	edit dl rm
process_reader.py	188	0644	edit dl rm
process_signal.py	214	0644	edit dl rm
process_stdinreader.py	857	0644	edit dl rm
process_tester.py	1035	0644	edit dl rm
process_tty.py	130	0644	edit dl rm
process_twisted.py	1206	0644	edit dl rm
proto_helpers.py	28687	0644	edit dl rm
raiser.cpython-38-x86_64-linux-gnu.so	23864	0644	edit dl rm
reflect_helper_IE.py	61	0644	edit dl rm
reflect_helper_VE.py	82	0644	edit dl rm
reflect_helper_ZDE.py	47	0644	edit dl rm
server.pem	4444	0644	edit dl rm
ssl_helpers.py	1032	0644	edit dl rm
stdio_test_consumer.py	1216	0644	edit dl rm
stdio_test_halfclose.py	1938	0644	edit dl rm
stdio_test_hostpeer.py	1021	0644	edit dl rm
stdio_test_lastwrite.py	1206	0644	edit dl rm
stdio_test_loseconn.py	1548	0644	edit dl rm
stdio_test_producer.py	1507	0644	edit dl rm
stdio_test_write.py	923	0644	edit dl rm
stdio_test_writeseq.py	915	0644	edit dl rm
testutils.py	5321	0644	edit dl rm
test_abstract.py	3497	0644	edit dl rm
test_adbapi.py	26148	0644	edit dl rm
test_amp.py	110553	0644	edit dl rm
test_application.py	32816	0644	edit dl rm
test_compat.py	29278	0644	edit dl rm
test_context.py	1515	0644	edit dl rm
test_cooperator.py	21467	0644	edit dl rm
test_defer.py	103407	0644	edit dl rm
test_defgen.py	10701	0644	edit dl rm
test_dict.py	1442	0644	edit dl rm
test_dirdbm.py	6695	0644	edit dl rm
test_error.py	8593	0644	edit dl rm
test_factories.py	4637	0644	edit dl rm
test_failure.py	32288	0644	edit dl rm
test_fdesc.py	7371	0644	edit dl rm
test_finger.py	1997	0644	edit dl rm
test_formmethod.py	3645	0644	edit dl rm
test_ftp.py	130321	0644	edit dl rm
test_ftp_options.py	2685	0644	edit dl rm
test_htb.py	3190	0644	edit dl rm
test_ident.py	7015	0644	edit dl rm
test_internet.py	46422	0644	edit dl rm
test_iosim.py	9060	0644	edit dl rm
test_iutils.py	13445	0644	edit dl rm
test_lockfile.py	15506	0644	edit dl rm
test_log.py	36330	0644	edit dl rm
test_logfile.py	18227	0644	edit dl rm
test_loopback.py	14486	0644	edit dl rm
test_main.py	2501	0644	edit dl rm
test_memcache.py	25143	0644	edit dl rm
test_modules.py	17888	0644	edit dl rm
test_monkey.py	5637	0644	edit dl rm
test_nooldstyle.py	5955	0644	edit dl rm
test_paths.py	74357	0644	edit dl rm
test_pcp.py	12551	0644	edit dl rm
test_persisted.py	14624	0644	edit dl rm
test_plugin.py	26113	0644	edit dl rm
test_policies.py	33499	0644	edit dl rm
test_postfix.py	4243	0644	edit dl rm
test_process.py	86120	0644	edit dl rm
test_protocols.py	7450	0644	edit dl rm
test_randbytes.py	3357	0644	edit dl rm
test_rebuild.py	8495	0644	edit dl rm
test_reflect.py	26085	0644	edit dl rm
test_roots.py	1812	0644	edit dl rm
test_shortcut.py	1991	0644	edit dl rm
test_sip.py	25284	0644	edit dl rm
test_sob.py	5632	0644	edit dl rm
test_socks.py	17738	0644	edit dl rm
test_ssl.py	23846	0644	edit dl rm
test_sslverify.py	113322	0644	edit dl rm
test_stateful.py	2021	0644	edit dl rm
test_stdio.py	13156	0644	edit dl rm
test_strerror.py	5183	0644	edit dl rm
test_stringtransport.py	13264	0644	edit dl rm
test_strports.py	1797	0644	edit dl rm
test_task.py	39326	0644	edit dl rm
test_tcp.py	65820	0644	edit dl rm
test_tcp_internals.py	13117	0644	edit dl rm
test_text.py	6456	0644	edit dl rm
test_threadable.py	3738	0644	edit dl rm
test_threadpool.py	22204	0644	edit dl rm
test_threads.py	13268	0644	edit dl rm
test_tpfile.py	1601	0644	edit dl rm
test_twistd.py	74201	0644	edit dl rm
test_twisted.py	11173	0644	edit dl rm
test_udp.py	24676	0644	edit dl rm
test_unix.py	15157	0644	edit dl rm
test_usage.py	23645	0644	edit dl rm
__init__.py	103	0644	edit dl rm

Edit: /usr/lib/python3/dist-packages/twisted/test/test_iosim.py (9060B)

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

"""
Tests for L{twisted.test.iosim}.
"""

from __future__ import absolute_import, division

from zope.interface import implementer

from twisted.internet.interfaces import IPushProducer
from twisted.internet.protocol import Protocol

from twisted.test.iosim import FakeTransport, connect
from twisted.trial.unittest import TestCase

class FakeTransportTests(TestCase):
    """
    Tests for L{FakeTransport}.
    """

def test_connectionSerial(self):
        """
        Each L{FakeTransport} receives a serial number that uniquely identifies
        it.
        """
        a = FakeTransport(object(), True)
        b = FakeTransport(object(), False)
        self.assertIsInstance(a.serial, int)
        self.assertIsInstance(b.serial, int)
        self.assertNotEqual(a.serial, b.serial)

def test_writeSequence(self):
        """
        L{FakeTransport.writeSequence} will write a sequence of L{bytes} to the
        transport.
        """
        a = FakeTransport(object(), False)

a.write(b"a")
        a.writeSequence([b"b", b"c", b"d"])

self.assertEqual(b"".join(a.stream), b"abcd")

def test_writeAfterClose(self):
        """
        L{FakeTransport.write} will accept writes after transport was closed,
        but the data will be silently discarded.
        """
        a = FakeTransport(object(), False)
        a.write(b"before")
        a.loseConnection()
        a.write(b"after")

self.assertEqual(b"".join(a.stream), b"before")

@implementer(IPushProducer)
class StrictPushProducer(object):
    """
    An L{IPushProducer} implementation which produces nothing but enforces
    preconditions on its state transition methods.
    """
    _state = u"running"

def stopProducing(self):
        if self._state == u"stopped":
            raise ValueError(u"Cannot stop already-stopped IPushProducer")
        self._state = u"stopped"

def pauseProducing(self):
        if self._state != u"running":
            raise ValueError(
                u"Cannot pause {} IPushProducer".format(self._state)
            )
        self._state = u"paused"

def resumeProducing(self):
        if self._state != u"paused":
            raise ValueError(
                u"Cannot resume {} IPushProducer".format(self._state)
            )
        self._state = u"running"

class StrictPushProducerTests(TestCase):
    """
    Tests for L{StrictPushProducer}.
    """
    def _initial(self):
        """
        @return: A new L{StrictPushProducer} which has not been through any state
            changes.
        """
        return StrictPushProducer()

def _stopped(self):
        """
        @return: A new, stopped L{StrictPushProducer}.
        """
        producer = StrictPushProducer()
        producer.stopProducing()
        return producer

def _paused(self):
        """
        @return: A new, paused L{StrictPushProducer}.
        """
        producer = StrictPushProducer()
        producer.pauseProducing()
        return producer

def _resumed(self):
        """
        @return: A new L{StrictPushProducer} which has been paused and resumed.
        """
        producer = StrictPushProducer()
        producer.pauseProducing()
        producer.resumeProducing()
        return producer

def assertStopped(self, producer):
        """
        Assert that the given producer is in the stopped state.

@param producer: The producer to verify.
        @type producer: L{StrictPushProducer}
        """
        self.assertEqual(producer._state, u"stopped")

def assertPaused(self, producer):
        """
        Assert that the given producer is in the paused state.

@param producer: The producer to verify.
        @type producer: L{StrictPushProducer}
        """
        self.assertEqual(producer._state, u"paused")

def assertRunning(self, producer):
        """
        Assert that the given producer is in the running state.

@param producer: The producer to verify.
        @type producer: L{StrictPushProducer}
        """
        self.assertEqual(producer._state, u"running")

def test_stopThenStop(self):
        """
        L{StrictPushProducer.stopProducing} raises L{ValueError} if called when
        the producer is stopped.
        """
        self.assertRaises(ValueError, self._stopped().stopProducing)

def test_stopThenPause(self):
        """
        L{StrictPushProducer.pauseProducing} raises L{ValueError} if called when
        the producer is stopped.
        """
        self.assertRaises(ValueError, self._stopped().pauseProducing)

def test_stopThenResume(self):
        """
        L{StrictPushProducer.resumeProducing} raises L{ValueError} if called when
        the producer is stopped.
        """
        self.assertRaises(ValueError, self._stopped().resumeProducing)

def test_pauseThenStop(self):
        """
        L{StrictPushProducer} is stopped if C{stopProducing} is called on a paused
        producer.
        """
        producer = self._paused()
        producer.stopProducing()
        self.assertStopped(producer)

def test_pauseThenPause(self):
        """
        L{StrictPushProducer.pauseProducing} raises L{ValueError} if called on a
        paused producer.
        """
        producer = self._paused()
        self.assertRaises(ValueError, producer.pauseProducing)

def test_pauseThenResume(self):
        """
        L{StrictPushProducer} is resumed if C{resumeProducing} is called on a
        paused producer.
        """
        producer = self._paused()
        producer.resumeProducing()
        self.assertRunning(producer)

def test_resumeThenStop(self):
        """
        L{StrictPushProducer} is stopped if C{stopProducing} is called on a
        resumed producer.
        """
        producer = self._resumed()
        producer.stopProducing()
        self.assertStopped(producer)

def test_resumeThenPause(self):
        """
        L{StrictPushProducer} is paused if C{pauseProducing} is called on a
        resumed producer.
        """
        producer = self._resumed()
        producer.pauseProducing()
        self.assertPaused(producer)

def test_resumeThenResume(self):
        """
        L{StrictPushProducer.resumeProducing} raises L{ValueError} if called on a
        resumed producer.
        """
        producer = self._resumed()
        self.assertRaises(ValueError, producer.resumeProducing)

def test_stop(self):
        """
        L{StrictPushProducer} is stopped if C{stopProducing} is called in the
        initial state.
        """
        producer = self._initial()
        producer.stopProducing()
        self.assertStopped(producer)

def test_pause(self):
        """
        L{StrictPushProducer} is paused if C{pauseProducing} is called in the
        initial state.
        """
        producer = self._initial()
        producer.pauseProducing()
        self.assertPaused(producer)

def test_resume(self):
        """
        L{StrictPushProducer} raises L{ValueError} if C{resumeProducing} is called
        in the initial state.
        """
        producer = self._initial()
        self.assertRaises(ValueError, producer.resumeProducing)

class IOPumpTests(TestCase):
    """
    Tests for L{IOPump}.
    """
    def _testStreamingProducer(self, mode):
        """
        Connect a couple protocol/transport pairs to an L{IOPump} and then pump
        it.  Verify that a streaming producer registered with one of the
        transports does not receive invalid L{IPushProducer} method calls and
        ends in the right state.

@param mode: C{u"server"} to test a producer registered with the
            server transport.  C{u"client"} to test a producer registered with
            the client transport.
        """
        serverProto = Protocol()
        serverTransport = FakeTransport(serverProto, isServer=True)

clientProto = Protocol()
        clientTransport = FakeTransport(clientProto, isServer=False)

pump = connect(
            serverProto, serverTransport,
            clientProto, clientTransport,
            greet=False,
        )

producer = StrictPushProducer()
        victim = {
            u"server": serverTransport,
            u"client": clientTransport,
        }[mode]
        victim.registerProducer(producer, streaming=True)

pump.pump()
        self.assertEqual(u"running", producer._state)

def test_serverStreamingProducer(self):
        """
        L{IOPump.pump} does not call C{resumeProducing} on a L{IPushProducer}
        (stream producer) registered with the server transport.
        """
        self._testStreamingProducer(mode=u"server")

def test_clientStreamingProducer(self):
        """
        L{IOPump.pump} does not call C{resumeProducing} on a L{IPushProducer}
        (stream producer) registered with the client transport.
        """
        self._testStreamingProducer(mode=u"client")

cmd: