aDriv4 - MANAGER

Edit File: erroneous.py

# -*- test-case-name: twisted.trial.test.test_tests -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Definitions of test cases with various interesting error-related behaviors, to
be used by test modules to exercise different features of trial's test runner.

See the L{twisted.trial.test.test_tests} module docstring for details about how
this code is arranged.

Some of these tests are also used by L{twisted.trial._dist.test}.
"""

from unittest import skipIf

from twisted.internet import defer, protocol, reactor
from twisted.internet.task import deferLater
from twisted.trial import unittest, util

class FoolishError(Exception):
    pass

class LargeError(Exception):
    """
    An exception which has a string representation of at least a specified
    number of characters.
    """

def __init__(self, minSize: int) -> None:
        Exception.__init__(self)
        self.minSize = minSize

def __str__(self):
        large = "x" * self.minSize
        return f"LargeError<I fail: {large}>"

class FailureInSetUpMixin:
    def setUp(self):
        raise FoolishError("I am a broken setUp method")

def test_noop(self):
        pass

class SynchronousTestFailureInSetUp(FailureInSetUpMixin, unittest.SynchronousTestCase):
    pass

class AsynchronousTestFailureInSetUp(FailureInSetUpMixin, unittest.TestCase):
    pass

class FailureInTearDownMixin:
    def tearDown(self):
        raise FoolishError("I am a broken tearDown method")

def test_noop(self):
        pass

class SynchronousTestFailureInTearDown(
    FailureInTearDownMixin, unittest.SynchronousTestCase
):
    pass

class AsynchronousTestFailureInTearDown(FailureInTearDownMixin, unittest.TestCase):
    pass

class FailureButTearDownRunsMixin:
    """
    A test fails, but its L{tearDown} still runs.
    """

tornDown = False

def tearDown(self):
        self.tornDown = True

def test_fails(self):
        """
        A test that fails.
        """
        raise FoolishError("I am a broken test")

class SynchronousTestFailureButTearDownRuns(
    FailureButTearDownRunsMixin, unittest.SynchronousTestCase
):
    pass

class AsynchronousTestFailureButTearDownRuns(
    FailureButTearDownRunsMixin, unittest.TestCase
):
    pass

class TestRegularFail(unittest.SynchronousTestCase):
    def test_fail(self):
        self.fail("I fail")

def test_subfail(self):
        self.subroutine()

def subroutine(self):
        self.fail("I fail inside")

class TestAsynchronousFail(unittest.TestCase):
    """
    Test failures for L{unittest.TestCase} based classes.
    """

text = "I fail"

def test_fail(self) -> defer.Deferred[None]:
        """
        A test which fails in the callback of the returned L{defer.Deferred}.
        """
        return deferLater(reactor, 0, self.fail, "I fail later")  # type: ignore[arg-type]

def test_failGreaterThan64k(self) -> defer.Deferred[None]:
        """
        A test which fails in the callback of the returned L{defer.Deferred}
        with a very long string.
        """
        return deferLater(reactor, 0, self.fail, "I fail later: " + "x" * 2**16)  # type: ignore[arg-type]

def test_exception(self) -> None:
        """
        A test which raises an exception synchronously.
        """
        raise Exception(self.text)

def test_exceptionGreaterThan64k(self) -> None:
        """
        A test which raises an exception with a long string representation
        synchronously.
        """
        raise LargeError(2**16)

def test_exceptionGreaterThan64kEncoded(self) -> None:
        """
        A test which synchronously raises an exception with a long string
        representation including non-ascii content.
        """
        # The exception text itself is not greater than 64k but SNOWMAN
        # encodes to 3 bytes with UTF-8 so the length of the UTF-8 encoding of
        # the string representation of this exception will be greater than 2
        # ** 16.
        raise Exception("\N{SNOWMAN}" * 2**15)

class ErrorTest(unittest.SynchronousTestCase):
    """
    A test case which has a L{test_foo} which will raise an error.

@ivar ran: boolean indicating whether L{test_foo} has been run.
    """

ran = False

def test_foo(self):
        """
        Set C{self.ran} to True and raise a C{ZeroDivisionError}
        """
        self.ran = True
        1 / 0

@skipIf(True, "skipping this test")
class TestSkipTestCase(unittest.SynchronousTestCase):
    pass

class DelayedCall(unittest.TestCase):
    hiddenExceptionMsg = "something blew up"

def go(self):
        raise RuntimeError(self.hiddenExceptionMsg)

def testHiddenException(self):
        """
        What happens if an error is raised in a DelayedCall and an error is
        also raised in the test?

L{test_reporter.ErrorReportingTests.testHiddenException} checks that
        both errors get reported.

Note that this behaviour is deprecated. A B{real} test would return a
        Deferred that got triggered by the callLater. This would guarantee the
        delayed call error gets reported.
        """
        reactor.callLater(0, self.go)
        reactor.iterate(0.01)
        self.fail("Deliberate failure to mask the hidden exception")

testHiddenException.suppress = [  # type: ignore[attr-defined]
        util.suppress(
            message=r"reactor\.iterate cannot be used.*", category=DeprecationWarning
        )
    ]

class ReactorCleanupTests(unittest.TestCase):
    def test_leftoverPendingCalls(self):
        def _():
            print("foo!")

reactor.callLater(10000.0, _)

class SocketOpenTest(unittest.TestCase):
    def test_socketsLeftOpen(self):
        f = protocol.Factory()
        f.protocol = protocol.Protocol
        reactor.listenTCP(0, f)

class TimingOutDeferred(unittest.TestCase):
    def test_alpha(self):
        pass

def test_deferredThatNeverFires(self):
        self.methodCalled = True
        d = defer.Deferred()
        return d

def test_omega(self):
        pass

def unexpectedException(self):
    """i will raise an unexpected exception...
    ... *CAUSE THAT'S THE KINDA GUY I AM*

>>> 1/0
    """

class EventuallyFailingTestCase(unittest.SynchronousTestCase):
    """
    A test suite that fails after it is run a few times.
    """

n: int = 0

def test_it(self):
        """
        Run successfully a few times and then fail forever after.
        """
        self.n += 1
        if self.n >= 5:
            self.fail("eventually failing")