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__xxinterpchannels.py

from collections import namedtuple
import contextlib
import sys
from textwrap import dedent
import threading
import time
import unittest

from test.support import import_helper

from test.test__xxsubinterpreters import (
    interpreters,
    _run_output,
    clean_up_interpreters,
)

channels = import_helper.import_module('_xxinterpchannels')

##################################
# helpers

#@contextmanager
#def run_threaded(id, source, **shared):
#    def run():
#        run_interp(id, source, **shared)
#    t = threading.Thread(target=run)
#    t.start()
#    yield
#    t.join()

def run_interp(id, source, **shared):
    _run_interp(id, source, shared)

def _run_interp(id, source, shared, _mainns={}):
    source = dedent(source)
    main = interpreters.get_main()
    if main == id:
        if interpreters.get_current() != main:
            raise RuntimeError
        # XXX Run a func?
        exec(source, _mainns)
    else:
        interpreters.run_string(id, source, shared)

class Interpreter(namedtuple('Interpreter', 'name id')):

@classmethod
    def from_raw(cls, raw):
        if isinstance(raw, cls):
            return raw
        elif isinstance(raw, str):
            return cls(raw)
        else:
            raise NotImplementedError

def __new__(cls, name=None, id=None):
        main = interpreters.get_main()
        if id == main:
            if not name:
                name = 'main'
            elif name != 'main':
                raise ValueError(
                    'name mismatch (expected "main", got "{}")'.format(name))
            id = main
        elif id is not None:
            if not name:
                name = 'interp'
            elif name == 'main':
                raise ValueError('name mismatch (unexpected "main")')
            if not isinstance(id, interpreters.InterpreterID):
                id = interpreters.InterpreterID(id)
        elif not name or name == 'main':
            name = 'main'
            id = main
        else:
            id = interpreters.create()
        self = super().__new__(cls, name, id)
        return self

# XXX expect_channel_closed() is unnecessary once we improve exc propagation.

@contextlib.contextmanager
def expect_channel_closed():
    try:
        yield
    except channels.ChannelClosedError:
        pass
    else:
        assert False, 'channel not closed'

class ChannelAction(namedtuple('ChannelAction', 'action end interp')):

def __new__(cls, action, end=None, interp=None):
        if not end:
            end = 'both'
        if not interp:
            interp = 'main'
        self = super().__new__(cls, action, end, interp)
        return self

def __init__(self, *args, **kwargs):
        if self.action == 'use':
            if self.end not in ('same', 'opposite', 'send', 'recv'):
                raise ValueError(self.end)
        elif self.action in ('close', 'force-close'):
            if self.end not in ('both', 'same', 'opposite', 'send', 'recv'):
                raise ValueError(self.end)
        else:
            raise ValueError(self.action)
        if self.interp not in ('main', 'same', 'other', 'extra'):
            raise ValueError(self.interp)

def resolve_end(self, end):
        if self.end == 'same':
            return end
        elif self.end == 'opposite':
            return 'recv' if end == 'send' else 'send'
        else:
            return self.end

def resolve_interp(self, interp, other, extra):
        if self.interp == 'same':
            return interp
        elif self.interp == 'other':
            if other is None:
                raise RuntimeError
            return other
        elif self.interp == 'extra':
            if extra is None:
                raise RuntimeError
            return extra
        elif self.interp == 'main':
            if interp.name == 'main':
                return interp
            elif other and other.name == 'main':
                return other
            else:
                raise RuntimeError
        # Per __init__(), there aren't any others.

class ChannelState(namedtuple('ChannelState', 'pending closed')):

def __new__(cls, pending=0, *, closed=False):
        self = super().__new__(cls, pending, closed)
        return self

def incr(self):
        return type(self)(self.pending + 1, closed=self.closed)

def decr(self):
        return type(self)(self.pending - 1, closed=self.closed)

def close(self, *, force=True):
        if self.closed:
            if not force or self.pending == 0:
                return self
        return type(self)(0 if force else self.pending, closed=True)

def run_action(cid, action, end, state, *, hideclosed=True):
    if state.closed:
        if action == 'use' and end == 'recv' and state.pending:
            expectfail = False
        else:
            expectfail = True
    else:
        expectfail = False

try:
        result = _run_action(cid, action, end, state)
    except channels.ChannelClosedError:
        if not hideclosed and not expectfail:
            raise
        result = state.close()
    else:
        if expectfail:
            raise ...  # XXX
    return result

def _run_action(cid, action, end, state):
    if action == 'use':
        if end == 'send':
            channels.send(cid, b'spam')
            return state.incr()
        elif end == 'recv':
            if not state.pending:
                try:
                    channels.recv(cid)
                except channels.ChannelEmptyError:
                    return state
                else:
                    raise Exception('expected ChannelEmptyError')
            else:
                channels.recv(cid)
                return state.decr()
        else:
            raise ValueError(end)
    elif action == 'close':
        kwargs = {}
        if end in ('recv', 'send'):
            kwargs[end] = True
        channels.close(cid, **kwargs)
        return state.close()
    elif action == 'force-close':
        kwargs = {
            'force': True,
            }
        if end in ('recv', 'send'):
            kwargs[end] = True
        channels.close(cid, **kwargs)
        return state.close(force=True)
    else:
        raise ValueError(action)

def clean_up_channels():
    for cid in channels.list_all():
        try:
            channels.destroy(cid)
        except channels.ChannelNotFoundError:
            pass  # already destroyed

class TestBase(unittest.TestCase):

def tearDown(self):
        clean_up_channels()
        clean_up_interpreters()

##################################
# channel tests

class ChannelIDTests(TestBase):

def test_default_kwargs(self):
        cid = channels._channel_id(10, force=True)

self.assertEqual(int(cid), 10)
        self.assertEqual(cid.end, 'both')

def test_with_kwargs(self):
        cid = channels._channel_id(10, send=True, force=True)
        self.assertEqual(cid.end, 'send')

cid = channels._channel_id(10, send=True, recv=False, force=True)
        self.assertEqual(cid.end, 'send')

cid = channels._channel_id(10, recv=True, force=True)
        self.assertEqual(cid.end, 'recv')

cid = channels._channel_id(10, recv=True, send=False, force=True)
        self.assertEqual(cid.end, 'recv')

cid = channels._channel_id(10, send=True, recv=True, force=True)
        self.assertEqual(cid.end, 'both')

def test_coerce_id(self):
        class Int(str):
            def __index__(self):
                return 10

cid = channels._channel_id(Int(), force=True)
        self.assertEqual(int(cid), 10)

def test_bad_id(self):
        self.assertRaises(TypeError, channels._channel_id, object())
        self.assertRaises(TypeError, channels._channel_id, 10.0)
        self.assertRaises(TypeError, channels._channel_id, '10')
        self.assertRaises(TypeError, channels._channel_id, b'10')
        self.assertRaises(ValueError, channels._channel_id, -1)
        self.assertRaises(OverflowError, channels._channel_id, 2**64)

def test_bad_kwargs(self):
        with self.assertRaises(ValueError):
            channels._channel_id(10, send=False, recv=False)

def test_does_not_exist(self):
        cid = channels.create()
        with self.assertRaises(channels.ChannelNotFoundError):
            channels._channel_id(int(cid) + 1)  # unforced

def test_str(self):
        cid = channels._channel_id(10, force=True)
        self.assertEqual(str(cid), '10')

def test_repr(self):
        cid = channels._channel_id(10, force=True)
        self.assertEqual(repr(cid), 'ChannelID(10)')

cid = channels._channel_id(10, send=True, force=True)
        self.assertEqual(repr(cid), 'ChannelID(10, send=True)')

cid = channels._channel_id(10, recv=True, force=True)
        self.assertEqual(repr(cid), 'ChannelID(10, recv=True)')

cid = channels._channel_id(10, send=True, recv=True, force=True)
        self.assertEqual(repr(cid), 'ChannelID(10)')

def test_equality(self):
        cid1 = channels.create()
        cid2 = channels._channel_id(int(cid1))
        cid3 = channels.create()

self.assertTrue(cid1 == cid1)
        self.assertTrue(cid1 == cid2)
        self.assertTrue(cid1 == int(cid1))
        self.assertTrue(int(cid1) == cid1)
        self.assertTrue(cid1 == float(int(cid1)))
        self.assertTrue(float(int(cid1)) == cid1)
        self.assertFalse(cid1 == float(int(cid1)) + 0.1)
        self.assertFalse(cid1 == str(int(cid1)))
        self.assertFalse(cid1 == 2**1000)
        self.assertFalse(cid1 == float('inf'))
        self.assertFalse(cid1 == 'spam')
        self.assertFalse(cid1 == cid3)

self.assertFalse(cid1 != cid1)
        self.assertFalse(cid1 != cid2)
        self.assertTrue(cid1 != cid3)

def test_shareable(self):
        chan = channels.create()

obj = channels.create()
        channels.send(chan, obj)
        got = channels.recv(chan)

self.assertEqual(got, obj)
        self.assertIs(type(got), type(obj))
        # XXX Check the following in the channel tests?
        #self.assertIsNot(got, obj)

class ChannelTests(TestBase):

def test_create_cid(self):
        cid = channels.create()
        self.assertIsInstance(cid, channels.ChannelID)

def test_sequential_ids(self):
        before = channels.list_all()
        id1 = channels.create()
        id2 = channels.create()
        id3 = channels.create()
        after = channels.list_all()

self.assertEqual(id2, int(id1) + 1)
        self.assertEqual(id3, int(id2) + 1)
        self.assertEqual(set(after) - set(before), {id1, id2, id3})

def test_ids_global(self):
        id1 = interpreters.create()
        out = _run_output(id1, dedent("""
            import _xxinterpchannels as _channels
            cid = _channels.create()
            print(cid)
            """))
        cid1 = int(out.strip())

id2 = interpreters.create()
        out = _run_output(id2, dedent("""
            import _xxinterpchannels as _channels
            cid = _channels.create()
            print(cid)
            """))
        cid2 = int(out.strip())

self.assertEqual(cid2, int(cid1) + 1)

def test_channel_list_interpreters_none(self):
        """Test listing interpreters for a channel with no associations."""
        # Test for channel with no associated interpreters.
        cid = channels.create()
        send_interps = channels.list_interpreters(cid, send=True)
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(send_interps, [])
        self.assertEqual(recv_interps, [])

def test_channel_list_interpreters_basic(self):
        """Test basic listing channel interpreters."""
        interp0 = interpreters.get_main()
        cid = channels.create()
        channels.send(cid, "send")
        # Test for a channel that has one end associated to an interpreter.
        send_interps = channels.list_interpreters(cid, send=True)
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(send_interps, [interp0])
        self.assertEqual(recv_interps, [])

interp1 = interpreters.create()
        _run_output(interp1, dedent(f"""
            import _xxinterpchannels as _channels
            obj = _channels.recv({cid})
            """))
        # Test for channel that has both ends associated to an interpreter.
        send_interps = channels.list_interpreters(cid, send=True)
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(send_interps, [interp0])
        self.assertEqual(recv_interps, [interp1])

def test_channel_list_interpreters_multiple(self):
        """Test listing interpreters for a channel with many associations."""
        interp0 = interpreters.get_main()
        interp1 = interpreters.create()
        interp2 = interpreters.create()
        interp3 = interpreters.create()
        cid = channels.create()

channels.send(cid, "send")
        _run_output(interp1, dedent(f"""
            import _xxinterpchannels as _channels
            _channels.send({cid}, "send")
            """))
        _run_output(interp2, dedent(f"""
            import _xxinterpchannels as _channels
            obj = _channels.recv({cid})
            """))
        _run_output(interp3, dedent(f"""
            import _xxinterpchannels as _channels
            obj = _channels.recv({cid})
            """))
        send_interps = channels.list_interpreters(cid, send=True)
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(set(send_interps), {interp0, interp1})
        self.assertEqual(set(recv_interps), {interp2, interp3})

def test_channel_list_interpreters_destroyed(self):
        """Test listing channel interpreters with a destroyed interpreter."""
        interp0 = interpreters.get_main()
        interp1 = interpreters.create()
        cid = channels.create()
        channels.send(cid, "send")
        _run_output(interp1, dedent(f"""
            import _xxinterpchannels as _channels
            obj = _channels.recv({cid})
            """))
        # Should be one interpreter associated with each end.
        send_interps = channels.list_interpreters(cid, send=True)
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(send_interps, [interp0])
        self.assertEqual(recv_interps, [interp1])

interpreters.destroy(interp1)
        # Destroyed interpreter should not be listed.
        send_interps = channels.list_interpreters(cid, send=True)
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(send_interps, [interp0])
        self.assertEqual(recv_interps, [])

def test_channel_list_interpreters_released(self):
        """Test listing channel interpreters with a released channel."""
        # Set up one channel with main interpreter on the send end and two
        # subinterpreters on the receive end.
        interp0 = interpreters.get_main()
        interp1 = interpreters.create()
        interp2 = interpreters.create()
        cid = channels.create()
        channels.send(cid, "data")
        _run_output(interp1, dedent(f"""
            import _xxinterpchannels as _channels
            obj = _channels.recv({cid})
            """))
        channels.send(cid, "data")
        _run_output(interp2, dedent(f"""
            import _xxinterpchannels as _channels
            obj = _channels.recv({cid})
            """))
        # Check the setup.
        send_interps = channels.list_interpreters(cid, send=True)
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(len(send_interps), 1)
        self.assertEqual(len(recv_interps), 2)

# Release the main interpreter from the send end.
        channels.release(cid, send=True)
        # Send end should have no associated interpreters.
        send_interps = channels.list_interpreters(cid, send=True)
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(len(send_interps), 0)
        self.assertEqual(len(recv_interps), 2)

# Release one of the subinterpreters from the receive end.
        _run_output(interp2, dedent(f"""
            import _xxinterpchannels as _channels
            _channels.release({cid})
            """))
        # Receive end should have the released interpreter removed.
        send_interps = channels.list_interpreters(cid, send=True)
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(len(send_interps), 0)
        self.assertEqual(recv_interps, [interp1])

def test_channel_list_interpreters_closed(self):
        """Test listing channel interpreters with a closed channel."""
        interp0 = interpreters.get_main()
        interp1 = interpreters.create()
        cid = channels.create()
        # Put something in the channel so that it's not empty.
        channels.send(cid, "send")

# Check initial state.
        send_interps = channels.list_interpreters(cid, send=True)
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(len(send_interps), 1)
        self.assertEqual(len(recv_interps), 0)

# Force close the channel.
        channels.close(cid, force=True)
        # Both ends should raise an error.
        with self.assertRaises(channels.ChannelClosedError):
            channels.list_interpreters(cid, send=True)
        with self.assertRaises(channels.ChannelClosedError):
            channels.list_interpreters(cid, send=False)

def test_channel_list_interpreters_closed_send_end(self):
        """Test listing channel interpreters with a channel's send end closed."""
        interp0 = interpreters.get_main()
        interp1 = interpreters.create()
        cid = channels.create()
        # Put something in the channel so that it's not empty.
        channels.send(cid, "send")

# Close the send end of the channel.
        channels.close(cid, send=True)
        # Send end should raise an error.
        with self.assertRaises(channels.ChannelClosedError):
            channels.list_interpreters(cid, send=True)
        # Receive end should not be closed (since channel is not empty).
        recv_interps = channels.list_interpreters(cid, send=False)
        self.assertEqual(len(recv_interps), 0)

# Close the receive end of the channel from a subinterpreter.
        _run_output(interp1, dedent(f"""
            import _xxinterpchannels as _channels
            _channels.close({cid}, force=True)
            """))
        return
        # Both ends should raise an error.
        with self.assertRaises(channels.ChannelClosedError):
            channels.list_interpreters(cid, send=True)
        with self.assertRaises(channels.ChannelClosedError):
            channels.list_interpreters(cid, send=False)

####################

def test_send_recv_main(self):
        cid = channels.create()
        orig = b'spam'
        channels.send(cid, orig)
        obj = channels.recv(cid)

self.assertEqual(obj, orig)
        self.assertIsNot(obj, orig)

def test_send_recv_same_interpreter(self):
        id1 = interpreters.create()
        out = _run_output(id1, dedent("""
            import _xxinterpchannels as _channels
            cid = _channels.create()
            orig = b'spam'
            _channels.send(cid, orig)
            obj = _channels.recv(cid)
            assert obj is not orig
            assert obj == orig
            """))

def test_send_recv_different_interpreters(self):
        cid = channels.create()
        id1 = interpreters.create()
        out = _run_output(id1, dedent(f"""
            import _xxinterpchannels as _channels
            _channels.send({cid}, b'spam')
            """))
        obj = channels.recv(cid)

self.assertEqual(obj, b'spam')

def test_send_recv_different_threads(self):
        cid = channels.create()

def f():
            while True:
                try:
                    obj = channels.recv(cid)
                    break
                except channels.ChannelEmptyError:
                    time.sleep(0.1)
            channels.send(cid, obj)
        t = threading.Thread(target=f)
        t.start()

channels.send(cid, b'spam')
        t.join()
        obj = channels.recv(cid)

self.assertEqual(obj, b'spam')

def test_send_recv_different_interpreters_and_threads(self):
        cid = channels.create()
        id1 = interpreters.create()
        out = None

def f():
            nonlocal out
            out = _run_output(id1, dedent(f"""
                import time
                import _xxinterpchannels as _channels
                while True:
                    try:
                        obj = _channels.recv({cid})
                        break
                    except _channels.ChannelEmptyError:
                        time.sleep(0.1)
                assert(obj == b'spam')
                _channels.send({cid}, b'eggs')
                """))
        t = threading.Thread(target=f)
        t.start()

channels.send(cid, b'spam')
        t.join()
        obj = channels.recv(cid)

self.assertEqual(obj, b'eggs')

def test_send_not_found(self):
        with self.assertRaises(channels.ChannelNotFoundError):
            channels.send(10, b'spam')

def test_recv_not_found(self):
        with self.assertRaises(channels.ChannelNotFoundError):
            channels.recv(10)

def test_recv_empty(self):
        cid = channels.create()
        with self.assertRaises(channels.ChannelEmptyError):
            channels.recv(cid)

def test_recv_default(self):
        default = object()
        cid = channels.create()
        obj1 = channels.recv(cid, default)
        channels.send(cid, None)
        channels.send(cid, 1)
        channels.send(cid, b'spam')
        channels.send(cid, b'eggs')
        obj2 = channels.recv(cid, default)
        obj3 = channels.recv(cid, default)
        obj4 = channels.recv(cid)
        obj5 = channels.recv(cid, default)
        obj6 = channels.recv(cid, default)

self.assertIs(obj1, default)
        self.assertIs(obj2, None)
        self.assertEqual(obj3, 1)
        self.assertEqual(obj4, b'spam')
        self.assertEqual(obj5, b'eggs')
        self.assertIs(obj6, default)

def test_recv_sending_interp_destroyed(self):
        with self.subTest('closed'):
            cid1 = channels.create()
            interp = interpreters.create()
            interpreters.run_string(interp, dedent(f"""
                import _xxinterpchannels as _channels
                _channels.send({cid1}, b'spam')
                """))
            interpreters.destroy(interp)

with self.assertRaisesRegex(RuntimeError,
                                        f'channel {cid1} is closed'):
                channels.recv(cid1)
            del cid1
        with self.subTest('still open'):
            cid2 = channels.create()
            interp = interpreters.create()
            interpreters.run_string(interp, dedent(f"""
                import _xxinterpchannels as _channels
                _channels.send({cid2}, b'spam')
                """))
            channels.send(cid2, b'eggs')
            interpreters.destroy(interp)

channels.recv(cid2)
            with self.assertRaisesRegex(RuntimeError,
                                        f'channel {cid2} is empty'):
                channels.recv(cid2)
            del cid2

def test_allowed_types(self):
        cid = channels.create()
        objects = [
            None,
            'spam',
            b'spam',
            42,
        ]
        for obj in objects:
            with self.subTest(obj):
                channels.send(cid, obj)
                got = channels.recv(cid)

self.assertEqual(got, obj)
                self.assertIs(type(got), type(obj))
                # XXX Check the following?
                #self.assertIsNot(got, obj)
                # XXX What about between interpreters?

def test_run_string_arg_unresolved(self):
        cid = channels.create()
        interp = interpreters.create()

out = _run_output(interp, dedent("""
            import _xxinterpchannels as _channels
            print(cid.end)
            _channels.send(cid, b'spam')
            """),
            dict(cid=cid.send))
        obj = channels.recv(cid)

self.assertEqual(obj, b'spam')
        self.assertEqual(out.strip(), 'send')

# XXX For now there is no high-level channel into which the
    # sent channel ID can be converted...
    # Note: this test caused crashes on some buildbots (bpo-33615).
    @unittest.skip('disabled until high-level channels exist')
    def test_run_string_arg_resolved(self):
        cid = channels.create()
        cid = channels._channel_id(cid, _resolve=True)
        interp = interpreters.create()

out = _run_output(interp, dedent("""
            import _xxinterpchannels as _channels
            print(chan.id.end)
            _channels.send(chan.id, b'spam')
            """),
            dict(chan=cid.send))
        obj = channels.recv(cid)

self.assertEqual(obj, b'spam')
        self.assertEqual(out.strip(), 'send')

# close

def test_close_single_user(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.recv(cid)
        channels.close(cid)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'eggs')
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_close_multiple_users(self):
        cid = channels.create()
        id1 = interpreters.create()
        id2 = interpreters.create()
        interpreters.run_string(id1, dedent(f"""
            import _xxinterpchannels as _channels
            _channels.send({cid}, b'spam')
            """))
        interpreters.run_string(id2, dedent(f"""
            import _xxinterpchannels as _channels
            _channels.recv({cid})
            """))
        channels.close(cid)
        with self.assertRaises(interpreters.RunFailedError) as cm:
            interpreters.run_string(id1, dedent(f"""
                _channels.send({cid}, b'spam')
                """))
        self.assertIn('ChannelClosedError', str(cm.exception))
        with self.assertRaises(interpreters.RunFailedError) as cm:
            interpreters.run_string(id2, dedent(f"""
                _channels.send({cid}, b'spam')
                """))
        self.assertIn('ChannelClosedError', str(cm.exception))

def test_close_multiple_times(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.recv(cid)
        channels.close(cid)

with self.assertRaises(channels.ChannelClosedError):
            channels.close(cid)

def test_close_empty(self):
        tests = [
            (False, False),
            (True, False),
            (False, True),
            (True, True),
            ]
        for send, recv in tests:
            with self.subTest((send, recv)):
                cid = channels.create()
                channels.send(cid, b'spam')
                channels.recv(cid)
                channels.close(cid, send=send, recv=recv)

with self.assertRaises(channels.ChannelClosedError):
                    channels.send(cid, b'eggs')
                with self.assertRaises(channels.ChannelClosedError):
                    channels.recv(cid)

def test_close_defaults_with_unused_items(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.send(cid, b'ham')

with self.assertRaises(channels.ChannelNotEmptyError):
            channels.close(cid)
        channels.recv(cid)
        channels.send(cid, b'eggs')

def test_close_recv_with_unused_items_unforced(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.send(cid, b'ham')

with self.assertRaises(channels.ChannelNotEmptyError):
            channels.close(cid, recv=True)
        channels.recv(cid)
        channels.send(cid, b'eggs')
        channels.recv(cid)
        channels.recv(cid)
        channels.close(cid, recv=True)

def test_close_send_with_unused_items_unforced(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.send(cid, b'ham')
        channels.close(cid, send=True)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'eggs')
        channels.recv(cid)
        channels.recv(cid)
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_close_both_with_unused_items_unforced(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.send(cid, b'ham')

with self.assertRaises(channels.ChannelNotEmptyError):
            channels.close(cid, recv=True, send=True)
        channels.recv(cid)
        channels.send(cid, b'eggs')
        channels.recv(cid)
        channels.recv(cid)
        channels.close(cid, recv=True)

def test_close_recv_with_unused_items_forced(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.send(cid, b'ham')
        channels.close(cid, recv=True, force=True)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'eggs')
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_close_send_with_unused_items_forced(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.send(cid, b'ham')
        channels.close(cid, send=True, force=True)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'eggs')
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_close_both_with_unused_items_forced(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.send(cid, b'ham')
        channels.close(cid, send=True, recv=True, force=True)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'eggs')
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_close_never_used(self):
        cid = channels.create()
        channels.close(cid)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'spam')
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_close_by_unassociated_interp(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        interp = interpreters.create()
        interpreters.run_string(interp, dedent(f"""
            import _xxinterpchannels as _channels
            _channels.close({cid}, force=True)
            """))
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)
        with self.assertRaises(channels.ChannelClosedError):
            channels.close(cid)

def test_close_used_multiple_times_by_single_user(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.send(cid, b'spam')
        channels.send(cid, b'spam')
        channels.recv(cid)
        channels.close(cid, force=True)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'eggs')
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_channel_list_interpreters_invalid_channel(self):
        cid = channels.create()
        # Test for invalid channel ID.
        with self.assertRaises(channels.ChannelNotFoundError):
            channels.list_interpreters(1000, send=True)

channels.close(cid)
        # Test for a channel that has been closed.
        with self.assertRaises(channels.ChannelClosedError):
            channels.list_interpreters(cid, send=True)

def test_channel_list_interpreters_invalid_args(self):
        # Tests for invalid arguments passed to the API.
        cid = channels.create()
        with self.assertRaises(TypeError):
            channels.list_interpreters(cid)

class ChannelReleaseTests(TestBase):

# XXX Add more test coverage a la the tests for close().

"""
    - main / interp / other
    - run in: current thread / new thread / other thread / different threads
    - end / opposite
    - force / no force
    - used / not used  (associated / not associated)
    - empty / emptied / never emptied / partly emptied
    - closed / not closed
    - released / not released
    - creator (interp) / other
    - associated interpreter not running
    - associated interpreter destroyed
    """

"""
    use
    pre-release
    release
    after
    check
    """

"""
    release in:         main, interp1
    creator:            same, other (incl. interp2)

use:                None,send,recv,send/recv in None,same,other(incl. interp2),same+other(incl. interp2),all
    pre-release:        None,send,recv,both in None,same,other(incl. interp2),same+other(incl. interp2),all
    pre-release forced: None,send,recv,both in None,same,other(incl. interp2),same+other(incl. interp2),all

release:            same
    release forced:     same

use after:          None,send,recv,send/recv in None,same,other(incl. interp2),same+other(incl. interp2),all
    release after:      None,send,recv,send/recv in None,same,other(incl. interp2),same+other(incl. interp2),all
    check released:     send/recv for same/other(incl. interp2)
    check closed:       send/recv for same/other(incl. interp2)
    """

def test_single_user(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.recv(cid)
        channels.release(cid, send=True, recv=True)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'eggs')
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_multiple_users(self):
        cid = channels.create()
        id1 = interpreters.create()
        id2 = interpreters.create()
        interpreters.run_string(id1, dedent(f"""
            import _xxinterpchannels as _channels
            _channels.send({cid}, b'spam')
            """))
        out = _run_output(id2, dedent(f"""
            import _xxinterpchannels as _channels
            obj = _channels.recv({cid})
            _channels.release({cid})
            print(repr(obj))
            """))
        interpreters.run_string(id1, dedent(f"""
            _channels.release({cid})
            """))

self.assertEqual(out.strip(), "b'spam'")

def test_no_kwargs(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.recv(cid)
        channels.release(cid)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'eggs')
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_multiple_times(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.recv(cid)
        channels.release(cid, send=True, recv=True)

with self.assertRaises(channels.ChannelClosedError):
            channels.release(cid, send=True, recv=True)

def test_with_unused_items(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.send(cid, b'ham')
        channels.release(cid, send=True, recv=True)

with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_never_used(self):
        cid = channels.create()
        channels.release(cid)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'spam')
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_by_unassociated_interp(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        interp = interpreters.create()
        interpreters.run_string(interp, dedent(f"""
            import _xxinterpchannels as _channels
            _channels.release({cid})
            """))
        obj = channels.recv(cid)
        channels.release(cid)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'eggs')
        self.assertEqual(obj, b'spam')

def test_close_if_unassociated(self):
        # XXX Something's not right with this test...
        cid = channels.create()
        interp = interpreters.create()
        interpreters.run_string(interp, dedent(f"""
            import _xxinterpchannels as _channels
            obj = _channels.send({cid}, b'spam')
            _channels.release({cid})
            """))

with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

def test_partially(self):
        # XXX Is partial close too weird/confusing?
        cid = channels.create()
        channels.send(cid, None)
        channels.recv(cid)
        channels.send(cid, b'spam')
        channels.release(cid, send=True)
        obj = channels.recv(cid)

self.assertEqual(obj, b'spam')

def test_used_multiple_times_by_single_user(self):
        cid = channels.create()
        channels.send(cid, b'spam')
        channels.send(cid, b'spam')
        channels.send(cid, b'spam')
        channels.recv(cid)
        channels.release(cid, send=True, recv=True)

with self.assertRaises(channels.ChannelClosedError):
            channels.send(cid, b'eggs')
        with self.assertRaises(channels.ChannelClosedError):
            channels.recv(cid)

class ChannelCloseFixture(namedtuple('ChannelCloseFixture',
                                     'end interp other extra creator')):

# Set this to True to avoid creating interpreters, e.g. when
    # scanning through test permutations without running them.
    QUICK = False

def __new__(cls, end, interp, other, extra, creator):
        assert end in ('send', 'recv')
        if cls.QUICK:
            known = {}
        else:
            interp = Interpreter.from_raw(interp)
            other = Interpreter.from_raw(other)
            extra = Interpreter.from_raw(extra)
            known = {
                interp.name: interp,
                other.name: other,
                extra.name: extra,
                }
        if not creator:
            creator = 'same'
        self = super().__new__(cls, end, interp, other, extra, creator)
        self._prepped = set()
        self._state = ChannelState()
        self._known = known
        return self

@property
    def state(self):
        return self._state

@property
    def cid(self):
        try:
            return self._cid
        except AttributeError:
            creator = self._get_interpreter(self.creator)
            self._cid = self._new_channel(creator)
            return self._cid

def get_interpreter(self, interp):
        interp = self._get_interpreter(interp)
        self._prep_interpreter(interp)
        return interp

def expect_closed_error(self, end=None):
        if end is None:
            end = self.end
        if end == 'recv' and self.state.closed == 'send':
            return False
        return bool(self.state.closed)

def prep_interpreter(self, interp):
        self._prep_interpreter(interp)

def record_action(self, action, result):
        self._state = result

def clean_up(self):
        clean_up_interpreters()
        clean_up_channels()

# internal methods

def _new_channel(self, creator):
        if creator.name == 'main':
            return channels.create()
        else:
            ch = channels.create()
            run_interp(creator.id, f"""
                import _xxsubinterpreters
                cid = _xxsubchannels.create()
                # We purposefully send back an int to avoid tying the
                # channel to the other interpreter.
                _xxsubchannels.send({ch}, int(cid))
                del _xxsubinterpreters
                """)
            self._cid = channels.recv(ch)
        return self._cid

def _get_interpreter(self, interp):
        if interp in ('same', 'interp'):
            return self.interp
        elif interp == 'other':
            return self.other
        elif interp == 'extra':
            return self.extra
        else:
            name = interp
            try:
                interp = self._known[name]
            except KeyError:
                interp = self._known[name] = Interpreter(name)
            return interp

def _prep_interpreter(self, interp):
        if interp.id in self._prepped:
            return
        self._prepped.add(interp.id)
        if interp.name == 'main':
            return
        run_interp(interp.id, f"""
            import _xxinterpchannels as channels
            import test.test__xxinterpchannels as helpers
            ChannelState = helpers.ChannelState
            try:
                cid
            except NameError:
                cid = channels._channel_id({self.cid})
            """)

@unittest.skip('these tests take several hours to run')
class ExhaustiveChannelTests(TestBase):

- close after unbound
    """

"""
    use
    pre-close
    close
    after
    check
    """

"""
    close in:         main, interp1
    creator:          same, other, extra

use:              None,send,recv,send/recv in None,same,other,same+other,all
    pre-close:        None,send,recv in None,same,other,same+other,all
    pre-close forced: None,send,recv in None,same,other,same+other,all

close:            same
    close forced:     same

use after:        None,send,recv,send/recv in None,same,other,extra,same+other,all
    close after:      None,send,recv,send/recv in None,same,other,extra,same+other,all
    check closed:     send/recv for same/other(incl. interp2)
    """

def iter_action_sets(self):
        # - used / not used  (associated / not associated)
        # - empty / emptied / never emptied / partly emptied
        # - closed / not closed
        # - released / not released

# never used
        yield []

# only pre-closed (and possible used after)
        for closeactions in self._iter_close_action_sets('same', 'other'):
            yield closeactions
            for postactions in self._iter_post_close_action_sets():
                yield closeactions + postactions
        for closeactions in self._iter_close_action_sets('other', 'extra'):
            yield closeactions
            for postactions in self._iter_post_close_action_sets():
                yield closeactions + postactions

# used
        for useactions in self._iter_use_action_sets('same', 'other'):
            yield useactions
            for closeactions in self._iter_close_action_sets('same', 'other'):
                actions = useactions + closeactions
                yield actions
                for postactions in self._iter_post_close_action_sets():
                    yield actions + postactions
            for closeactions in self._iter_close_action_sets('other', 'extra'):
                actions = useactions + closeactions
                yield actions
                for postactions in self._iter_post_close_action_sets():
                    yield actions + postactions
        for useactions in self._iter_use_action_sets('other', 'extra'):
            yield useactions
            for closeactions in self._iter_close_action_sets('same', 'other'):
                actions = useactions + closeactions
                yield actions
                for postactions in self._iter_post_close_action_sets():
                    yield actions + postactions
            for closeactions in self._iter_close_action_sets('other', 'extra'):
                actions = useactions + closeactions
                yield actions
                for postactions in self._iter_post_close_action_sets():
                    yield actions + postactions

def _iter_use_action_sets(self, interp1, interp2):
        interps = (interp1, interp2)

# only recv end used
        yield [
            ChannelAction('use', 'recv', interp1),
            ]
        yield [
            ChannelAction('use', 'recv', interp2),
            ]
        yield [
            ChannelAction('use', 'recv', interp1),
            ChannelAction('use', 'recv', interp2),
            ]

# never emptied
        yield [
            ChannelAction('use', 'send', interp1),
            ]
        yield [
            ChannelAction('use', 'send', interp2),
            ]
        yield [
            ChannelAction('use', 'send', interp1),
            ChannelAction('use', 'send', interp2),
            ]

# partially emptied
        for interp1 in interps:
            for interp2 in interps:
                for interp3 in interps:
                    yield [
                        ChannelAction('use', 'send', interp1),
                        ChannelAction('use', 'send', interp2),
                        ChannelAction('use', 'recv', interp3),
                        ]

# fully emptied
        for interp1 in interps:
            for interp2 in interps:
                for interp3 in interps:
                    for interp4 in interps:
                        yield [
                            ChannelAction('use', 'send', interp1),
                            ChannelAction('use', 'send', interp2),
                            ChannelAction('use', 'recv', interp3),
                            ChannelAction('use', 'recv', interp4),
                            ]

def _iter_close_action_sets(self, interp1, interp2):
        ends = ('recv', 'send')
        interps = (interp1, interp2)
        for force in (True, False):
            op = 'force-close' if force else 'close'
            for interp in interps:
                for end in ends:
                    yield [
                        ChannelAction(op, end, interp),
                        ]
        for recvop in ('close', 'force-close'):
            for sendop in ('close', 'force-close'):
                for recv in interps:
                    for send in interps:
                        yield [
                            ChannelAction(recvop, 'recv', recv),
                            ChannelAction(sendop, 'send', send),
                            ]

def _iter_post_close_action_sets(self):
        for interp in ('same', 'extra', 'other'):
            yield [
                ChannelAction('use', 'recv', interp),
                ]
            yield [
                ChannelAction('use', 'send', interp),
                ]

def run_actions(self, fix, actions):
        for action in actions:
            self.run_action(fix, action)

def run_action(self, fix, action, *, hideclosed=True):
        end = action.resolve_end(fix.end)
        interp = action.resolve_interp(fix.interp, fix.other, fix.extra)
        fix.prep_interpreter(interp)
        if interp.name == 'main':
            result = run_action(
                fix.cid,
                action.action,
                end,
                fix.state,
                hideclosed=hideclosed,
                )
            fix.record_action(action, result)
        else:
            _cid = channels.create()
            run_interp(interp.id, f"""
                result = helpers.run_action(
                    {fix.cid},
                    {repr(action.action)},
                    {repr(end)},
                    {repr(fix.state)},
                    hideclosed={hideclosed},
                    )
                channels.send({_cid}, result.pending.to_bytes(1, 'little'))
                channels.send({_cid}, b'X' if result.closed else b'')
                """)
            result = ChannelState(
                pending=int.from_bytes(channels.recv(_cid), 'little'),
                closed=bool(channels.recv(_cid)),
                )
            fix.record_action(action, result)

def iter_fixtures(self):
        # XXX threads?
        interpreters = [
            ('main', 'interp', 'extra'),
            ('interp', 'main', 'extra'),
            ('interp1', 'interp2', 'extra'),
            ('interp1', 'interp2', 'main'),
        ]
        for interp, other, extra in interpreters:
            for creator in ('same', 'other', 'creator'):
                for end in ('send', 'recv'):
                    yield ChannelCloseFixture(end, interp, other, extra, creator)

def _close(self, fix, *, force):
        op = 'force-close' if force else 'close'
        close = ChannelAction(op, fix.end, 'same')
        if not fix.expect_closed_error():
            self.run_action(fix, close, hideclosed=False)
        else:
            with self.assertRaises(channels.ChannelClosedError):
                self.run_action(fix, close, hideclosed=False)

def _assert_closed_in_interp(self, fix, interp=None):
        if interp is None or interp.name == 'main':
            with self.assertRaises(channels.ChannelClosedError):
                channels.recv(fix.cid)
            with self.assertRaises(channels.ChannelClosedError):
                channels.send(fix.cid, b'spam')
            with self.assertRaises(channels.ChannelClosedError):
                channels.close(fix.cid)
            with self.assertRaises(channels.ChannelClosedError):
                channels.close(fix.cid, force=True)
        else:
            run_interp(interp.id, """
                with helpers.expect_channel_closed():
                    channels.recv(cid)
                """)
            run_interp(interp.id, """
                with helpers.expect_channel_closed():
                    channels.send(cid, b'spam')
                """)
            run_interp(interp.id, """
                with helpers.expect_channel_closed():
                    channels.close(cid)
                """)
            run_interp(interp.id, """
                with helpers.expect_channel_closed():
                    channels.close(cid, force=True)
                """)

def _assert_closed(self, fix):
        self.assertTrue(fix.state.closed)

for _ in range(fix.state.pending):
            channels.recv(fix.cid)
        self._assert_closed_in_interp(fix)

for interp in ('same', 'other'):
            interp = fix.get_interpreter(interp)
            if interp.name == 'main':
                continue
            self._assert_closed_in_interp(fix, interp)

interp = fix.get_interpreter('fresh')
        self._assert_closed_in_interp(fix, interp)

def _iter_close_tests(self, verbose=False):
        i = 0
        for actions in self.iter_action_sets():
            print()
            for fix in self.iter_fixtures():
                i += 1
                if i > 1000:
                    return
                if verbose:
                    if (i - 1) % 6 == 0:
                        print()
                    print(i, fix, '({} actions)'.format(len(actions)))
                else:
                    if (i - 1) % 6 == 0:
                        print(' ', end='')
                    print('.', end=''); sys.stdout.flush()
                yield i, fix, actions
            if verbose:
                print('---')
        print()

# This is useful for scanning through the possible tests.
    def _skim_close_tests(self):
        ChannelCloseFixture.QUICK = True
        for i, fix, actions in self._iter_close_tests():
            pass

def test_close(self):
        for i, fix, actions in self._iter_close_tests():
            with self.subTest('{} {}  {}'.format(i, fix, actions)):
                fix.prep_interpreter(fix.interp)
                self.run_actions(fix, actions)

self._close(fix, force=False)

self._assert_closed(fix)
            # XXX Things slow down if we have too many interpreters.
            fix.clean_up()

def test_force_close(self):
        for i, fix, actions in self._iter_close_tests():
            with self.subTest('{} {}  {}'.format(i, fix, actions)):
                fix.prep_interpreter(fix.interp)
                self.run_actions(fix, actions)

self._close(fix, force=True)

self._assert_closed(fix)
            # XXX Things slow down if we have too many interpreters.
            fix.clean_up()

if __name__ == '__main__':
    unittest.main()

${this.title}

Code Editor : test__xxinterpchannels.py