Gecko [ www.jdcpatala.org ]

Name	Size	Permission
audiodata	[ DIR ]	drwxr-xr-x
certdata	[ DIR ]	drwxr-xr-x
cjkencodings	[ DIR ]	drwxr-xr-x
configdata	[ DIR ]	drwxr-xr-x
crashers	[ DIR ]	drwxr-xr-x
data	[ DIR ]	drwxr-xr-x
decimaltestdata	[ DIR ]	drwxr-xr-x
dtracedata	[ DIR ]	drwxr-xr-x
encoded_modules	[ DIR ]	drwxr-xr-x
imghdrdata	[ DIR ]	drwxr-xr-x
leakers	[ DIR ]	drwxr-xr-x
libregrtest	[ DIR ]	drwxr-xr-x
regrtestdata	[ DIR ]	drwxr-xr-x
sndhdrdata	[ DIR ]	drwxr-xr-x
subprocessdata	[ DIR ]	drwxr-xr-x
support	[ DIR ]	drwxr-xr-x
test_asyncio	[ DIR ]	drwxr-xr-x
test_capi	[ DIR ]	drwxr-xr-x
test_concurrent_futures	[ DIR ]	drwxr-xr-x
test_cppext	[ DIR ]	drwxr-xr-x
test_ctypes	[ DIR ]	drwxr-xr-x
test_dataclasses	[ DIR ]	drwxr-xr-x
test_doctest	[ DIR ]	drwxr-xr-x
test_email	[ DIR ]	drwxr-xr-x
test_future_stmt	[ DIR ]	drwxr-xr-x
test_gdb	[ DIR ]	drwxr-xr-x
test_import	[ DIR ]	drwxr-xr-x
test_importlib	[ DIR ]	drwxr-xr-x
test_inspect	[ DIR ]	drwxr-xr-x
test_json	[ DIR ]	drwxr-xr-x
test_lib2to3	[ DIR ]	drwxr-xr-x
test_module	[ DIR ]	drwxr-xr-x
test_multiprocessing_fork	[ DIR ]	drwxr-xr-x
test_multiprocessing_forkserve...	[ DIR ]	drwxr-xr-x
test_multiprocessing_spawn	[ DIR ]	drwxr-xr-x
test_peg_generator	[ DIR ]	drwxr-xr-x
test_pydoc	[ DIR ]	drwxr-xr-x
test_sqlite3	[ DIR ]	drwxr-xr-x
test_tkinter	[ DIR ]	drwxr-xr-x
test_tomllib	[ DIR ]	drwxr-xr-x
test_tools	[ DIR ]	drwxr-xr-x
test_ttk	[ DIR ]	drwxr-xr-x
test_unittest	[ DIR ]	drwxr-xr-x
test_warnings	[ DIR ]	drwxr-xr-x
test_zipfile	[ DIR ]	drwxr-xr-x
test_zoneinfo	[ DIR ]	drwxr-xr-x
tokenizedata	[ DIR ]	drwxr-xr-x
tracedmodules	[ DIR ]	drwxr-xr-x
typinganndata	[ DIR ]	drwxr-xr-x
wheeldata	[ DIR ]	drwxr-xr-x
xmltestdata	[ DIR ]	drwxr-xr-x
ziptestdata	[ DIR ]	drwxr-xr-x
Sine-1000Hz-300ms.aif	60.25 KB	-rw-r--r--
__init__.py	47 B	-rw-r--r--
__main__.py	67 B	-rw-r--r--
_test_atexit.py	3.61 KB	-rw-r--r--
_test_eintr.py	17.75 KB	-rw-r--r--
_test_embed_set_config.py	8.64 KB	-rw-r--r--
_test_embed_structseq.py	1.99 KB	-rw-r--r--
_test_multiprocessing.py	206.66 KB	-rw-r--r--
_test_venv_multiprocessing.py	796 B	-rw-r--r--
archiver_tests.py	6.1 KB	-rw-r--r--
audiotest.au	27.48 KB	-rw-r--r--
audiotests.py	12.13 KB	-rw-r--r--
audit-tests.py	13.19 KB	-rw-r--r--
autotest.py	214 B	-rw-r--r--
badsyntax_pep3120.py	14 B	-rw-r--r--
bisect_cmd.py	5.34 KB	-rwxr-xr-x
clinic.test.c	138.59 KB	-rw-r--r--
cmath_testcases.txt	141.2 KB	-rw-r--r--
curses_tests.py	1.21 KB	-rwxr-xr-x
datetimetester.py	260.28 KB	-rw-r--r--
dis_module.py	76 B	-rw-r--r--
empty.vbs	70 B	-rw-r--r--
exception_hierarchy.txt	2.33 KB	-rw-r--r--
floating_points.txt	15.92 KB	-rw-r--r--
fork_wait.py	2.29 KB	-rw-r--r--
formatfloat_testcases.txt	7.45 KB	-rw-r--r--
ieee754.txt	3.15 KB	-rw-r--r--
levenshtein_examples.json	406.44 KB	-rw-r--r--
list_tests.py	16.64 KB	-rw-r--r--
lock_tests.py	35.48 KB	-rw-r--r--
mailcap.txt	1.24 KB	-rw-r--r--
mapping_tests.py	21.87 KB	-rw-r--r--
math_testcases.txt	23.19 KB	-rw-r--r--
memory_watchdog.py	711 B	-rw-r--r--
mime.types	47.37 KB	-rw-r--r--
mock_socket.py	3.69 KB	-rw-r--r--
mp_fork_bomb.py	448 B	-rw-r--r--
mp_preload.py	351 B	-rw-r--r--
multibytecodec_support.py	14.19 KB	-rw-r--r--
pickletester.py	143.84 KB	-rw-r--r--
profilee.py	2.97 KB	-rw-r--r--
pstats.pck	65.05 KB	-rw-r--r--
pyclbr_input.py	648 B	-rw-r--r--
pythoninfo.py	28.32 KB	-rw-r--r--
randv2_32.pck	7.34 KB	-rw-r--r--
randv2_64.pck	7.19 KB	-rw-r--r--
randv3.pck	7.82 KB	-rw-r--r--
re_tests.py	25.93 KB	-rwxr-xr-x
recursion.tar	516 B	-rw-r--r--
regrtest.py	1.27 KB	-rwxr-xr-x
relimport.py	27 B	-rw-r--r--
reperf.py	538 B	-rw-r--r--
seq_tests.py	14.96 KB	-rw-r--r--
signalinterproctester.py	3.12 KB	-rw-r--r--
ssl_servers.py	7.12 KB	-rw-r--r--
ssltests.py	1.03 KB	-rw-r--r--
string_tests.py	71.24 KB	-rw-r--r--
test___all__.py	5.04 KB	-rw-r--r--
test__locale.py	8.09 KB	-rw-r--r--
test__opcode.py	4.14 KB	-rw-r--r--
test__osx_support.py	13.62 KB	-rw-r--r--
test__xxinterpchannels.py	52.19 KB	-rw-r--r--
test__xxsubinterpreters.py	27.5 KB	-rw-r--r--
test_abc.py	23.81 KB	-rw-r--r--
test_abstract_numbers.py	5.81 KB	-rw-r--r--
test_aifc.py	17.84 KB	-rw-r--r--
test_argparse.py	189 KB	-rw-r--r--
test_array.py	55.27 KB	-rwxr-xr-x
test_asdl_parser.py	4.44 KB	-rw-r--r--
test_ast.py	140.71 KB	-rw-r--r--
test_asyncgen.py	47.39 KB	-rw-r--r--
test_atexit.py	3.2 KB	-rw-r--r--
test_audioop.py	28.32 KB	-rw-r--r--
test_audit.py	8.6 KB	-rw-r--r--
test_augassign.py	7.68 KB	-rw-r--r--
test_base64.py	35.05 KB	-rw-r--r--
test_baseexception.py	7.77 KB	-rw-r--r--
test_bdb.py	43.75 KB	-rw-r--r--
test_bigaddrspace.py	2.83 KB	-rw-r--r--
test_bigmem.py	45.01 KB	-rw-r--r--
test_binascii.py	19.35 KB	-rw-r--r--
test_binop.py	14.14 KB	-rw-r--r--
test_bisect.py	16.63 KB	-rw-r--r--
test_bool.py	14.25 KB	-rw-r--r--
test_buffer.py	171.31 KB	-rw-r--r--
test_bufio.py	2.56 KB	-rw-r--r--
test_builtin.py	95.14 KB	-rw-r--r--
test_bytes.py	80.57 KB	-rw-r--r--
test_bz2.py	42.61 KB	-rw-r--r--
test_c_locale_coercion.py	20.99 KB	-rw-r--r--
test_calendar.py	51.25 KB	-rw-r--r--
test_call.py	35.21 KB	-rw-r--r--
test_cgi.py	22.27 KB	-rw-r--r--
test_cgitb.py	2.62 KB	-rw-r--r--
test_charmapcodec.py	1.77 KB	-rw-r--r--
test_class.py	19.77 KB	-rw-r--r--
test_clinic.py	83.96 KB	-rw-r--r--
test_cmath.py	23.55 KB	-rw-r--r--
test_cmd.py	6.49 KB	-rw-r--r--
test_cmd_line.py	39.51 KB	-rw-r--r--
test_cmd_line_script.py	34.93 KB	-rw-r--r--
test_code.py	25.7 KB	-rw-r--r--
test_code_module.py	5.53 KB	-rw-r--r--
test_codeccallbacks.py	47.43 KB	-rw-r--r--
test_codecencodings_cn.py	3.86 KB	-rw-r--r--
test_codecencodings_hk.py	701 B	-rw-r--r--
test_codecencodings_iso2022.py	3.65 KB	-rw-r--r--
test_codecencodings_jp.py	4.79 KB	-rw-r--r--
test_codecencodings_kr.py	2.96 KB	-rw-r--r--
test_codecencodings_tw.py	681 B	-rw-r--r--
test_codecmaps_cn.py	746 B	-rw-r--r--
test_codecmaps_hk.py	386 B	-rw-r--r--
test_codecmaps_jp.py	1.7 KB	-rw-r--r--
test_codecmaps_kr.py	1.16 KB	-rw-r--r--
test_codecmaps_tw.py	705 B	-rw-r--r--
test_codecs.py	136.12 KB	-rw-r--r--
test_codeop.py	8.68 KB	-rw-r--r--
test_collections.py	93.47 KB	-rw-r--r--
test_colorsys.py	4.27 KB	-rw-r--r--
test_compare.py	17.46 KB	-rw-r--r--
test_compile.py	78.68 KB	-rw-r--r--
test_compileall.py	48.27 KB	-rw-r--r--
test_compiler_assemble.py	2.46 KB	-rw-r--r--
test_compiler_codegen.py	1.69 KB	-rw-r--r--
test_complex.py	35.37 KB	-rw-r--r--
test_configparser.py	85.34 KB	-rw-r--r--
test_contains.py	3.35 KB	-rw-r--r--
test_context.py	30.78 KB	-rw-r--r--
test_contextlib.py	43.12 KB	-rw-r--r--
test_contextlib_async.py	23.99 KB	-rw-r--r--
test_copy.py	26.52 KB	-rw-r--r--
test_copyreg.py	4.36 KB	-rw-r--r--
test_coroutines.py	67.47 KB	-rw-r--r--
test_cprofile.py	7.36 KB	-rw-r--r--
test_crashers.py	1.17 KB	-rw-r--r--
test_crypt.py	4.19 KB	-rw-r--r--
test_csv.py	61.27 KB	-rw-r--r--
test_curses.py	49.54 KB	-rw-r--r--
test_datetime.py	2.53 KB	-rw-r--r--
test_dbm.py	6.83 KB	-rw-r--r--
test_dbm_dumb.py	11.08 KB	-rw-r--r--
test_dbm_gnu.py	7.24 KB	-rw-r--r--
test_dbm_ndbm.py	5.91 KB	-rw-r--r--
test_decimal.py	216.13 KB	-rw-r--r--
test_decorators.py	14.63 KB	-rw-r--r--
test_defaultdict.py	6.1 KB	-rw-r--r--
test_deque.py	33.16 KB	-rw-r--r--
test_descr.py	196.13 KB	-rw-r--r--
test_descrtut.py	10.98 KB	-rw-r--r--
test_devpoll.py	4.44 KB	-rw-r--r--
test_dict.py	50.92 KB	-rw-r--r--
test_dict_version.py	6.1 KB	-rw-r--r--
test_dictcomps.py	5.15 KB	-rw-r--r--
test_dictviews.py	14.82 KB	-rw-r--r--
test_difflib.py	21.47 KB	-rw-r--r--
test_difflib_expect.html	100.85 KB	-rw-r--r--
test_dis.py	83 KB	-rw-r--r--
test_docxmlrpc.py	9.1 KB	-rw-r--r--
test_dtrace.py	7.98 KB	-rw-r--r--
test_dynamic.py	6 KB	-rw-r--r--
test_dynamicclassattribute.py	9.57 KB	-rw-r--r--
test_eintr.py	627 B	-rw-r--r--
test_embed.py	69.41 KB	-rw-r--r--
test_ensurepip.py	11.49 KB	-rw-r--r--
test_enum.py	186.78 KB	-rw-r--r--
test_enumerate.py	9.14 KB	-rw-r--r--
test_eof.py	3.1 KB	-rw-r--r--
test_epoll.py	9.4 KB	-rw-r--r--
test_errno.py	1.04 KB	-rw-r--r--
test_except_star.py	38.25 KB	-rw-r--r--
test_exception_group.py	34.03 KB	-rw-r--r--
test_exception_hierarchy.py	7.54 KB	-rw-r--r--
test_exception_variations.py	13.74 KB	-rw-r--r--
test_exceptions.py	76.46 KB	-rw-r--r--
test_extcall.py	14.69 KB	-rw-r--r--
test_faulthandler.py	30.31 KB	-rw-r--r--
test_fcntl.py	7.76 KB	-rw-r--r--
test_file.py	11.78 KB	-rw-r--r--
test_file_eintr.py	10.74 KB	-rw-r--r--
test_filecmp.py	10.33 KB	-rw-r--r--
test_fileinput.py	37.85 KB	-rw-r--r--
test_fileio.py	19.98 KB	-rw-r--r--
test_fileutils.py	951 B	-rw-r--r--
test_finalization.py	14.66 KB	-rw-r--r--
test_float.py	64.76 KB	-rw-r--r--
test_flufl.py	1.53 KB	-rw-r--r--
test_fnmatch.py	10.68 KB	-rw-r--r--
test_fork1.py	3.3 KB	-rw-r--r--
test_format.py	28.44 KB	-rw-r--r--
test_fractions.py	52.53 KB	-rw-r--r--
test_frame.py	14.04 KB	-rw-r--r--
test_frozen.py	2.2 KB	-rw-r--r--
test_fstring.py	64.71 KB	-rw-r--r--
test_ftplib.py	41.94 KB	-rw-r--r--
test_funcattrs.py	15.57 KB	-rw-r--r--
test_functools.py	109.31 KB	-rw-r--r--
test_gc.py	47.71 KB	-rw-r--r--
test_generator_stop.py	943 B	-rw-r--r--
test_generators.py	66.13 KB	-rw-r--r--
test_genericalias.py	17.78 KB	-rw-r--r--
test_genericclass.py	9.44 KB	-rw-r--r--
test_genericpath.py	22.29 KB	-rw-r--r--
test_genexps.py	7.3 KB	-rw-r--r--
test_getopt.py	6.6 KB	-rw-r--r--
test_getpass.py	6.37 KB	-rw-r--r--
test_getpath.py	44.36 KB	-rw-r--r--
test_gettext.py	35.67 KB	-rw-r--r--
test_glob.py	17.19 KB	-rw-r--r--
test_global.py	1.2 KB	-rw-r--r--
test_grammar.py	65.97 KB	-rw-r--r--
test_graphlib.py	8.31 KB	-rw-r--r--
test_grp.py	3.67 KB	-rw-r--r--
test_gzip.py	40.94 KB	-rw-r--r--
test_hash.py	12.11 KB	-rw-r--r--
test_hashlib.py	46.71 KB	-rw-r--r--
test_heapq.py	16.42 KB	-rw-r--r--
test_hmac.py	26.06 KB	-rw-r--r--
test_html.py	4.23 KB	-rw-r--r--
test_htmlparser.py	33.37 KB	-rw-r--r--
test_http_cookiejar.py	81.57 KB	-rw-r--r--
test_http_cookies.py	18.7 KB	-rw-r--r--
test_httplib.py	96.14 KB	-rw-r--r--
test_httpservers.py	56.43 KB	-rw-r--r--
test_idle.py	831 B	-rw-r--r--
test_imaplib.py	41.69 KB	-rw-r--r--
test_imghdr.py	4.81 KB	-rw-r--r--
test_index.py	8.37 KB	-rw-r--r--
test_int.py	33.34 KB	-rw-r--r--
test_int_literal.py	6.89 KB	-rw-r--r--
test_interpreters.py	32.11 KB	-rw-r--r--
test_io.py	182.76 KB	-rw-r--r--
test_ioctl.py	3.24 KB	-rw-r--r--
test_ipaddress.py	119.17 KB	-rw-r--r--
test_isinstance.py	12.95 KB	-rw-r--r--
test_iter.py	36.77 KB	-rw-r--r--
test_iterlen.py	7.1 KB	-rw-r--r--
test_itertools.py	106.61 KB	-rw-r--r--
test_keyword.py	2 KB	-rw-r--r--
test_keywordonlyarg.py	6.89 KB	-rw-r--r--
test_kqueue.py	9.36 KB	-rw-r--r--
test_largefile.py	10.17 KB	-rw-r--r--
test_launcher.py	27.23 KB	-rw-r--r--
test_linecache.py	11.04 KB	-rw-r--r--
test_list.py	8.93 KB	-rw-r--r--
test_listcomps.py	20.71 KB	-rw-r--r--
test_lltrace.py	3.71 KB	-rw-r--r--
test_locale.py	24.43 KB	-rw-r--r--
test_logging.py	241.62 KB	-rw-r--r--
test_long.py	63.33 KB	-rw-r--r--
test_longexp.py	233 B	-rw-r--r--
test_lzma.py	92.65 KB	-rw-r--r--
test_mailbox.py	93.91 KB	-rw-r--r--
test_mailcap.py	11.48 KB	-rw-r--r--
test_marshal.py	23.15 KB	-rw-r--r--
test_math.py	107.6 KB	-rw-r--r--
test_math_property.py	1.15 KB	-rw-r--r--
test_memoryio.py	32.65 KB	-rw-r--r--
test_memoryview.py	21.76 KB	-rw-r--r--
test_metaclass.py	6.19 KB	-rw-r--r--
test_mimetypes.py	15.28 KB	-rw-r--r--
test_minidom.py	68.42 KB	-rw-r--r--
test_mmap.py	38.56 KB	-rw-r--r--
test_modulefinder.py	12.21 KB	-rw-r--r--
test_monitoring.py	55.76 KB	-rw-r--r--
test_msilib.py	5.52 KB	-rw-r--r--
test_multibytecodec.py	15.79 KB	-rw-r--r--
test_multiprocessing_main_hand...	11.48 KB	-rw-r--r--
test_named_expressions.py	29.62 KB	-rw-r--r--
test_netrc.py	11.86 KB	-rw-r--r--
test_nis.py	1.25 KB	-rw-r--r--
test_nntplib.py	62.7 KB	-rw-r--r--
test_ntpath.py	52.48 KB	-rw-r--r--
test_numeric_tower.py	8 KB	-rw-r--r--
test_opcache.py	10.89 KB	-rw-r--r--
test_opcodes.py	3.62 KB	-rw-r--r--
test_openpty.py	600 B	-rw-r--r--
test_operator.py	26.72 KB	-rw-r--r--
test_optparse.py	61.02 KB	-rw-r--r--
test_ordered_dict.py	35.62 KB	-rw-r--r--
test_os.py	179.95 KB	-rw-r--r--
test_ossaudiodev.py	7.27 KB	-rw-r--r--
test_osx_env.py	1.31 KB	-rw-r--r--
test_pathlib.py	137.81 KB	-rw-r--r--
test_patma.py	86.03 KB	-rw-r--r--
test_pdb.py	86.53 KB	-rw-r--r--
test_peepholer.py	40.6 KB	-rw-r--r--
test_pep646_syntax.py	7.79 KB	-rw-r--r--
test_perf_profiler.py	11.27 KB	-rw-r--r--
test_perfmaps.py	685 B	-rw-r--r--
test_pickle.py	20.75 KB	-rw-r--r--
test_picklebuffer.py	4.99 KB	-rw-r--r--
test_pickletools.py	4.13 KB	-rw-r--r--
test_pipes.py	6.79 KB	-rw-r--r--
test_pkg.py	9.59 KB	-rw-r--r--
test_pkgutil.py	22.36 KB	-rw-r--r--
test_platform.py	21.59 KB	-rw-r--r--
test_plistlib.py	41.25 KB	-rw-r--r--
test_poll.py	7.39 KB	-rw-r--r--
test_popen.py	2.11 KB	-rw-r--r--
test_poplib.py	17.05 KB	-rw-r--r--
test_positional_only_arg.py	18.44 KB	-rw-r--r--
test_posix.py	95.07 KB	-rw-r--r--
test_posixpath.py	33.75 KB	-rw-r--r--
test_pow.py	6.38 KB	-rw-r--r--
test_pprint.py	50.59 KB	-rw-r--r--
test_print.py	7.72 KB	-rw-r--r--
test_profile.py	8.69 KB	-rw-r--r--
test_property.py	18.03 KB	-rw-r--r--
test_pstats.py	4.31 KB	-rw-r--r--
test_pty.py	16.18 KB	-rw-r--r--
test_pulldom.py	12.33 KB	-rw-r--r--
test_pwd.py	4.32 KB	-rw-r--r--
test_py_compile.py	11.93 KB	-rw-r--r--
test_pyclbr.py	10.15 KB	-rw-r--r--
test_pyexpat.py	29.35 KB	-rw-r--r--
test_queue.py	20.61 KB	-rw-r--r--
test_quopri.py	7.87 KB	-rw-r--r--
test_raise.py	13.44 KB	-rw-r--r--
test_random.py	56.69 KB	-rw-r--r--
test_range.py	26.53 KB	-rw-r--r--
test_re.py	131.37 KB	-rw-r--r--
test_readline.py	12.76 KB	-rw-r--r--
test_regrtest.py	90.02 KB	-rw-r--r--
test_repl.py	4.99 KB	-rw-r--r--
test_reprlib.py	27.77 KB	-rw-r--r--
test_resource.py	7.12 KB	-rw-r--r--
test_richcmp.py	11.95 KB	-rw-r--r--
test_rlcompleter.py	7.4 KB	-rw-r--r--
test_robotparser.py	11.02 KB	-rw-r--r--
test_runpy.py	33.95 KB	-rw-r--r--
test_sax.py	54.63 KB	-rw-r--r--
test_sched.py	7.38 KB	-rw-r--r--
test_scope.py	21.21 KB	-rw-r--r--
test_script_helper.py	5.82 KB	-rw-r--r--
test_secrets.py	4.28 KB	-rw-r--r--
test_select.py	3.42 KB	-rw-r--r--
test_selectors.py	19.64 KB	-rw-r--r--
test_set.py	71.31 KB	-rw-r--r--
test_setcomps.py	3.8 KB	-rw-r--r--
test_shelve.py	6.42 KB	-rw-r--r--
test_shlex.py	13.39 KB	-rw-r--r--
test_shutil.py	126.96 KB	-rw-r--r--
test_signal.py	52.42 KB	-rw-r--r--
test_site.py	29.79 KB	-rw-r--r--
test_slice.py	9.46 KB	-rw-r--r--
test_smtplib.py	60.02 KB	-rw-r--r--
test_smtpnet.py	3.03 KB	-rw-r--r--
test_sndhdr.py	1.51 KB	-rw-r--r--
test_socket.py	254.72 KB	-rw-r--r--
test_socketserver.py	17.39 KB	-rw-r--r--
test_sort.py	13.59 KB	-rw-r--r--
test_source_encoding.py	12.65 KB	-rw-r--r--
test_spwd.py	2.83 KB	-rw-r--r--
test_ssl.py	215.24 KB	-rw-r--r--
test_stable_abi_ctypes.py	24.75 KB	-rw-r--r--
test_startfile.py	1.7 KB	-rw-r--r--
test_stat.py	8.92 KB	-rw-r--r--
test_statistics.py	120.02 KB	-rw-r--r--
test_strftime.py	7.4 KB	-rw-r--r--
test_string.py	21.86 KB	-rw-r--r--
test_string_literals.py	13.07 KB	-rw-r--r--
test_stringprep.py	3.04 KB	-rw-r--r--
test_strptime.py	36.48 KB	-rw-r--r--
test_strtod.py	20.06 KB	-rw-r--r--
test_struct.py	38.45 KB	-rw-r--r--
test_structseq.py	7.23 KB	-rw-r--r--
test_subclassinit.py	8.04 KB	-rw-r--r--
test_subprocess.py	162.29 KB	-rw-r--r--
test_sunau.py	6.09 KB	-rw-r--r--
test_sundry.py	1.02 KB	-rw-r--r--
test_super.py	13.9 KB	-rw-r--r--
test_support.py	27.05 KB	-rw-r--r--
test_symtable.py	11.05 KB	-rw-r--r--
test_syntax.py	71.87 KB	-rw-r--r--
test_sys.py	65.64 KB	-rw-r--r--
test_sys_setprofile.py	13.71 KB	-rw-r--r--
test_sys_settrace.py	84.56 KB	-rw-r--r--
test_sysconfig.py	22.45 KB	-rw-r--r--
test_syslog.py	4.7 KB	-rw-r--r--
test_tabnanny.py	13.89 KB	-rw-r--r--
test_tarfile.py	159.67 KB	-rw-r--r--
test_tcl.py	27.22 KB	-rw-r--r--
test_telnetlib.py	12.85 KB	-rw-r--r--
test_tempfile.py	73.86 KB	-rw-r--r--
test_termios.py	10.95 KB	-rw-r--r--
test_textwrap.py	41.89 KB	-rw-r--r--
test_thread.py	8.87 KB	-rw-r--r--
test_threadedtempfile.py	1.93 KB	-rw-r--r--
test_threading.py	73 KB	-rw-r--r--
test_threading_local.py	6.58 KB	-rw-r--r--
test_threadsignals.py	9.87 KB	-rw-r--r--
test_time.py	42.44 KB	-rw-r--r--
test_timeit.py	15.2 KB	-rw-r--r--
test_timeout.py	10.74 KB	-rw-r--r--
test_tix.py	1.05 KB	-rw-r--r--
test_tokenize.py	115.33 KB	-rw-r--r--
test_trace.py	20.58 KB	-rw-r--r--
test_traceback.py	142.96 KB	-rw-r--r--
test_tracemalloc.py	39.54 KB	-rw-r--r--
test_ttk_textonly.py	16.69 KB	-rw-r--r--
test_tty.py	3.63 KB	-rw-r--r--
test_tuple.py	19.8 KB	-rw-r--r--
test_turtle.py	14.04 KB	-rw-r--r--
test_type_aliases.py	11.65 KB	-rw-r--r--
test_type_annotations.py	6.23 KB	-rw-r--r--
test_type_cache.py	6.6 KB	-rw-r--r--
test_type_comments.py	10.5 KB	-rw-r--r--
test_type_params.py	34.24 KB	-rw-r--r--
test_typechecks.py	2.55 KB	-rw-r--r--
test_types.py	80.76 KB	-rw-r--r--
test_typing.py	334.07 KB	-rw-r--r--
test_ucn.py	9.52 KB	-rw-r--r--
test_unary.py	1.52 KB	-rw-r--r--
test_unicode.py	124.82 KB	-rw-r--r--
test_unicode_file.py	5.72 KB	-rw-r--r--
test_unicode_file_functions.py	6.91 KB	-rw-r--r--
test_unicode_identifiers.py	997 B	-rw-r--r--
test_unicodedata.py	17.01 KB	-rw-r--r--
test_univnewlines.py	3.85 KB	-rw-r--r--
test_unpack.py	3.51 KB	-rw-r--r--
test_unpack_ex.py	9.89 KB	-rw-r--r--
test_unparse.py	27.75 KB	-rw-r--r--
test_urllib.py	70.17 KB	-rw-r--r--
test_urllib2.py	80.73 KB	-rw-r--r--
test_urllib2_localnet.py	25.59 KB	-rw-r--r--
test_urllib2net.py	13.96 KB	-rw-r--r--
test_urllib_response.py	2 KB	-rw-r--r--
test_urllibnet.py	9.41 KB	-rw-r--r--
test_urlparse.py	73.73 KB	-rw-r--r--
test_userdict.py	7.56 KB	-rw-r--r--
test_userlist.py	1.97 KB	-rw-r--r--
test_userstring.py	2.52 KB	-rw-r--r--
test_utf8_mode.py	10.31 KB	-rw-r--r--
test_utf8source.py	1.15 KB	-rw-r--r--
test_uu.py	9.2 KB	-rw-r--r--
test_uuid.py	44.26 KB	-rwxr-xr-x
test_venv.py	32.42 KB	-rw-r--r--
test_wait3.py	1.74 KB	-rw-r--r--
test_wait4.py	1.14 KB	-rw-r--r--
test_wave.py	7.64 KB	-rw-r--r--
test_weakref.py	74.32 KB	-rw-r--r--
test_weakset.py	16.3 KB	-rw-r--r--
test_webbrowser.py	10.5 KB	-rw-r--r--
test_winconsoleio.py	6.69 KB	-rw-r--r--
test_winreg.py	22.48 KB	-rw-r--r--
test_winsound.py	5.32 KB	-rw-r--r--
test_with.py	26.02 KB	-rw-r--r--
test_wmi.py	2.89 KB	-rw-r--r--

Code Editor : test_monitoring.py

"""Test suite for the sys.monitoring."""

import collections
import dis
import functools
import operator
import sys
import textwrap
import types
import unittest
import asyncio

PAIR = (0,1)

def f1():
    pass

def f2():
    len([])
    sys.getsizeof(0)

def floop():
    for item in PAIR:
        pass

def gen():
    yield
    yield

def g1():
    for _ in gen():
        pass

TEST_TOOL = 2
TEST_TOOL2 = 3
TEST_TOOL3 = 4

class MonitoringBasicTest(unittest.TestCase):

def test_has_objects(self):
        m = sys.monitoring
        m.events
        m.use_tool_id
        m.free_tool_id
        m.get_tool
        m.get_events
        m.set_events
        m.get_local_events
        m.set_local_events
        m.register_callback
        m.restart_events
        m.DISABLE
        m.MISSING
        m.events.NO_EVENTS

def test_tool(self):
        sys.monitoring.use_tool_id(TEST_TOOL, "MonitoringTest.Tool")
        self.assertEqual(sys.monitoring.get_tool(TEST_TOOL), "MonitoringTest.Tool")
        sys.monitoring.set_events(TEST_TOOL, 15)
        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), 15)
        sys.monitoring.set_events(TEST_TOOL, 0)
        with self.assertRaises(ValueError):
            sys.monitoring.set_events(TEST_TOOL, sys.monitoring.events.C_RETURN)
        with self.assertRaises(ValueError):
            sys.monitoring.set_events(TEST_TOOL, sys.monitoring.events.C_RAISE)
        sys.monitoring.free_tool_id(TEST_TOOL)
        self.assertEqual(sys.monitoring.get_tool(TEST_TOOL), None)
        with self.assertRaises(ValueError):
            sys.monitoring.set_events(TEST_TOOL, sys.monitoring.events.CALL)

class MonitoringTestBase:

def setUp(self):
        # Check that a previous test hasn't left monitoring on.
        for tool in range(6):
            self.assertEqual(sys.monitoring.get_events(tool), 0)
        self.assertIs(sys.monitoring.get_tool(TEST_TOOL), None)
        self.assertIs(sys.monitoring.get_tool(TEST_TOOL2), None)
        self.assertIs(sys.monitoring.get_tool(TEST_TOOL3), None)
        sys.monitoring.use_tool_id(TEST_TOOL, "test " + self.__class__.__name__)
        sys.monitoring.use_tool_id(TEST_TOOL2, "test2 " + self.__class__.__name__)
        sys.monitoring.use_tool_id(TEST_TOOL3, "test3 " + self.__class__.__name__)

def tearDown(self):
        # Check that test hasn't left monitoring on.
        for tool in range(6):
            self.assertEqual(sys.monitoring.get_events(tool), 0)
        sys.monitoring.free_tool_id(TEST_TOOL)
        sys.monitoring.free_tool_id(TEST_TOOL2)
        sys.monitoring.free_tool_id(TEST_TOOL3)

class MonitoringCountTest(MonitoringTestBase, unittest.TestCase):

def check_event_count(self, func, event, expected):

class Counter:
            def __init__(self):
                self.count = 0
            def __call__(self, *args):
                self.count += 1

counter = Counter()
        sys.monitoring.register_callback(TEST_TOOL, event, counter)
        if event == E.C_RETURN or event == E.C_RAISE:
            sys.monitoring.set_events(TEST_TOOL, E.CALL)
        else:
            sys.monitoring.set_events(TEST_TOOL, event)
        self.assertEqual(counter.count, 0)
        counter.count = 0
        func()
        self.assertEqual(counter.count, expected)
        prev = sys.monitoring.register_callback(TEST_TOOL, event, None)
        counter.count = 0
        func()
        self.assertEqual(counter.count, 0)
        self.assertEqual(prev, counter)
        sys.monitoring.set_events(TEST_TOOL, 0)

def test_start_count(self):
        self.check_event_count(f1, E.PY_START, 1)

def test_resume_count(self):
        self.check_event_count(g1, E.PY_RESUME, 2)

def test_return_count(self):
        self.check_event_count(f1, E.PY_RETURN, 1)

def test_call_count(self):
        self.check_event_count(f2, E.CALL, 3)

def test_c_return_count(self):
        self.check_event_count(f2, E.C_RETURN, 2)

E = sys.monitoring.events

INSTRUMENTED_EVENTS = [
    (E.PY_START, "start"),
    (E.PY_RESUME, "resume"),
    (E.PY_RETURN, "return"),
    (E.PY_YIELD, "yield"),
    (E.JUMP, "jump"),
    (E.BRANCH, "branch"),
]

EXCEPT_EVENTS = [
    (E.RAISE, "raise"),
    (E.PY_UNWIND, "unwind"),
    (E.EXCEPTION_HANDLED, "exception_handled"),
]

SIMPLE_EVENTS = INSTRUMENTED_EVENTS + EXCEPT_EVENTS + [
    (E.C_RAISE, "c_raise"),
    (E.C_RETURN, "c_return"),
]

SIMPLE_EVENT_SET = functools.reduce(operator.or_, [ev for (ev, _) in SIMPLE_EVENTS], 0) | E.CALL

def just_pass():
    pass

just_pass.events = [
    "py_call",
    "start",
    "return",
]

def just_raise():
    raise Exception

just_raise.events = [
    'py_call',
    "start",
    "raise",
    "unwind",
]

def just_call():
    len([])

just_call.events = [
    'py_call',
    "start",
    "c_call",
    "c_return",
    "return",
]

def caught():
    try:
        1/0
    except Exception:
        pass

caught.events = [
    'py_call',
    "start",
    "raise",
    "exception_handled",
    "branch",
    "return",
]

def nested_call():
    just_pass()

nested_call.events = [
    "py_call",
    "start",
    "py_call",
    "start",
    "return",
    "return",
]

PY_CALLABLES = (types.FunctionType, types.MethodType)

class MonitoringEventsBase(MonitoringTestBase):

def gather_events(self, func):
        events = []
        for event, event_name in SIMPLE_EVENTS:
            def record(*args, event_name=event_name):
                events.append(event_name)
            sys.monitoring.register_callback(TEST_TOOL, event, record)
        def record_call(code, offset, obj, arg):
            if isinstance(obj, PY_CALLABLES):
                events.append("py_call")
            else:
                events.append("c_call")
        sys.monitoring.register_callback(TEST_TOOL, E.CALL, record_call)
        sys.monitoring.set_events(TEST_TOOL, SIMPLE_EVENT_SET)
        events = []
        try:
            func()
        except:
            pass
        sys.monitoring.set_events(TEST_TOOL, 0)
        #Remove the final event, the call to `sys.monitoring.set_events`
        events = events[:-1]
        return events

def check_events(self, func, expected=None):
        events = self.gather_events(func)
        if expected is None:
            expected = func.events
        self.assertEqual(events, expected)

class MonitoringEventsTest(MonitoringEventsBase, unittest.TestCase):

def test_just_pass(self):
        self.check_events(just_pass)

def test_just_raise(self):
        try:
            self.check_events(just_raise)
        except Exception:
            pass
        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), 0)

def test_just_call(self):
        self.check_events(just_call)

def test_caught(self):
        self.check_events(caught)

def test_nested_call(self):
        self.check_events(nested_call)

UP_EVENTS = (E.C_RETURN, E.C_RAISE, E.PY_RETURN, E.PY_UNWIND, E.PY_YIELD)
DOWN_EVENTS = (E.PY_START, E.PY_RESUME)

from test.profilee import testfunc

class SimulateProfileTest(MonitoringEventsBase, unittest.TestCase):

def test_balanced(self):
        events = self.gather_events(testfunc)
        c = collections.Counter(events)
        self.assertEqual(c["c_call"], c["c_return"])
        self.assertEqual(c["start"], c["return"] + c["unwind"])
        self.assertEqual(c["raise"], c["exception_handled"] + c["unwind"])

def test_frame_stack(self):
        self.maxDiff = None
        stack = []
        errors = []
        seen = set()
        def up(*args):
            frame = sys._getframe(1)
            if not stack:
                errors.append("empty")
            else:
                expected = stack.pop()
                if frame != expected:
                    errors.append(f" Popping {frame} expected {expected}")
        def down(*args):
            frame = sys._getframe(1)
            stack.append(frame)
            seen.add(frame.f_code)
        def call(code, offset, callable, arg):
            if not isinstance(callable, PY_CALLABLES):
                stack.append(sys._getframe(1))
        for event in UP_EVENTS:
            sys.monitoring.register_callback(TEST_TOOL, event, up)
        for event in DOWN_EVENTS:
            sys.monitoring.register_callback(TEST_TOOL, event, down)
        sys.monitoring.register_callback(TEST_TOOL, E.CALL, call)
        sys.monitoring.set_events(TEST_TOOL, SIMPLE_EVENT_SET)
        testfunc()
        sys.monitoring.set_events(TEST_TOOL, 0)
        self.assertEqual(errors, [])
        self.assertEqual(stack, [sys._getframe()])
        self.assertEqual(len(seen), 9)

class CounterWithDisable:

def __init__(self):
        self.disable = False
        self.count = 0

def __call__(self, *args):
        self.count += 1
        if self.disable:
            return sys.monitoring.DISABLE

class RecorderWithDisable:

def __init__(self, events):
        self.disable = False
        self.events = events

def __call__(self, code, event):
        self.events.append(event)
        if self.disable:
            return sys.monitoring.DISABLE

class MontoringDisableAndRestartTest(MonitoringTestBase, unittest.TestCase):

def test_disable(self):
        try:
            counter = CounterWithDisable()
            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter)
            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
            self.assertEqual(counter.count, 0)
            counter.count = 0
            f1()
            self.assertEqual(counter.count, 1)
            counter.disable = True
            counter.count = 0
            f1()
            self.assertEqual(counter.count, 1)
            counter.count = 0
            f1()
            self.assertEqual(counter.count, 0)
            sys.monitoring.set_events(TEST_TOOL, 0)
        finally:
            sys.monitoring.restart_events()

def test_restart(self):
        try:
            counter = CounterWithDisable()
            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter)
            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
            counter.disable = True
            f1()
            counter.count = 0
            f1()
            self.assertEqual(counter.count, 0)
            sys.monitoring.restart_events()
            counter.count = 0
            f1()
            self.assertEqual(counter.count, 1)
            sys.monitoring.set_events(TEST_TOOL, 0)
        finally:
            sys.monitoring.restart_events()

class MultipleMonitorsTest(MonitoringTestBase, unittest.TestCase):

def test_two_same(self):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            counter1 = CounterWithDisable()
            counter2 = CounterWithDisable()
            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, counter2)
            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
            sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
            self.assertEqual(sys.monitoring._all_events(), {'PY_START': (1 << TEST_TOOL) | (1 << TEST_TOOL2)})
            counter1.count = 0
            counter2.count = 0
            f1()
            count1 = counter1.count
            count2 = counter2.count
            self.assertEqual((count1, count2), (1, 1))
        finally:
            sys.monitoring.set_events(TEST_TOOL, 0)
            sys.monitoring.set_events(TEST_TOOL2, 0)
            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, None)
            self.assertEqual(sys.monitoring._all_events(), {})

def test_three_same(self):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            counter1 = CounterWithDisable()
            counter2 = CounterWithDisable()
            counter3 = CounterWithDisable()
            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, counter2)
            sys.monitoring.register_callback(TEST_TOOL3, E.PY_START, counter3)
            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
            sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
            sys.monitoring.set_events(TEST_TOOL3, E.PY_START)
            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
            self.assertEqual(sys.monitoring.get_events(TEST_TOOL3), E.PY_START)
            self.assertEqual(sys.monitoring._all_events(), {'PY_START': (1 << TEST_TOOL) | (1 << TEST_TOOL2) | (1 << TEST_TOOL3)})
            counter1.count = 0
            counter2.count = 0
            counter3.count = 0
            f1()
            count1 = counter1.count
            count2 = counter2.count
            count3 = counter3.count
            self.assertEqual((count1, count2, count3), (1, 1, 1))
        finally:
            sys.monitoring.set_events(TEST_TOOL, 0)
            sys.monitoring.set_events(TEST_TOOL2, 0)
            sys.monitoring.set_events(TEST_TOOL3, 0)
            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, None)
            sys.monitoring.register_callback(TEST_TOOL3, E.PY_START, None)
            self.assertEqual(sys.monitoring._all_events(), {})

def test_two_different(self):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            counter1 = CounterWithDisable()
            counter2 = CounterWithDisable()
            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
            sys.monitoring.register_callback(TEST_TOOL2, E.PY_RETURN, counter2)
            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
            sys.monitoring.set_events(TEST_TOOL2, E.PY_RETURN)
            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_RETURN)
            self.assertEqual(sys.monitoring._all_events(), {'PY_START': 1 << TEST_TOOL, 'PY_RETURN': 1 << TEST_TOOL2})
            counter1.count = 0
            counter2.count = 0
            f1()
            count1 = counter1.count
            count2 = counter2.count
            self.assertEqual((count1, count2), (1, 1))
        finally:
            sys.monitoring.set_events(TEST_TOOL, 0)
            sys.monitoring.set_events(TEST_TOOL2, 0)
            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
            sys.monitoring.register_callback(TEST_TOOL2, E.PY_RETURN, None)
            self.assertEqual(sys.monitoring._all_events(), {})

def test_two_with_disable(self):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            counter1 = CounterWithDisable()
            counter2 = CounterWithDisable()
            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, counter2)
            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
            sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
            self.assertEqual(sys.monitoring._all_events(), {'PY_START': (1 << TEST_TOOL) | (1 << TEST_TOOL2)})
            counter1.count = 0
            counter2.count = 0
            counter1.disable = True
            f1()
            count1 = counter1.count
            count2 = counter2.count
            self.assertEqual((count1, count2), (1, 1))
            counter1.count = 0
            counter2.count = 0
            f1()
            count1 = counter1.count
            count2 = counter2.count
            self.assertEqual((count1, count2), (0, 1))
        finally:
            sys.monitoring.set_events(TEST_TOOL, 0)
            sys.monitoring.set_events(TEST_TOOL2, 0)
            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, None)
            self.assertEqual(sys.monitoring._all_events(), {})
            sys.monitoring.restart_events()

def test_with_instruction_event(self):
        """Test that the second tool can set events with instruction events set by the first tool."""
        def f():
            pass
        code = f.__code__

try:
            self.assertEqual(sys.monitoring._all_events(), {})
            sys.monitoring.set_local_events(TEST_TOOL, code, E.INSTRUCTION | E.LINE)
            sys.monitoring.set_local_events(TEST_TOOL2, code, E.LINE)
        finally:
            sys.monitoring.set_events(TEST_TOOL, 0)
            sys.monitoring.set_events(TEST_TOOL2, 0)
            self.assertEqual(sys.monitoring._all_events(), {})

class LineMonitoringTest(MonitoringTestBase, unittest.TestCase):

def test_lines_single(self):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            events = []
            recorder = RecorderWithDisable(events)
            sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
            sys.monitoring.set_events(TEST_TOOL, E.LINE)
            f1()
            sys.monitoring.set_events(TEST_TOOL, 0)
            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
            start = LineMonitoringTest.test_lines_single.__code__.co_firstlineno
            self.assertEqual(events, [start+7, 16, start+8])
        finally:
            sys.monitoring.set_events(TEST_TOOL, 0)
            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
            self.assertEqual(sys.monitoring._all_events(), {})
            sys.monitoring.restart_events()

def test_lines_loop(self):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            events = []
            recorder = RecorderWithDisable(events)
            sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
            sys.monitoring.set_events(TEST_TOOL, E.LINE)
            floop()
            sys.monitoring.set_events(TEST_TOOL, 0)
            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
            start = LineMonitoringTest.test_lines_loop.__code__.co_firstlineno
            self.assertEqual(events, [start+7, 23, 24, 23, 24, 23, start+8])
        finally:
            sys.monitoring.set_events(TEST_TOOL, 0)
            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
            self.assertEqual(sys.monitoring._all_events(), {})
            sys.monitoring.restart_events()

def test_lines_two(self):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            events = []
            recorder = RecorderWithDisable(events)
            events2 = []
            recorder2 = RecorderWithDisable(events2)
            sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
            sys.monitoring.register_callback(TEST_TOOL2, E.LINE, recorder2)
            sys.monitoring.set_events(TEST_TOOL, E.LINE); sys.monitoring.set_events(TEST_TOOL2, E.LINE)
            f1()
            sys.monitoring.set_events(TEST_TOOL, 0); sys.monitoring.set_events(TEST_TOOL2, 0)
            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
            sys.monitoring.register_callback(TEST_TOOL2, E.LINE, None)
            start = LineMonitoringTest.test_lines_two.__code__.co_firstlineno
            expected = [start+10, 16, start+11]
            self.assertEqual(events, expected)
            self.assertEqual(events2, expected)
        finally:
            sys.monitoring.set_events(TEST_TOOL, 0)
            sys.monitoring.set_events(TEST_TOOL2, 0)
            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
            sys.monitoring.register_callback(TEST_TOOL2, E.LINE, None)
            self.assertEqual(sys.monitoring._all_events(), {})
            sys.monitoring.restart_events()

def check_lines(self, func, expected, tool=TEST_TOOL):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            events = []
            recorder = RecorderWithDisable(events)
            sys.monitoring.register_callback(tool, E.LINE, recorder)
            sys.monitoring.set_events(tool, E.LINE)
            func()
            sys.monitoring.set_events(tool, 0)
            sys.monitoring.register_callback(tool, E.LINE, None)
            lines = [ line - func.__code__.co_firstlineno for line in events[1:-1] ]
            self.assertEqual(lines, expected)
        finally:
            sys.monitoring.set_events(tool, 0)

def test_linear(self):

def func():
            line = 1
            line = 2
            line = 3
            line = 4
            line = 5

self.check_lines(func, [1,2,3,4,5])

def test_branch(self):
        def func():
            if "true".startswith("t"):
                line = 2
                line = 3
            else:
                line = 5
            line = 6

self.check_lines(func, [1,2,3,6])

def test_try_except(self):

def func1():
            try:
                line = 2
                line = 3
            except:
                line = 5
            line = 6

self.check_lines(func1, [1,2,3,6])

def func2():
            try:
                line = 2
                raise 3
            except:
                line = 5
            line = 6

self.check_lines(func2, [1,2,3,4,5,6])

class TestDisable(MonitoringTestBase, unittest.TestCase):

def gen(self, cond):
        for i in range(10):
            if cond:
                yield 1
            else:
                yield 2

def raise_handle_reraise(self):
        try:
            1/0
        except:
            raise

def test_disable_legal_events(self):
        for event, name in INSTRUMENTED_EVENTS:
            try:
                counter = CounterWithDisable()
                counter.disable = True
                sys.monitoring.register_callback(TEST_TOOL, event, counter)
                sys.monitoring.set_events(TEST_TOOL, event)
                for _ in self.gen(1):
                    pass
                self.assertLess(counter.count, 4)
            finally:
                sys.monitoring.set_events(TEST_TOOL, 0)
                sys.monitoring.register_callback(TEST_TOOL, event, None)

def test_disable_illegal_events(self):
        for event, name in EXCEPT_EVENTS:
            try:
                counter = CounterWithDisable()
                counter.disable = True
                sys.monitoring.register_callback(TEST_TOOL, event, counter)
                sys.monitoring.set_events(TEST_TOOL, event)
                with self.assertRaises(ValueError):
                    self.raise_handle_reraise()
            finally:
                sys.monitoring.set_events(TEST_TOOL, 0)
                sys.monitoring.register_callback(TEST_TOOL, event, None)

class ExceptionRecorder:

event_type = E.RAISE

def __init__(self, events):
        self.events = events

def __call__(self, code, offset, exc):
        self.events.append(("raise", type(exc)))

class CheckEvents(MonitoringTestBase, unittest.TestCase):

def get_events(self, func, tool, recorders):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            event_list = []
            all_events = 0
            for recorder in recorders:
                ev = recorder.event_type
                sys.monitoring.register_callback(tool, ev, recorder(event_list))
                all_events |= ev
            sys.monitoring.set_events(tool, all_events)
            func()
            sys.monitoring.set_events(tool, 0)
            for recorder in recorders:
                sys.monitoring.register_callback(tool, recorder.event_type, None)
            return event_list
        finally:
            sys.monitoring.set_events(tool, 0)
            for recorder in recorders:
                sys.monitoring.register_callback(tool, recorder.event_type, None)

def check_events(self, func, expected, tool=TEST_TOOL, recorders=(ExceptionRecorder,)):
        events = self.get_events(func, tool, recorders)
        if events != expected:
            print(events, file = sys.stderr)
        self.assertEqual(events, expected)

def check_balanced(self, func, recorders):
        events = self.get_events(func, TEST_TOOL, recorders)
        self.assertEqual(len(events)%2, 0)
        for r, h in zip(events[::2],events[1::2]):
            r0 = r[0]
            self.assertIn(r0, ("raise", "reraise"))
            h0 = h[0]
            self.assertIn(h0, ("handled", "unwind"))
            self.assertEqual(r[1], h[1])

class StopiterationRecorder(ExceptionRecorder):

event_type = E.STOP_ITERATION

class ReraiseRecorder(ExceptionRecorder):

event_type = E.RERAISE

def __call__(self, code, offset, exc):
        self.events.append(("reraise", type(exc)))

class UnwindRecorder(ExceptionRecorder):

event_type = E.PY_UNWIND

def __call__(self, code, offset, exc):
        self.events.append(("unwind", type(exc)))

class ExceptionHandledRecorder(ExceptionRecorder):

event_type = E.EXCEPTION_HANDLED

def __call__(self, code, offset, exc):
        self.events.append(("handled", type(exc)))

class ThrowRecorder(ExceptionRecorder):

event_type = E.PY_THROW

def __call__(self, code, offset, exc):
        self.events.append(("throw", type(exc)))

class ExceptionMonitoringTest(CheckEvents):

exception_recorders = (
        ExceptionRecorder,
        ReraiseRecorder,
        ExceptionHandledRecorder,
        UnwindRecorder
    )

def test_simple_try_except(self):

def func1():
            try:
                line = 2
                raise KeyError
            except:
                line = 5
            line = 6

self.check_events(func1, [("raise", KeyError)])

def test_implicit_stop_iteration(self):

def gen():
            yield 1
            return 2

def implicit_stop_iteration():
            for _ in gen():
                pass

self.check_events(implicit_stop_iteration, [("raise", StopIteration)], recorders=(StopiterationRecorder,))

initial = [
        ("raise", ZeroDivisionError),
        ("handled", ZeroDivisionError)
    ]

reraise = [
        ("reraise", ZeroDivisionError),
        ("handled", ZeroDivisionError)
    ]

def test_explicit_reraise(self):

def func():
            try:
                try:
                    1/0
                except:
                    raise
            except:
                pass

self.check_balanced(
            func,
            recorders = self.exception_recorders)

def test_explicit_reraise_named(self):

def func():
            try:
                try:
                    1/0
                except Exception as ex:
                    raise
            except:
                pass

self.check_balanced(
            func,
            recorders = self.exception_recorders)

def test_implicit_reraise(self):

def func():
            try:
                try:
                    1/0
                except ValueError:
                    pass
            except:
                pass

self.check_balanced(
            func,
            recorders = self.exception_recorders)

def test_implicit_reraise_named(self):

def func():
            try:
                try:
                    1/0
                except ValueError as ex:
                    pass
            except:
                pass

self.check_balanced(
            func,
            recorders = self.exception_recorders)

def test_try_finally(self):

def func():
            try:
                try:
                    1/0
                finally:
                    pass
            except:
                pass

self.check_balanced(
            func,
            recorders = self.exception_recorders)

def test_async_for(self):

def func():

async def async_generator():
                for i in range(1):
                    raise ZeroDivisionError
                    yield i

async def async_loop():
                try:
                    async for item in async_generator():
                        pass
                except Exception:
                    pass

try:
                async_loop().send(None)
            except StopIteration:
                pass

self.check_balanced(
            func,
            recorders = self.exception_recorders)

def test_throw(self):

def gen():
            yield 1
            yield 2

def func():
            try:
                g = gen()
                next(g)
                g.throw(IndexError)
            except IndexError:
                pass

self.check_balanced(
            func,
            recorders = self.exception_recorders)

events = self.get_events(
            func,
            TEST_TOOL,
            self.exception_recorders + (ThrowRecorder,)
        )
        self.assertEqual(events[0], ("throw", IndexError))

class LineRecorder:

event_type = E.LINE

def __init__(self, events):
        self.events = events

def __call__(self, code, line):
        self.events.append(("line", code.co_name, line - code.co_firstlineno))

class CallRecorder:

event_type = E.CALL

def __init__(self, events):
        self.events = events

def __call__(self, code, offset, func, arg):
        self.events.append(("call", func.__name__, arg))

class CEventRecorder:

def __init__(self, events):
        self.events = events

def __call__(self, code, offset, func, arg):
        self.events.append((self.event_name, func.__name__, arg))

class CReturnRecorder(CEventRecorder):

event_type = E.C_RETURN
    event_name = "C return"

class CRaiseRecorder(CEventRecorder):

event_type = E.C_RAISE
    event_name = "C raise"

MANY_RECORDERS = ExceptionRecorder, CallRecorder, LineRecorder, CReturnRecorder, CRaiseRecorder

class TestManyEvents(CheckEvents):

def test_simple(self):

def func1():
            line1 = 1
            line2 = 2
            line3 = 3

self.check_events(func1, recorders = MANY_RECORDERS, expected = [
            ('line', 'get_events', 10),
            ('call', 'func1', sys.monitoring.MISSING),
            ('line', 'func1', 1),
            ('line', 'func1', 2),
            ('line', 'func1', 3),
            ('line', 'get_events', 11),
            ('call', 'set_events', 2)])

def test_c_call(self):

def func2():
            line1 = 1
            [].append(2)
            line3 = 3

self.check_events(func2, recorders = MANY_RECORDERS, expected = [
            ('line', 'get_events', 10),
            ('call', 'func2', sys.monitoring.MISSING),
            ('line', 'func2', 1),
            ('line', 'func2', 2),
            ('call', 'append', [2]),
            ('C return', 'append', [2]),
            ('line', 'func2', 3),
            ('line', 'get_events', 11),
            ('call', 'set_events', 2)])

def test_try_except(self):

def func3():
            try:
                line = 2
                raise KeyError
            except:
                line = 5
            line = 6

self.check_events(func3, recorders = MANY_RECORDERS, expected = [
            ('line', 'get_events', 10),
            ('call', 'func3', sys.monitoring.MISSING),
            ('line', 'func3', 1),
            ('line', 'func3', 2),
            ('line', 'func3', 3),
            ('raise', KeyError),
            ('line', 'func3', 4),
            ('line', 'func3', 5),
            ('line', 'func3', 6),
            ('line', 'get_events', 11),
            ('call', 'set_events', 2)])

class InstructionRecorder:

event_type = E.INSTRUCTION

def __init__(self, events):
        self.events = events

def __call__(self, code, offset):
        # Filter out instructions in check_events to lower noise
        if code.co_name != "get_events":
            self.events.append(("instruction", code.co_name, offset))

LINE_AND_INSTRUCTION_RECORDERS = InstructionRecorder, LineRecorder

class TestLineAndInstructionEvents(CheckEvents):
    maxDiff = None

def test_simple(self):

def func1():
            line1 = 1
            line2 = 2
            line3 = 3

self.check_events(func1, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
            ('line', 'get_events', 10),
            ('line', 'func1', 1),
            ('instruction', 'func1', 2),
            ('instruction', 'func1', 4),
            ('line', 'func1', 2),
            ('instruction', 'func1', 6),
            ('instruction', 'func1', 8),
            ('line', 'func1', 3),
            ('instruction', 'func1', 10),
            ('instruction', 'func1', 12),
            ('instruction', 'func1', 14),
            ('line', 'get_events', 11)])

def test_c_call(self):

def func2():
            line1 = 1
            [].append(2)
            line3 = 3

self.check_events(func2, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
            ('line', 'get_events', 10),
            ('line', 'func2', 1),
            ('instruction', 'func2', 2),
            ('instruction', 'func2', 4),
            ('line', 'func2', 2),
            ('instruction', 'func2', 6),
            ('instruction', 'func2', 8),
            ('instruction', 'func2', 28),
            ('instruction', 'func2', 30),
            ('instruction', 'func2', 38),
            ('line', 'func2', 3),
            ('instruction', 'func2', 40),
            ('instruction', 'func2', 42),
            ('instruction', 'func2', 44),
            ('line', 'get_events', 11)])

def test_try_except(self):

def func3():
            try:
                line = 2
                raise KeyError
            except:
                line = 5
            line = 6

self.check_events(func3, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
            ('line', 'get_events', 10),
            ('line', 'func3', 1),
            ('instruction', 'func3', 2),
            ('line', 'func3', 2),
            ('instruction', 'func3', 4),
            ('instruction', 'func3', 6),
            ('line', 'func3', 3),
            ('instruction', 'func3', 8),
            ('instruction', 'func3', 18),
            ('instruction', 'func3', 20),
            ('line', 'func3', 4),
            ('instruction', 'func3', 22),
            ('line', 'func3', 5),
            ('instruction', 'func3', 24),
            ('instruction', 'func3', 26),
            ('instruction', 'func3', 28),
            ('line', 'func3', 6),
            ('instruction', 'func3', 30),
            ('instruction', 'func3', 32),
            ('instruction', 'func3', 34),
            ('line', 'get_events', 11)])

def test_with_restart(self):
        def func1():
            line1 = 1
            line2 = 2
            line3 = 3

sys.monitoring.restart_events()

class TestInstallIncrementally(MonitoringTestBase, unittest.TestCase):

def check_events(self, func, must_include, tool=TEST_TOOL, recorders=(ExceptionRecorder,)):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            event_list = []
            all_events = 0
            for recorder in recorders:
                all_events |= recorder.event_type
                sys.monitoring.set_events(tool, all_events)
            for recorder in recorders:
                sys.monitoring.register_callback(tool, recorder.event_type, recorder(event_list))
            func()
            sys.monitoring.set_events(tool, 0)
            for recorder in recorders:
                sys.monitoring.register_callback(tool, recorder.event_type, None)
            for line in must_include:
                self.assertIn(line, event_list)
        finally:
            sys.monitoring.set_events(tool, 0)
            for recorder in recorders:
                sys.monitoring.register_callback(tool, recorder.event_type, None)

@staticmethod
    def func1():
        line1 = 1

MUST_INCLUDE_LI = [
            ('instruction', 'func1', 2),
            ('line', 'func1', 2),
            ('instruction', 'func1', 4),
            ('instruction', 'func1', 6)]

def test_line_then_instruction(self):
        recorders = [ LineRecorder, InstructionRecorder ]
        self.check_events(self.func1,
                          recorders = recorders, must_include = self.MUST_INCLUDE_LI)

def test_instruction_then_line(self):
        recorders = [ InstructionRecorder, LineRecorder ]
        self.check_events(self.func1,
                          recorders = recorders, must_include = self.MUST_INCLUDE_LI)

@staticmethod
    def func2():
        len(())

MUST_INCLUDE_CI = [
            ('instruction', 'func2', 2),
            ('call', 'func2', sys.monitoring.MISSING),
            ('call', 'len', ()),
            ('instruction', 'func2', 12),
            ('instruction', 'func2', 14)]

def test_call_then_instruction(self):
        recorders = [ CallRecorder, InstructionRecorder ]
        self.check_events(self.func2,
                          recorders = recorders, must_include = self.MUST_INCLUDE_CI)

def test_instruction_then_call(self):
        recorders = [ InstructionRecorder, CallRecorder ]
        self.check_events(self.func2,
                          recorders = recorders, must_include = self.MUST_INCLUDE_CI)

LOCAL_RECORDERS = CallRecorder, LineRecorder, CReturnRecorder, CRaiseRecorder

class TestLocalEvents(MonitoringTestBase, unittest.TestCase):

def check_events(self, func, expected, tool=TEST_TOOL, recorders=()):
        try:
            self.assertEqual(sys.monitoring._all_events(), {})
            event_list = []
            all_events = 0
            for recorder in recorders:
                ev = recorder.event_type
                sys.monitoring.register_callback(tool, ev, recorder(event_list))
                all_events |= ev
            sys.monitoring.set_local_events(tool, func.__code__, all_events)
            func()
            sys.monitoring.set_local_events(tool, func.__code__, 0)
            for recorder in recorders:
                sys.monitoring.register_callback(tool, recorder.event_type, None)
            self.assertEqual(event_list, expected)
        finally:
            sys.monitoring.set_local_events(tool, func.__code__, 0)
            for recorder in recorders:
                sys.monitoring.register_callback(tool, recorder.event_type, None)

def test_simple(self):

def func1():
            line1 = 1
            line2 = 2
            line3 = 3

self.check_events(func1, recorders = LOCAL_RECORDERS, expected = [
            ('line', 'func1', 1),
            ('line', 'func1', 2),
            ('line', 'func1', 3)])

def test_c_call(self):

def func2():
            line1 = 1
            [].append(2)
            line3 = 3

self.check_events(func2, recorders = LOCAL_RECORDERS, expected = [
            ('line', 'func2', 1),
            ('line', 'func2', 2),
            ('call', 'append', [2]),
            ('C return', 'append', [2]),
            ('line', 'func2', 3)])

def test_try_except(self):

def func3():
            try:
                line = 2
                raise KeyError
            except:
                line = 5
            line = 6

self.check_events(func3, recorders = LOCAL_RECORDERS, expected = [
            ('line', 'func3', 1),
            ('line', 'func3', 2),
            ('line', 'func3', 3),
            ('line', 'func3', 4),
            ('line', 'func3', 5),
            ('line', 'func3', 6)])

def test_set_non_local_event(self):
        with self.assertRaises(ValueError):
            sys.monitoring.set_local_events(TEST_TOOL, just_call.__code__, E.RAISE)

def line_from_offset(code, offset):
    for start, end, line in code.co_lines():
        if start <= offset < end:
            if line is None:
                return f"[offset={offset}]"
            return line - code.co_firstlineno
    return -1

class JumpRecorder:

event_type = E.JUMP
    name = "jump"

def __init__(self, events):
        self.events = events

def __call__(self, code, from_, to):
        from_line = line_from_offset(code, from_)
        to_line = line_from_offset(code, to)
        self.events.append((self.name, code.co_name, from_line, to_line))

class BranchRecorder(JumpRecorder):

event_type = E.BRANCH
    name = "branch"

class ReturnRecorder:

event_type = E.PY_RETURN

def __init__(self, events):
        self.events = events

def __call__(self, code, offset, val):
        self.events.append(("return", val))

JUMP_AND_BRANCH_RECORDERS = JumpRecorder, BranchRecorder
JUMP_BRANCH_AND_LINE_RECORDERS = JumpRecorder, BranchRecorder, LineRecorder
FLOW_AND_LINE_RECORDERS = JumpRecorder, BranchRecorder, LineRecorder, ExceptionRecorder, ReturnRecorder

class TestBranchAndJumpEvents(CheckEvents):
    maxDiff = None

def test_loop(self):

def func():
            x = 1
            for a in range(2):
                if a:
                    x = 4
                else:
                    x = 6

self.check_events(func, recorders = JUMP_AND_BRANCH_RECORDERS, expected = [
            ('branch', 'func', 2, 2),
            ('branch', 'func', 3, 6),
            ('jump', 'func', 6, 2),
            ('branch', 'func', 2, 2),
            ('branch', 'func', 3, 4),
            ('jump', 'func', 4, 2),
            ('branch', 'func', 2, 2)])

self.check_events(func, recorders = JUMP_BRANCH_AND_LINE_RECORDERS, expected = [
            ('line', 'get_events', 10),
            ('line', 'func', 1),
            ('line', 'func', 2),
            ('branch', 'func', 2, 2),
            ('line', 'func', 3),
            ('branch', 'func', 3, 6),
            ('line', 'func', 6),
            ('jump', 'func', 6, 2),
            ('line', 'func', 2),
            ('branch', 'func', 2, 2),
            ('line', 'func', 3),
            ('branch', 'func', 3, 4),
            ('line', 'func', 4),
            ('jump', 'func', 4, 2),
            ('line', 'func', 2),
            ('branch', 'func', 2, 2),
            ('line', 'get_events', 11)])

def test_except_star(self):

class Foo:
            def meth(self):
                pass

def func():
            try:
                try:
                    raise KeyError
                except* Exception as e:
                    f = Foo(); f.meth()
            except KeyError:
                pass

self.check_events(func, recorders = JUMP_BRANCH_AND_LINE_RECORDERS, expected = [
            ('line', 'get_events', 10),
            ('line', 'func', 1),
            ('line', 'func', 2),
            ('line', 'func', 3),
            ('line', 'func', 4),
            ('branch', 'func', 4, 4),
            ('line', 'func', 5),
            ('line', 'meth', 1),
            ('jump', 'func', 5, 5),
            ('jump', 'func', 5, '[offset=114]'),
            ('branch', 'func', '[offset=120]', '[offset=122]'),
            ('line', 'get_events', 11)])

self.check_events(func, recorders = FLOW_AND_LINE_RECORDERS, expected = [
            ('line', 'get_events', 10),
            ('line', 'func', 1),
            ('line', 'func', 2),
            ('line', 'func', 3),
            ('raise', KeyError),
            ('line', 'func', 4),
            ('branch', 'func', 4, 4),
            ('line', 'func', 5),
            ('line', 'meth', 1),
            ('return', None),
            ('jump', 'func', 5, 5),
            ('jump', 'func', 5, '[offset=114]'),
            ('branch', 'func', '[offset=120]', '[offset=122]'),
            ('return', None),
            ('line', 'get_events', 11)])

class TestLoadSuperAttr(CheckEvents):
    RECORDERS = CallRecorder, LineRecorder, CRaiseRecorder, CReturnRecorder

def _exec(self, co):
        d = {}
        exec(co, d, d)
        return d

def _exec_super(self, codestr, optimized=False):
        # The compiler checks for statically visible shadowing of the name
        # `super`, and declines to emit `LOAD_SUPER_ATTR` if shadowing is found.
        # So inserting `super = super` prevents the compiler from emitting
        # `LOAD_SUPER_ATTR`, and allows us to test that monitoring events for
        # `LOAD_SUPER_ATTR` are equivalent to those we'd get from the
        # un-optimized `LOAD_GLOBAL super; CALL; LOAD_ATTR` form.
        assignment = "x = 1" if optimized else "super = super"
        codestr = f"{assignment}\n{textwrap.dedent(codestr)}"
        co = compile(codestr, "<string>", "exec")
        # validate that we really do have a LOAD_SUPER_ATTR, only when optimized
        self.assertEqual(self._has_load_super_attr(co), optimized)
        return self._exec(co)

def _has_load_super_attr(self, co):
        has = any(instr.opname == "LOAD_SUPER_ATTR" for instr in dis.get_instructions(co))
        if not has:
            has = any(
                isinstance(c, types.CodeType) and self._has_load_super_attr(c)
                for c in co.co_consts
            )
        return has

def _super_method_call(self, optimized=False):
        codestr = """
            class A:
                def method(self, x):
                    return x

class B(A):
                def method(self, x):
                    return super(
                    ).method(
                        x
                    )

b = B()
            def f():
                return b.method(1)
        """
        d = self._exec_super(codestr, optimized)
        expected = [
            ('line', 'get_events', 10),
            ('call', 'f', sys.monitoring.MISSING),
            ('line', 'f', 1),
            ('call', 'method', d["b"]),
            ('line', 'method', 1),
            ('call', 'super', sys.monitoring.MISSING),
            ('C return', 'super', sys.monitoring.MISSING),
            ('line', 'method', 2),
            ('line', 'method', 3),
            ('line', 'method', 2),
            ('call', 'method', 1),
            ('line', 'method', 1),
            ('line', 'method', 1),
            ('line', 'get_events', 11),
            ('call', 'set_events', 2),
        ]
        return d["f"], expected

def test_method_call(self):
        nonopt_func, nonopt_expected = self._super_method_call(optimized=False)
        opt_func, opt_expected = self._super_method_call(optimized=True)

self.check_events(nonopt_func, recorders=self.RECORDERS, expected=nonopt_expected)
        self.check_events(opt_func, recorders=self.RECORDERS, expected=opt_expected)

def _super_method_call_error(self, optimized=False):
        codestr = """
            class A:
                def method(self, x):
                    return x

class B(A):
                def method(self, x):
                    return super(
                        x,
                        self,
                    ).method(
                        x
                    )

b = B()
            def f():
                try:
                    return b.method(1)
                except TypeError:
                    pass
                else:
                    assert False, "should have raised TypeError"
        """
        d = self._exec_super(codestr, optimized)
        expected = [
            ('line', 'get_events', 10),
            ('call', 'f', sys.monitoring.MISSING),
            ('line', 'f', 1),
            ('line', 'f', 2),
            ('call', 'method', d["b"]),
            ('line', 'method', 1),
            ('line', 'method', 2),
            ('line', 'method', 3),
            ('line', 'method', 1),
            ('call', 'super', 1),
            ('C raise', 'super', 1),
            ('line', 'f', 3),
            ('line', 'f', 4),
            ('line', 'get_events', 11),
            ('call', 'set_events', 2),
        ]
        return d["f"], expected

def test_method_call_error(self):
        nonopt_func, nonopt_expected = self._super_method_call_error(optimized=False)
        opt_func, opt_expected = self._super_method_call_error(optimized=True)

self.check_events(nonopt_func, recorders=self.RECORDERS, expected=nonopt_expected)
        self.check_events(opt_func, recorders=self.RECORDERS, expected=opt_expected)

def _super_attr(self, optimized=False):
        codestr = """
            class A:
                x = 1

class B(A):
                def method(self):
                    return super(
                    ).x

b = B()
            def f():
                return b.method()
        """
        d = self._exec_super(codestr, optimized)
        expected = [
            ('line', 'get_events', 10),
            ('call', 'f', sys.monitoring.MISSING),
            ('line', 'f', 1),
            ('call', 'method', d["b"]),
            ('line', 'method', 1),
            ('call', 'super', sys.monitoring.MISSING),
            ('C return', 'super', sys.monitoring.MISSING),
            ('line', 'method', 2),
            ('line', 'method', 1),
            ('line', 'get_events', 11),
            ('call', 'set_events', 2)
        ]
        return d["f"], expected

def test_attr(self):
        nonopt_func, nonopt_expected = self._super_attr(optimized=False)
        opt_func, opt_expected = self._super_attr(optimized=True)

self.check_events(nonopt_func, recorders=self.RECORDERS, expected=nonopt_expected)
        self.check_events(opt_func, recorders=self.RECORDERS, expected=opt_expected)

def test_vs_other_type_call(self):
        code_template = textwrap.dedent("""
            class C:
                def method(self):
                    return {cls}().__repr__{call}
            c = C()
            def f():
                return c.method()
        """)

def get_expected(name, call_method, ns):
            repr_arg = 0 if name == "int" else sys.monitoring.MISSING
            return [
                ('line', 'get_events', 10),
                ('call', 'f', sys.monitoring.MISSING),
                ('line', 'f', 1),
                ('call', 'method', ns["c"]),
                ('line', 'method', 1),
                ('call', name, sys.monitoring.MISSING),
                ('C return', name, sys.monitoring.MISSING),
                *(
                    [
                        ('call', '__repr__', repr_arg),
                        ('C return', '__repr__', repr_arg),
                    ] if call_method else []
                ),
                ('line', 'get_events', 11),
                ('call', 'set_events', 2),
            ]

for call_method in [True, False]:
            with self.subTest(call_method=call_method):
                call_str = "()" if call_method else ""
                code_super = code_template.format(cls="super", call=call_str)
                code_int = code_template.format(cls="int", call=call_str)
                co_super = compile(code_super, '<string>', 'exec')
                self.assertTrue(self._has_load_super_attr(co_super))
                ns_super = self._exec(co_super)
                ns_int = self._exec(code_int)

self.check_events(
                    ns_super["f"],
                    recorders=self.RECORDERS,
                    expected=get_expected("super", call_method, ns_super)
                )
                self.check_events(
                    ns_int["f"],
                    recorders=self.RECORDERS,
                    expected=get_expected("int", call_method, ns_int)
                )

class TestSetGetEvents(MonitoringTestBase, unittest.TestCase):

def test_global(self):
        sys.monitoring.set_events(TEST_TOOL, E.PY_START)
        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
        sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
        self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
        sys.monitoring.set_events(TEST_TOOL, 0)
        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), 0)
        sys.monitoring.set_events(TEST_TOOL2,0)
        self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), 0)

def test_local(self):
        code = f1.__code__
        sys.monitoring.set_local_events(TEST_TOOL, code, E.PY_START)
        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), E.PY_START)
        sys.monitoring.set_local_events(TEST_TOOL2, code, E.PY_START)
        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL2, code), E.PY_START)
        sys.monitoring.set_local_events(TEST_TOOL, code, 0)
        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), 0)
        sys.monitoring.set_local_events(TEST_TOOL2, code, 0)
        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL2, code), 0)

class TestUninitialized(unittest.TestCase, MonitoringTestBase):

@staticmethod
    def f():
        pass

def test_get_local_events_uninitialized(self):
        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, self.f.__code__), 0)

class TestRegressions(MonitoringTestBase, unittest.TestCase):

def test_105162(self):
        caught = None

def inner():
            nonlocal caught
            try:
                yield
            except Exception:
                caught = "inner"
                yield

def outer():
            nonlocal caught
            try:
                yield from inner()
            except Exception:
                caught = "outer"
                yield

def run():
            gen = outer()
            gen.send(None)
            gen.throw(Exception)
        run()
        self.assertEqual(caught, "inner")
        caught = None
        try:
            sys.monitoring.set_events(TEST_TOOL, E.PY_RESUME)
            run()
            self.assertEqual(caught, "inner")
        finally:
            sys.monitoring.set_events(TEST_TOOL, 0)

def test_108390(self):

class Foo:
            def __init__(self, set_event):
                if set_event:
                    sys.monitoring.set_events(TEST_TOOL, E.PY_RESUME)

def make_foo_optimized_then_set_event():
            for i in range(100):
                Foo(i == 99)

try:
            make_foo_optimized_then_set_event()
        finally:
            sys.monitoring.set_events(TEST_TOOL, 0)

def test_gh108976(self):
        sys.monitoring.use_tool_id(0, "test")
        self.addCleanup(sys.monitoring.free_tool_id, 0)
        sys.monitoring.set_events(0, 0)
        sys.monitoring.register_callback(0, E.LINE, lambda *args: sys.monitoring.set_events(0, 0))
        sys.monitoring.register_callback(0, E.INSTRUCTION, lambda *args: 0)
        sys.monitoring.set_events(0, E.LINE | E.INSTRUCTION)
        sys.monitoring.set_events(0, 0)

def test_call_function_ex(self):
        def f(a=1, b=2):
            return a + b
        args = (1, 2)
        empty_args = []

call_data = []
        sys.monitoring.use_tool_id(0, "test")
        self.addCleanup(sys.monitoring.free_tool_id, 0)
        sys.monitoring.set_events(0, 0)
        sys.monitoring.register_callback(0, E.CALL, lambda code, offset, callable, arg0: call_data.append((callable, arg0)))
        sys.monitoring.set_events(0, E.CALL)
        f(*args)
        f(*empty_args)
        sys.monitoring.set_events(0, 0)
        self.assertEqual(call_data[0], (f, 1))
        self.assertEqual(call_data[1], (f, sys.monitoring.MISSING))

${this.title}

Code Editor : test_monitoring.py