Gecko [ gandhischool.edu.np ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
__init__.py	130 B	-rw-r--r--
detests.py	5.53 KB	-rw-r--r--
erroneous.py	4.68 KB	-rw-r--r--
mockcustomsuite.py	536 B	-rw-r--r--
mockcustomsuite2.py	533 B	-rw-r--r--
mockcustomsuite3.py	676 B	-rw-r--r--
mockdoctest.py	2.36 KB	-rw-r--r--
moduleself.py	170 B	-rw-r--r--
moduletest.py	302 B	-rw-r--r--
novars.py	182 B	-rw-r--r--
ordertests.py	864 B	-rw-r--r--
packages.py	4.54 KB	-rw-r--r--
sample.py	2.04 KB	-rw-r--r--
scripttest.py	457 B	-rwxr-xr-x
skipping.py	5.58 KB	-rw-r--r--
suppression.py	2.44 KB	-rw-r--r--
test_assertions.py	59.39 KB	-rw-r--r--
test_asyncassertions.py	2.49 KB	-rw-r--r--
test_deferred.py	8.62 KB	-rw-r--r--
test_doctest.py	1.67 KB	-rw-r--r--
test_keyboard.py	3.7 KB	-rw-r--r--
test_loader.py	21.84 KB	-rw-r--r--
test_log.py	7.85 KB	-rw-r--r--
test_output.py	4.9 KB	-rw-r--r--
test_plugins.py	1.43 KB	-rw-r--r--
test_pyunitcompat.py	7.44 KB	-rw-r--r--
test_reporter.py	55.38 KB	-rw-r--r--
test_runner.py	34.22 KB	-rw-r--r--
test_script.py	28.69 KB	-rw-r--r--
test_skip.py	2.59 KB	-rw-r--r--
test_suppression.py	5.77 KB	-rw-r--r--
test_testcase.py	1.94 KB	-rw-r--r--
test_tests.py	48.34 KB	-rw-r--r--
test_util.py	19.2 KB	-rw-r--r--
test_warning.py	17.22 KB	-rw-r--r--
weird.py	675 B	-rw-r--r--

Code Editor : detests.py

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

"""
Tests for Deferred handling by L{twisted.trial.unittest.TestCase}.
"""

from twisted.internet import defer, reactor, threads
from twisted.python.util import runWithWarningsSuppressed
from twisted.trial import unittest
from twisted.trial.util import suppress as SUPPRESS

class DeferredSetUpOK(unittest.TestCase):
    def setUp(self):
        d = defer.succeed("value")
        d.addCallback(self._cb_setUpCalled)
        return d

def _cb_setUpCalled(self, ignored):
        self._setUpCalled = True

def test_ok(self):
        self.assertTrue(self._setUpCalled)

class DeferredSetUpFail(unittest.TestCase):
    testCalled = False

def setUp(self):
        return defer.fail(unittest.FailTest("i fail"))

def test_ok(self):
        DeferredSetUpFail.testCalled = True
        self.fail("I should not get called")

class DeferredSetUpCallbackFail(unittest.TestCase):
    testCalled = False

def setUp(self):
        d = defer.succeed("value")
        d.addCallback(self._cb_setUpCalled)
        return d

def _cb_setUpCalled(self, ignored):
        self.fail("deliberate failure")

def test_ok(self):
        DeferredSetUpCallbackFail.testCalled = True

class DeferredSetUpError(unittest.TestCase):
    testCalled = False

def setUp(self):
        return defer.fail(RuntimeError("deliberate error"))

def test_ok(self):
        DeferredSetUpError.testCalled = True

class DeferredSetUpNeverFire(unittest.TestCase):
    testCalled = False

def setUp(self):
        return defer.Deferred()

def test_ok(self):
        DeferredSetUpNeverFire.testCalled = True

class DeferredSetUpSkip(unittest.TestCase):
    testCalled = False

def setUp(self):
        d = defer.succeed("value")
        d.addCallback(self._cb1)
        return d

def _cb1(self, ignored):
        raise unittest.SkipTest("skip me")

def test_ok(self):
        DeferredSetUpSkip.testCalled = True

class DeferredTests(unittest.TestCase):
    touched = False

def _cb_fail(self, reason):
        self.fail(reason)

def _cb_error(self, reason):
        raise RuntimeError(reason)

def _cb_skip(self, reason):
        raise unittest.SkipTest(reason)

def _touchClass(self, ignored):
        self.__class__.touched = True

def setUp(self):
        self.__class__.touched = False

def test_pass(self):
        return defer.succeed("success")

def test_passGenerated(self):
        self._touchClass(None)
        yield None

test_passGenerated = runWithWarningsSuppressed(
        [
            SUPPRESS(
                message="twisted.internet.defer.deferredGenerator was " "deprecated"
            )
        ],
        defer.deferredGenerator,
        test_passGenerated,
    )

@defer.inlineCallbacks
    def test_passInlineCallbacks(self):
        """
        Test case that is decorated with L{defer.inlineCallbacks}.
        """
        self._touchClass(None)
        yield None

def test_fail(self):
        return defer.fail(self.failureException("I fail"))

def test_failureInCallback(self):
        d = defer.succeed("fail")
        d.addCallback(self._cb_fail)
        return d

def test_errorInCallback(self):
        d = defer.succeed("error")
        d.addCallback(self._cb_error)
        return d

def test_skip(self):
        d = defer.succeed("skip")
        d.addCallback(self._cb_skip)
        d.addCallback(self._touchClass)
        return d

def test_thread(self):
        return threads.deferToThread(lambda: None)

def test_expectedFailure(self):
        d = defer.succeed("todo")
        d.addCallback(self._cb_error)
        return d

test_expectedFailure.todo = "Expected failure"  # type: ignore[attr-defined]

class TimeoutTests(unittest.TestCase):
    timedOut = None

def test_pass(self):
        d = defer.Deferred()
        reactor.callLater(0, d.callback, "hoorj!")
        return d

test_pass.timeout = 2  # type: ignore[attr-defined]

def test_passDefault(self):
        # test default timeout
        d = defer.Deferred()
        reactor.callLater(0, d.callback, "hoorj!")
        return d

def test_timeout(self):
        return defer.Deferred()

test_timeout.timeout = 0.1  # type: ignore[attr-defined]

def test_timeoutZero(self):
        return defer.Deferred()

test_timeoutZero.timeout = 0  # type: ignore[attr-defined]

def test_expectedFailure(self):
        return defer.Deferred()

test_expectedFailure.timeout = 0.1  # type: ignore[attr-defined]
    test_expectedFailure.todo = "i will get it right, eventually"  # type: ignore[attr-defined]

def test_skip(self):
        return defer.Deferred()

test_skip.timeout = 0.1  # type: ignore[attr-defined]
    test_skip.skip = "i will get it right, eventually"  # type: ignore[attr-defined]

def test_errorPropagation(self):
        def timedOut(err):
            self.__class__.timedOut = err
            return err

d = defer.Deferred()
        d.addErrback(timedOut)
        return d

test_errorPropagation.timeout = 0.1  # type: ignore[attr-defined]

def test_calledButNeverCallback(self):
        d = defer.Deferred()

def neverFire(r):
            return defer.Deferred()

d.addCallback(neverFire)
        d.callback(1)
        return d

test_calledButNeverCallback.timeout = 0.1  # type: ignore[attr-defined]

class TestClassTimeoutAttribute(unittest.TestCase):
    timeout = 0.2

def setUp(self):
        self.d = defer.Deferred()

def testMethod(self):
        self.methodCalled = True
        return self.d

${this.title}

Code Editor : detests.py