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_address.py (8598B)

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

from __future__ import division, absolute_import

import os
import socket

from twisted.trial import unittest
from twisted.internet.address import IPv4Address, UNIXAddress, IPv6Address
from twisted.internet.address import HostnameAddress
from twisted.python.compat import nativeString
from twisted.python.runtime import platform

if not platform._supportsSymlinks():
    symlinkSkip = "Platform does not support symlinks"
else:
    symlinkSkip = None

try:
    socket.AF_UNIX
except AttributeError:
    unixSkip = "Platform doesn't support UNIX sockets."
else:
    unixSkip = None

class AddressTestCaseMixin(object):
    def test_addressComparison(self):
        """
        Two different address instances, sharing the same properties are
        considered equal by C{==} and not considered not equal by C{!=}.

Note: When applied via UNIXAddress class, this uses the same
        filename for both objects being compared.
        """
        self.assertTrue(self.buildAddress() == self.buildAddress())
        self.assertFalse(self.buildAddress() != self.buildAddress())

def test_hash(self):
        """
        C{__hash__} can be used to get a hash of an address, allowing
        addresses to be used as keys in dictionaries, for instance.
        """
        addr = self.buildAddress()
        d = {addr: True}
        self.assertTrue(d[self.buildAddress()])

def test_differentNamesComparison(self):
        """
        Check that comparison operators work correctly on address objects
        when a different name is passed in
        """
        self.assertFalse(self.buildAddress() == self.buildDifferentAddress())
        self.assertFalse(self.buildDifferentAddress() == self.buildAddress())

self.assertTrue(self.buildAddress() != self.buildDifferentAddress())
        self.assertTrue(self.buildDifferentAddress() != self.buildAddress())

def assertDeprecations(self, testMethod, message):
        """
        Assert that the a DeprecationWarning with the given message was
        emitted against the given method.
        """
        warnings = self.flushWarnings([testMethod])
        self.assertEqual(warnings[0]['category'], DeprecationWarning)
        self.assertEqual(warnings[0]['message'], message)
        self.assertEqual(len(warnings), 1)

class IPv4AddressTestCaseMixin(AddressTestCaseMixin):
    addressArgSpec = (("type", "%s"), ("host", "%r"), ("port", "%d"))

class HostnameAddressTests(unittest.TestCase, AddressTestCaseMixin):
    """
    Test case for L{HostnameAddress}.
    """
    addressArgSpec = (("hostname", "%s"), ("port", "%d"))

def buildAddress(self):
        """
        Create an arbitrary new L{HostnameAddress} instance.

@return: A L{HostnameAddress} instance.
        """
        return HostnameAddress(b"example.com", 0)

def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a different hostname.

@return: A L{HostnameAddress} instance.
        """
        return HostnameAddress(b"example.net", 0)

class IPv4AddressTCPTests(unittest.SynchronousTestCase,
                          IPv4AddressTestCaseMixin):
    def buildAddress(self):
        """
        Create an arbitrary new L{IPv4Address} instance with a C{"TCP"}
        type.  A new instance is created for each call, but always for the
        same address.
        """
        return IPv4Address("TCP", "127.0.0.1", 0)

def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a different fixed address.
        """
        return IPv4Address("TCP", "127.0.0.2", 0)

class IPv4AddressUDPTests(unittest.SynchronousTestCase,
                          IPv4AddressTestCaseMixin):
    def buildAddress(self):
        """
        Create an arbitrary new L{IPv4Address} instance with a C{"UDP"}
        type.  A new instance is created for each call, but always for the
        same address.
        """
        return IPv4Address("UDP", "127.0.0.1", 0)

def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a different fixed address.
        """
        return IPv4Address("UDP", "127.0.0.2", 0)

class IPv6AddressTests(unittest.SynchronousTestCase, AddressTestCaseMixin):
    addressArgSpec = (("type", "%s"), ("host", "%r"), ("port", "%d"))

def buildAddress(self):
        """
        Create an arbitrary new L{IPv6Address} instance with a C{"TCP"}
        type.  A new instance is created for each call, but always for the
        same address.
        """
        return IPv6Address("TCP", "::1", 0)

def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a different fixed address.
        """
        return IPv6Address("TCP", "::2", 0)

class UNIXAddressTests(unittest.SynchronousTestCase):
    skip = unixSkip
    addressArgSpec = (("name", "%r"),)

def setUp(self):
        self._socketAddress = self.mktemp()
        self._otherAddress = self.mktemp()

def buildAddress(self):
        """
        Create an arbitrary new L{UNIXAddress} instance.  A new instance is
        created for each call, but always for the same address.
        """
        return UNIXAddress(self._socketAddress)

def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a different fixed address.
        """
        return UNIXAddress(self._otherAddress)

def test_repr(self):
        """
        The repr of L{UNIXAddress} returns with the filename that the
        L{UNIXAddress} is for.
        """
        self.assertEqual(repr(self.buildAddress()), "UNIXAddress('%s')" % (
            nativeString(self._socketAddress)))

def test_comparisonOfLinkedFiles(self):
        """
        UNIXAddress objects compare as equal if they link to the same file.
        """
        linkName = self.mktemp()
        with open(self._socketAddress, 'w') as self.fd:
            os.symlink(os.path.abspath(self._socketAddress), linkName)
            self.assertEqual(UNIXAddress(self._socketAddress),
                             UNIXAddress(linkName))
            self.assertEqual(UNIXAddress(linkName),
                             UNIXAddress(self._socketAddress))
    if not unixSkip:
        test_comparisonOfLinkedFiles.skip = symlinkSkip

def test_hashOfLinkedFiles(self):
        """
        UNIXAddress Objects that compare as equal have the same hash value.
        """
        linkName = self.mktemp()
        with open(self._socketAddress, 'w') as self.fd:
            os.symlink(os.path.abspath(self._socketAddress), linkName)
            self.assertEqual(hash(UNIXAddress(self._socketAddress)),
                            hash(UNIXAddress(linkName)))
    if not unixSkip:
        test_hashOfLinkedFiles.skip = symlinkSkip

class EmptyUNIXAddressTests(unittest.SynchronousTestCase,
                            AddressTestCaseMixin):
    """
    Tests for L{UNIXAddress} operations involving a L{None} address.
    """
    skip = unixSkip
    addressArgSpec = (("name", "%r"),)

def setUp(self):
        self._socketAddress = self.mktemp()

def buildAddress(self):
        """
        Create an arbitrary new L{UNIXAddress} instance.  A new instance is
        created for each call, but always for the same address. This builds it
        with a fixed address of L{None}.
        """
        return UNIXAddress(None)

def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a random temporary directory.
        """
        return UNIXAddress(self._socketAddress)

def test_comparisonOfLinkedFiles(self):
        """
        A UNIXAddress referring to a L{None} address does not compare equal to a
        UNIXAddress referring to a symlink.
        """
        linkName = self.mktemp()
        with open(self._socketAddress, 'w') as self.fd:
            os.symlink(os.path.abspath(self._socketAddress), linkName)
            self.assertNotEqual(UNIXAddress(self._socketAddress),
                                UNIXAddress(None))
            self.assertNotEqual(UNIXAddress(None),
                                UNIXAddress(self._socketAddress))
    if not unixSkip:
        test_comparisonOfLinkedFiles.skip = symlinkSkip

def test_emptyHash(self):
        """
        C{__hash__} can be used to get a hash of an address, even one referring
        to L{None} rather than a real path.
        """
        addr = self.buildAddress()
        d = {addr: True}
        self.assertTrue(d[self.buildAddress()])

cmd: