%PDF-
%PDF-
Mini Shell
Mini Shell
# -*- test-case-name: twisted.trial.test.test_tests -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
Definitions of test cases with various interesting behaviors, to be used by
L{twisted.trial.test.test_tests} and other 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.
"""
from twisted.trial.unittest import FailTest, SkipTest, SynchronousTestCase, TestCase
class SkippingMixin:
def test_skip1(self):
raise SkipTest("skip1")
def test_skip2(self):
raise RuntimeError("I should not get raised")
test_skip2.skip = "skip2" # type: ignore[attr-defined]
def test_skip3(self):
self.fail("I should not fail")
test_skip3.skip = "skip3" # type: ignore[attr-defined]
class SynchronousSkipping(SkippingMixin, SynchronousTestCase):
pass
class AsynchronousSkipping(SkippingMixin, TestCase):
pass
class SkippingSetUpMixin:
def setUp(self):
raise SkipTest("skipSetUp")
def test_1(self):
pass
def test_2(self):
pass
class SynchronousSkippingSetUp(SkippingSetUpMixin, SynchronousTestCase):
pass
class AsynchronousSkippingSetUp(SkippingSetUpMixin, TestCase):
pass
class DeprecatedReasonlessSkipMixin:
def test_1(self):
raise SkipTest()
class SynchronousDeprecatedReasonlessSkip(
DeprecatedReasonlessSkipMixin, SynchronousTestCase
):
pass
class AsynchronousDeprecatedReasonlessSkip(DeprecatedReasonlessSkipMixin, TestCase):
pass
class SkippedClassMixin:
skip = "class"
def setUp(self):
self.__class__._setUpRan = True
def test_skip1(self):
raise SkipTest("skip1")
def test_skip2(self):
raise RuntimeError("Ought to skip me")
test_skip2.skip = "skip2" # type: ignore
def test_skip3(self):
pass
def test_skip4(self):
raise RuntimeError("Skip me too")
class SynchronousSkippedClass(SkippedClassMixin, SynchronousTestCase):
pass
class AsynchronousSkippedClass(SkippedClassMixin, TestCase):
pass
class TodoMixin:
def test_todo1(self):
self.fail("deliberate failure")
test_todo1.todo = "todo1" # type: ignore[attr-defined]
def test_todo2(self):
raise RuntimeError("deliberate error")
test_todo2.todo = "todo2" # type: ignore[attr-defined]
def test_todo3(self):
"""unexpected success"""
test_todo3.todo = "todo3" # type: ignore[attr-defined]
class SynchronousTodo(TodoMixin, SynchronousTestCase):
pass
class AsynchronousTodo(TodoMixin, TestCase):
pass
class SetUpTodoMixin:
def setUp(self):
raise RuntimeError("deliberate error")
def test_todo1(self):
pass
test_todo1.todo = "setUp todo1" # type: ignore[attr-defined]
class SynchronousSetUpTodo(SetUpTodoMixin, SynchronousTestCase):
pass
class AsynchronousSetUpTodo(SetUpTodoMixin, TestCase):
pass
class TearDownTodoMixin:
def tearDown(self):
raise RuntimeError("deliberate error")
def test_todo1(self):
pass
test_todo1.todo = "tearDown todo1" # type: ignore[attr-defined]
class SynchronousTearDownTodo(TearDownTodoMixin, SynchronousTestCase):
pass
class AsynchronousTearDownTodo(TearDownTodoMixin, TestCase):
pass
class TodoClassMixin:
todo = "class"
def test_todo1(self):
pass
test_todo1.todo = "method" # type: ignore[attr-defined]
def test_todo2(self):
pass
def test_todo3(self):
self.fail("Deliberate Failure")
test_todo3.todo = "method" # type: ignore[attr-defined]
def test_todo4(self):
self.fail("Deliberate Failure")
class SynchronousTodoClass(TodoClassMixin, SynchronousTestCase):
pass
class AsynchronousTodoClass(TodoClassMixin, TestCase):
pass
class StrictTodoMixin:
def test_todo1(self):
raise RuntimeError("expected failure")
test_todo1.todo = (RuntimeError, "todo1") # type: ignore[attr-defined]
def test_todo2(self):
raise RuntimeError("expected failure")
test_todo2.todo = ((RuntimeError, OSError), "todo2") # type: ignore[attr-defined]
def test_todo3(self):
raise RuntimeError("we had no idea!")
test_todo3.todo = (OSError, "todo3") # type: ignore[attr-defined]
def test_todo4(self):
raise RuntimeError("we had no idea!")
test_todo4.todo = ((OSError, SyntaxError), "todo4") # type: ignore[attr-defined]
def test_todo5(self):
self.fail("deliberate failure")
test_todo5.todo = (FailTest, "todo5") # type: ignore[attr-defined]
def test_todo6(self):
self.fail("deliberate failure")
test_todo6.todo = (RuntimeError, "todo6") # type: ignore[attr-defined]
def test_todo7(self):
pass
test_todo7.todo = (RuntimeError, "todo7") # type: ignore[attr-defined]
class SynchronousStrictTodo(StrictTodoMixin, SynchronousTestCase):
pass
class AsynchronousStrictTodo(StrictTodoMixin, TestCase):
pass
class AddCleanupMixin:
def setUp(self):
self.log = ["setUp"]
def brokenSetUp(self):
self.log = ["setUp"]
raise RuntimeError("Deliberate failure")
def skippingSetUp(self):
self.log = ["setUp"]
raise SkipTest("Don't do this")
def append(self, thing):
self.log.append(thing)
def tearDown(self):
self.log.append("tearDown")
def runTest(self):
self.log.append("runTest")
class SynchronousAddCleanup(AddCleanupMixin, SynchronousTestCase):
pass
class AsynchronousAddCleanup(AddCleanupMixin, TestCase):
pass
class ExpectedFailure(SynchronousTestCase):
"""
Hold a test that has an expected failure with an exception that has a
large string representation.
"""
def test_expectedFailureGreaterThan64k(self) -> None:
"""
Fail, but expectedly.
"""
raise RuntimeError("x" * (2**16 + 1))
test_expectedFailureGreaterThan64k.todo = "short todo string" # type: ignore[attr-defined]
Zerion Mini Shell 1.0