tcl.git - Tcl is a high-level, general-purpose, interpreted, dynamic programming language. It was designed with the goal of being very simple but powerful.

Tcl is a high-level, general-purpose, interpreted, dynamic programming language. It was designed with the goal of being very simple but powerful.

summary refs log tree commit diff stats

path: root/unix

diff options

author	jan.nijtmans <nijtmans@users.sourceforge.net>	2019-09-29 15:45:39 (GMT)
committer	jan.nijtmans <nijtmans@users.sourceforge.net>	2019-09-29 15:45:39 (GMT)
commit	53c93039f618aaec19a74523d45c0bee51de5cd0 (patch)
tree	b31f8d2c456f7adea64329404f81a3df81c8c68d /unix
parent	0e525ab2378cfb0dc315ee7959e7453fb4be9a3a (diff)
download	tcl-53c93039f618aaec19a74523d45c0bee51de5cd0.zip tcl-53c93039f618aaec19a74523d45c0bee51de5cd0.tar.gz tcl-53c93039f618aaec19a74523d45c0bee51de5cd0.tar.bz2

Fix correct export on win32 for TclZipfs_AppHook, when not building with -DUNICODE

Diffstat (limited to 'unix')

0 files changed, 0 insertions, 0 deletions

get_output(code) stder = '\n'.join(stderr) self.assertTrue(not_expected not in stderr, "%r is present in %r" % (not_expected, stderr)) self.assertNotEqual(exitcode, 0) def test_is_enabled(self): was_enabled = faulthandler.is_enabled() try: faulthandler.enable() self.assertTrue(faulthandler.is_enabled()) faulthandler.disable() self.assertFalse(faulthandler.is_enabled()) finally: if was_enabled: faulthandler.enable() else: faulthandler.disable() def check_dump_traceback(self, filename): """ Explicitly call dump_traceback() function and check its output. Raise an error if the output doesn't match the expected format. """ code = """ import faulthandler def funcB(): if {has_filename}: with open({filename}, "wb") as fp: faulthandler.dump_traceback(fp) else: faulthandler.dump_traceback() def funcA(): funcB() funcA() """.strip() code = code.format( filename=repr(filename), has_filename=bool(filename), ) if filename: lineno = 6 else: lineno = 8 expected = [ 'Traceback (most recent call first):', ' File "<string>", line %s in funcB' % lineno, ' File "<string>", line 11 in funcA', ' File "<string>", line 13 in <module>' ] trace, exitcode = self.get_output(code, filename) self.assertEqual(trace, expected) self.assertEqual(exitcode, 0) def test_dump_traceback(self): self.check_dump_traceback(None) def test_dump_traceback_file(self): with temporary_filename() as filename: self.check_dump_traceback(filename) def check_dump_traceback_threads(self, filename): """ Call explicitly dump_traceback(all_threads=True) and check the output. Raise an error if the output doesn't match the expected format. """ code = """ import faulthandler from threading import Thread, Event import time def dump(): if {filename}: with open({filename}, "wb") as fp: faulthandler.dump_traceback(fp, all_threads=True) else: faulthandler.dump_traceback(all_threads=True) class Waiter(Thread): # avoid blocking if the main thread raises an exception. daemon = True def __init__(self): Thread.__init__(self) self.running = Event() self.stop = Event() def run(self): self.running.set() self.stop.wait() waiter = Waiter() waiter.start() waiter.running.wait() dump() waiter.stop.set() waiter.join() """.strip() code = code.format(filename=repr(filename)) output, exitcode = self.get_output(code, filename) output = '\n'.join(output) if filename: lineno = 8 else: lineno = 10 regex = """ ^Thread 0x[0-9a-f]+: (?: File ".*threading.py", line [0-9]+ in [_a-z]+ ){{1,3}} File "<string>", line 23 in run File ".*threading.py", line [0-9]+ in _bootstrap_inner File ".*threading.py", line [0-9]+ in _bootstrap Current thread XXX: File "<string>", line {lineno} in dump File "<string>", line 28 in <module>$ """.strip() regex = regex.format(lineno=lineno) self.assertRegex(output, regex) self.assertEqual(exitcode, 0) def test_dump_traceback_threads(self): self.check_dump_traceback_threads(None) def test_dump_traceback_threads_file(self): with temporary_filename() as filename: self.check_dump_traceback_threads(filename) def _check_dump_tracebacks_later(self, repeat, cancel, filename): """ Check how many times the traceback is written in timeout x 2.5 seconds, or timeout x 3.5 seconds if cancel is True: 1, 2 or 3 times depending on repeat and cancel options. Raise an error if the output doesn't match the expect format. """ code = """ import faulthandler import time def func(repeat, cancel, timeout): if cancel: faulthandler.cancel_dump_tracebacks_later() time.sleep(timeout * 2.5) faulthandler.cancel_dump_tracebacks_later() timeout = {timeout} repeat = {repeat} cancel = {cancel} if {has_filename}: file = open({filename}, "wb") else: file = None faulthandler.dump_tracebacks_later(timeout, repeat=repeat, file=file) func(repeat, cancel, timeout) if file is not None: file.close() """.strip() code = code.format( filename=repr(filename), has_filename=bool(filename), repeat=repeat, cancel=cancel, timeout=TIMEOUT, ) trace, exitcode = self.get_output(code, filename) trace = '\n'.join(trace) if not cancel: if repeat: count = 2 else: count = 1 header = 'Thread 0x[0-9a-f]+:\n' regex = expected_traceback(7, 19, header, count=count) self.assertRegex(trace, regex) else: self.assertEqual(trace, '') self.assertEqual(exitcode, 0) @unittest.skipIf(not hasattr(faulthandler, 'dump_tracebacks_later'), 'need faulthandler.dump_tracebacks_later()') def check_dump_tracebacks_later(self, repeat=False, cancel=False, file=False): if file: with temporary_filename() as filename: self._check_dump_tracebacks_later(repeat, cancel, filename) else: self._check_dump_tracebacks_later(repeat, cancel, None) def test_dump_tracebacks_later(self): self.check_dump_tracebacks_later() def test_dump_tracebacks_later_repeat(self): self.check_dump_tracebacks_later(repeat=True) def test_dump_tracebacks_later_cancel(self): self.check_dump_tracebacks_later(cancel=True) def test_dump_tracebacks_later_file(self): self.check_dump_tracebacks_later(file=True) @unittest.skipIf(not hasattr(faulthandler, "register"), "need faulthandler.register") def check_register(self, filename=False, all_threads=False, unregister=False): """ Register a handler displaying the traceback on a user signal. Raise the signal and check the written traceback. Raise an error if the output doesn't match the expected format. """ signum = signal.SIGUSR1 code = """ import faulthandler import os import signal def func(signum): os.kill(os.getpid(), signum) signum = {signum} unregister = {unregister} if {has_filename}: file = open({filename}, "wb") else: file = None faulthandler.register(signum, file=file, all_threads={all_threads}) if unregister: faulthandler.unregister(signum) func(signum) if file is not None: file.close() """.strip() code = code.format( filename=repr(filename), has_filename=bool(filename), all_threads=all_threads, signum=signum, unregister=unregister, ) trace, exitcode = self.get_output(code, filename) trace = '\n'.join(trace) if not unregister: if all_threads: regex = 'Current thread XXX:\n' else: regex = 'Traceback $most recent call first$:\n' regex = expected_traceback(6, 17, regex) self.assertRegex(trace, regex) else: self.assertEqual(trace, '') if unregister: self.assertNotEqual(exitcode, 0) else: self.assertEqual(exitcode, 0) def test_register(self): self.check_register() def test_unregister(self): self.check_register(unregister=True) def test_register_file(self): with temporary_filename() as filename: self.check_register(filename=filename) def test_register_threads(self): self.check_register(all_threads=True) def test_main(): support.run_unittest(FaultHandlerTests) if __name__ == "__main__": test_main()


context:
space:
mode: