text: # -*- 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 SynchronousTestCase, TestCase, SkipTest, FailTest
  
  
  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] # noqa
  
      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] # noqa
  
      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
  