ULTRA [ growontech.com ]

Linux premium216.web-hosting.com 4.18.0-513.18.1.lve.el8.x86_64 #1 SMP Thu Feb 22 12:55:50 UTC 2024 x86_64

LiteSpeed

66.29.141.148 | Your IP: 18.117.103.185

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ proc / thread-self / root / lib64 / python2.7 / unittest / test /

Home Upload Mass Deface Mass Delete Back Connect Notify

test_break.py

import gc
import os
import sys
import signal
import weakref

from cStringIO import StringIO

import unittest

@unittest.skipUnless(hasattr(os, 'kill'), "Test requires os.kill")
@unittest.skipIf(sys.platform =="win32", "Test cannot run on Windows")
@unittest.skipIf(sys.platform == 'freebsd6', "Test kills regrtest on freebsd6 "
    "if threads have been used")
class TestBreak(unittest.TestCase):
    int_handler = None

def setUp(self):
        self._default_handler = signal.getsignal(signal.SIGINT)
        if self.int_handler is not None:
            signal.signal(signal.SIGINT, self.int_handler)

def tearDown(self):
        signal.signal(signal.SIGINT, self._default_handler)
        unittest.signals._results = weakref.WeakKeyDictionary()
        unittest.signals._interrupt_handler = None

def testInstallHandler(self):
        default_handler = signal.getsignal(signal.SIGINT)
        unittest.installHandler()
        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)

try:
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)
        except KeyboardInterrupt:
            self.fail("KeyboardInterrupt not handled")

self.assertTrue(unittest.signals._interrupt_handler.called)

def testRegisterResult(self):
        result = unittest.TestResult()
        unittest.registerResult(result)

for ref in unittest.signals._results:
            if ref is result:
                break
            elif ref is not result:
                self.fail("odd object in result set")
        else:
            self.fail("result not found")

def testInterruptCaught(self):
        default_handler = signal.getsignal(signal.SIGINT)

result = unittest.TestResult()
        unittest.installHandler()
        unittest.registerResult(result)

self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)

def test(result):
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)
            result.breakCaught = True
            self.assertTrue(result.shouldStop)

try:
            test(result)
        except KeyboardInterrupt:
            self.fail("KeyboardInterrupt not handled")
        self.assertTrue(result.breakCaught)

def testSecondInterrupt(self):
        # Can't use skipIf decorator because the signal handler may have
        # been changed after defining this method.
        if signal.getsignal(signal.SIGINT) == signal.SIG_IGN:
            self.skipTest("test requires SIGINT to not be ignored")
        result = unittest.TestResult()
        unittest.installHandler()
        unittest.registerResult(result)

def test(result):
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)
            result.breakCaught = True
            self.assertTrue(result.shouldStop)
            os.kill(pid, signal.SIGINT)
            self.fail("Second KeyboardInterrupt not raised")

try:
            test(result)
        except KeyboardInterrupt:
            pass
        else:
            self.fail("Second KeyboardInterrupt not raised")
        self.assertTrue(result.breakCaught)

def testTwoResults(self):
        unittest.installHandler()

result = unittest.TestResult()
        unittest.registerResult(result)
        new_handler = signal.getsignal(signal.SIGINT)

result2 = unittest.TestResult()
        unittest.registerResult(result2)
        self.assertEqual(signal.getsignal(signal.SIGINT), new_handler)

result3 = unittest.TestResult()

def test(result):
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)

try:
            test(result)
        except KeyboardInterrupt:
            self.fail("KeyboardInterrupt not handled")

self.assertTrue(result.shouldStop)
        self.assertTrue(result2.shouldStop)
        self.assertFalse(result3.shouldStop)

def testHandlerReplacedButCalled(self):
        # Can't use skipIf decorator because the signal handler may have
        # been changed after defining this method.
        if signal.getsignal(signal.SIGINT) == signal.SIG_IGN:
            self.skipTest("test requires SIGINT to not be ignored")
        # If our handler has been replaced (is no longer installed) but is
        # called by the *new* handler, then it isn't safe to delay the
        # SIGINT and we should immediately delegate to the default handler
        unittest.installHandler()

handler = signal.getsignal(signal.SIGINT)
        def new_handler(frame, signum):
            handler(frame, signum)
        signal.signal(signal.SIGINT, new_handler)

try:
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)
        except KeyboardInterrupt:
            pass
        else:
            self.fail("replaced but delegated handler doesn't raise interrupt")

def testRunner(self):
        # Creating a TextTestRunner with the appropriate argument should
        # register the TextTestResult it creates
        runner = unittest.TextTestRunner(stream=StringIO())

result = runner.run(unittest.TestSuite())
        self.assertIn(result, unittest.signals._results)

def testWeakReferences(self):
        # Calling registerResult on a result should not keep it alive
        result = unittest.TestResult()
        unittest.registerResult(result)

ref = weakref.ref(result)
        del result

# For non-reference counting implementations
        gc.collect();gc.collect()
        self.assertIsNone(ref())

def testRemoveResult(self):
        result = unittest.TestResult()
        unittest.registerResult(result)

unittest.installHandler()
        self.assertTrue(unittest.removeResult(result))

# Should this raise an error instead?
        self.assertFalse(unittest.removeResult(unittest.TestResult()))

try:
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)
        except KeyboardInterrupt:
            pass

self.assertFalse(result.shouldStop)

def testMainInstallsHandler(self):
        failfast = object()
        test = object()
        verbosity = object()
        result = object()
        default_handler = signal.getsignal(signal.SIGINT)

class FakeRunner(object):
            initArgs = []
            runArgs = []
            def __init__(self, *args, **kwargs):
                self.initArgs.append((args, kwargs))
            def run(self, test):
                self.runArgs.append(test)
                return result

class Program(unittest.TestProgram):
            def __init__(self, catchbreak):
                self.exit = False
                self.verbosity = verbosity
                self.failfast = failfast
                self.catchbreak = catchbreak
                self.testRunner = FakeRunner
                self.test = test
                self.result = None

p = Program(False)
        p.runTests()

self.assertEqual(FakeRunner.initArgs, [((), {'buffer': None,
                                                     'verbosity': verbosity,
                                                     'failfast': failfast})])
        self.assertEqual(FakeRunner.runArgs, [test])
        self.assertEqual(p.result, result)

self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)

FakeRunner.initArgs = []
        FakeRunner.runArgs = []
        p = Program(True)
        p.runTests()

self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)

def testRemoveHandler(self):
        default_handler = signal.getsignal(signal.SIGINT)
        unittest.installHandler()
        unittest.removeHandler()
        self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)

# check that calling removeHandler multiple times has no ill-effect
        unittest.removeHandler()
        self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)

def testRemoveHandlerAsDecorator(self):
        default_handler = signal.getsignal(signal.SIGINT)
        unittest.installHandler()

@unittest.removeHandler
        def test():
            self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)

test()
        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2024-06-15 05:03:36
..	dir	-	root/root	drwxr-xr-x	2024-06-15 05:03:36
__init__.py	text/x-script.python	514 B	root/root	-rw-r--r--	2024-04-10 04:58:35
__init__.pyc	application/x-bytecode.python	906 B	root/root	-rw-r--r--	2024-04-10 04:58:46
__init__.pyo	application/x-bytecode.python	906 B	root/root	-rw-r--r--	2024-04-10 04:58:46
dummy.py	text/plain	50 B	root/root	-rw-r--r--	2024-04-10 04:58:35
dummy.pyc	application/x-bytecode.python	130 B	root/root	-rw-r--r--	2024-04-10 04:58:46
dummy.pyo	application/x-bytecode.python	130 B	root/root	-rw-r--r--	2024-04-10 04:58:46
support.py	text/x-script.python	3.39 KB	root/root	-rw-r--r--	2024-04-10 04:58:35
support.pyc	application/x-bytecode.python	5.86 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
support.pyo	application/x-bytecode.python	5.86 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_assertions.py	text/x-script.python	11.68 KB	root/root	-rw-r--r--	2024-04-10 04:58:35
test_assertions.pyc	application/x-bytecode.python	13.12 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_assertions.pyo	application/x-bytecode.python	13.12 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_break.py	text/x-script.python	9.42 KB	root/root	-rw-r--r--	2024-04-10 04:58:35
test_break.pyc	application/x-bytecode.python	9.91 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_break.pyo	application/x-bytecode.python	9.91 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_case.py	text/x-script.python	44.65 KB	root/root	-rw-r--r--	2024-04-10 04:58:35
test_case.pyc	application/x-bytecode.python	45.92 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_case.pyo	application/x-bytecode.python	45.92 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_discovery.py	text/x-script.python	13.98 KB	root/root	-rw-r--r--	2024-04-10 04:58:35
test_discovery.pyc	application/x-bytecode.python	17.25 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_discovery.pyo	application/x-bytecode.python	17.25 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_functiontestcase.py	text/x-script.python	5.42 KB	root/root	-rw-r--r--	2024-04-10 04:58:36
test_functiontestcase.pyc	application/x-bytecode.python	5.94 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_functiontestcase.pyo	application/x-bytecode.python	5.94 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_loader.py	text/x-script.python	48.7 KB	root/root	-rw-r--r--	2024-04-10 04:58:36
test_loader.pyc	application/x-bytecode.python	48.65 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_loader.pyo	application/x-bytecode.python	48.65 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_program.py	text/x-script.python	7.4 KB	root/root	-rw-r--r--	2024-04-10 04:58:36
test_program.pyc	application/x-bytecode.python	10.23 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_program.pyo	application/x-bytecode.python	10.17 KB	root/root	-rw-r--r--	2024-04-10 04:58:44
test_result.py	text/x-script.python	18.61 KB	root/root	-rw-r--r--	2024-04-10 04:58:36
test_result.pyc	application/x-bytecode.python	20.9 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_result.pyo	application/x-bytecode.python	20.9 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_runner.py	text/x-script.python	8.41 KB	root/root	-rw-r--r--	2024-04-10 04:58:36
test_runner.pyc	application/x-bytecode.python	13.79 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_runner.pyo	application/x-bytecode.python	13.79 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_setups.py	text/x-script.python	16.07 KB	root/root	-rw-r--r--	2024-04-10 04:58:36
test_setups.pyc	application/x-bytecode.python	28.49 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_setups.pyo	application/x-bytecode.python	28.49 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_skipping.py	text/x-script.python	5.61 KB	root/root	-rw-r--r--	2024-04-10 04:58:36
test_skipping.pyc	application/x-bytecode.python	9.38 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_skipping.pyo	application/x-bytecode.python	9.38 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_suite.py	text/x-script.python	11.8 KB	root/root	-rw-r--r--	2024-04-10 04:58:36
test_suite.pyc	application/x-bytecode.python	15.14 KB	root/root	-rw-r--r--	2024-04-10 04:58:46
test_suite.pyo	application/x-bytecode.python	15.14 KB	root/root	-rw-r--r--	2024-04-10 04:58:46