# -*- 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 __future__ import division, absolute_import

from twisted.trial.unittest import (
    SynchronousTestCase, TestCase, SkipTest, FailTest)


class SkippingMixin(object):
    def test_skip1(self):
        raise SkipTest('skip1')

    def test_skip2(self):
        raise RuntimeError("I should not get raised")
    test_skip2.skip = 'skip2'

    def test_skip3(self):
        self.fail('I should not fail')
    test_skip3.skip = 'skip3'



class SynchronousSkipping(SkippingMixin, SynchronousTestCase):
    pass



class AsynchronousSkipping(SkippingMixin, TestCase):
    pass



class SkippingSetUpMixin(object):
    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(object):
    def test_1(self):
        raise SkipTest()



class SynchronousDeprecatedReasonlessSkip(
    DeprecatedReasonlessSkipMixin, SynchronousTestCase):
    pass



class AsynchronousDeprecatedReasonlessSkip(
    DeprecatedReasonlessSkipMixin, TestCase):
    pass



class SkippedClassMixin(object):
    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'
    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(object):
    def test_todo1(self):
        self.fail("deliberate failure")
    test_todo1.todo = "todo1"

    def test_todo2(self):
        raise RuntimeError("deliberate error")
    test_todo2.todo = "todo2"

    def test_todo3(self):
        """unexpected success"""
    test_todo3.todo = 'todo3'




class SynchronousTodo(TodoMixin, SynchronousTestCase):
    pass



class AsynchronousTodo(TodoMixin, TestCase):
    pass



class SetUpTodoMixin(object):
    def setUp(self):
        raise RuntimeError("deliberate error")

    def test_todo1(self):
        pass
    test_todo1.todo = "setUp todo1"



class SynchronousSetUpTodo(SetUpTodoMixin, SynchronousTestCase):
    pass



class AsynchronousSetUpTodo(SetUpTodoMixin, TestCase):
    pass



class TearDownTodoMixin(object):
    def tearDown(self):
        raise RuntimeError("deliberate error")

    def test_todo1(self):
        pass
    test_todo1.todo = "tearDown todo1"



class SynchronousTearDownTodo(TearDownTodoMixin, SynchronousTestCase):
    pass



class AsynchronousTearDownTodo(TearDownTodoMixin, TestCase):
    pass



class TodoClassMixin(object):
    todo = "class"
    def test_todo1(self):
        pass
    test_todo1.todo = "method"
    def test_todo2(self):
        pass
    def test_todo3(self):
        self.fail("Deliberate Failure")
    test_todo3.todo = "method"
    def test_todo4(self):
        self.fail("Deliberate Failure")



class SynchronousTodoClass(TodoClassMixin, SynchronousTestCase):
    pass



class AsynchronousTodoClass(TodoClassMixin, TestCase):
    pass



class StrictTodoMixin(object):
    def test_todo1(self):
        raise RuntimeError("expected failure")
    test_todo1.todo = (RuntimeError, "todo1")

    def test_todo2(self):
        raise RuntimeError("expected failure")
    test_todo2.todo = ((RuntimeError, OSError), "todo2")

    def test_todo3(self):
        raise RuntimeError("we had no idea!")
    test_todo3.todo = (OSError, "todo3")

    def test_todo4(self):
        raise RuntimeError("we had no idea!")
    test_todo4.todo = ((OSError, SyntaxError), "todo4")

    def test_todo5(self):
        self.fail("deliberate failure")
    test_todo5.todo = (FailTest, "todo5")

    def test_todo6(self):
        self.fail("deliberate failure")
    test_todo6.todo = (RuntimeError, "todo6")

    def test_todo7(self):
        pass
    test_todo7.todo = (RuntimeError, "todo7")



class SynchronousStrictTodo(StrictTodoMixin, SynchronousTestCase):
    pass



class AsynchronousStrictTodo(StrictTodoMixin, TestCase):
    pass



class AddCleanupMixin(object):
    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