File Manager

003 File Manager

Current Path: /usr/local/lib/python3.8/test

📁 ..
📄 Sine-1000Hz-300ms.aif(60.25 KB)
📄 __init__.py(47 B)
📄 __main__.py(41 B)
📁 __pycache__
📄 _test_multiprocessing.py(183.09 KB)
📄 allsans.pem(9.87 KB)
📄 ann_module.py(1.08 KB)
📄 ann_module2.py(519 B)
📄 ann_module3.py(448 B)
📁 audiodata
📄 audiotest.au(27.48 KB)
📄 audiotests.py(12.46 KB)
📄 audit-tests.py(8.9 KB)
📄 autotest.py(209 B)
📄 bad_coding.py(24 B)
📄 bad_coding2.py(30 B)
📄 bad_getattr.py(61 B)
📄 bad_getattr2.py(77 B)
📄 bad_getattr3.py(139 B)
📄 badcert.pem(1.88 KB)
📄 badkey.pem(2.11 KB)
📄 badsyntax_3131.py(32 B)
📄 badsyntax_future10.py(95 B)
📄 badsyntax_future3.py(172 B)
📄 badsyntax_future4.py(153 B)
📄 badsyntax_future5.py(184 B)
📄 badsyntax_future6.py(161 B)
📄 badsyntax_future7.py(196 B)
📄 badsyntax_future8.py(122 B)
📄 badsyntax_future9.py(142 B)
📄 badsyntax_pep3120.py(14 B)
📄 bisect_cmd.py(4.85 KB)
📄 bytecode_helper.py(1.56 KB)
📁 capath
📄 cfgparser.1(67 B)
📄 cfgparser.2(19.02 KB)
📄 cfgparser.3(1.55 KB)
📁 cjkencodings
📄 clinic.test(94.65 KB)
📄 cmath_testcases.txt(141.05 KB)
📄 coding20731.py(22 B)
📄 curses_tests.py(1.22 KB)
📁 data
📄 dataclass_module_1.py(837 B)
📄 dataclass_module_1_str.py(835 B)
📄 dataclass_module_2.py(756 B)
📄 dataclass_module_2_str.py(754 B)
📄 dataclass_textanno.py(126 B)
📄 datetimetester.py(239.84 KB)
📁 decimaltestdata
📄 dis_module.py(76 B)
📄 doctest_aliases.py(240 B)
📄 double_const.py(1.18 KB)
📁 dtracedata
📁 eintrdata
📄 empty.vbs(70 B)
📁 encoded_modules
📄 exception_hierarchy.txt(1.78 KB)
📄 ffdh3072.pem(2.16 KB)
📄 final_a.py(411 B)
📄 final_b.py(411 B)
📄 floating_points.txt(15.92 KB)
📄 fork_wait.py(2.53 KB)
📄 formatfloat_testcases.txt(7.45 KB)
📄 future_test1.py(229 B)
📄 future_test2.py(149 B)
📄 gdb_sample.py(153 B)
📄 good_getattr.py(198 B)
📄 idnsans.pem(9.71 KB)
📄 ieee754.txt(3.21 KB)
📁 imghdrdata
📄 imp_dummy.py(63 B)
📄 inspect_fodder.py(1.88 KB)
📄 inspect_fodder2.py(2.06 KB)
📄 keycert.passwd.pem(4.13 KB)
📄 keycert.pem(3.96 KB)
📄 keycert2.pem(3.98 KB)
📄 keycert3.pem(9.23 KB)
📄 keycert4.pem(9.24 KB)
📄 keycertecc.pem(5.5 KB)
📁 libregrtest
📄 list_tests.py(16.54 KB)
📄 lock_tests.py(28.26 KB)
📄 mailcap.txt(1.24 KB)
📄 make_ssl_certs.py(9.25 KB)
📄 mapping_tests.py(21.75 KB)
📄 math_testcases.txt(23.19 KB)
📄 memory_watchdog.py(859 B)
📄 mime.types(47.37 KB)
📄 mock_socket.py(3.53 KB)
📄 mod_generics_cache.py(1.13 KB)
📄 mp_fork_bomb.py(448 B)
📄 mp_preload.py(351 B)
📄 multibytecodec_support.py(14.17 KB)
📄 nokia.pem(1.88 KB)
📄 nosan.pem(7.54 KB)
📄 nullbytecert.pem(5.31 KB)
📄 nullcert.pem(0 B)
📄 outstanding_bugs.py(370 B)
📄 pickletester.py(135.99 KB)
📄 profilee.py(2.97 KB)
📄 pstats.pck(65.05 KB)
📄 pycacert.pem(5.53 KB)
📄 pycakey.pem(2.43 KB)
📄 pyclbr_input.py(648 B)
📄 pydoc_mod.py(713 B)
📄 pydocfodder.py(6.18 KB)
📄 pythoninfo.py(20.34 KB)
📄 randv2_32.pck(7.34 KB)
📄 randv2_64.pck(7.19 KB)
📄 randv3.pck(7.82 KB)
📄 re_tests.py(25.93 KB)
📄 recursion.tar(516 B)
📄 regrtest.py(1.34 KB)
📄 relimport.py(27 B)
📄 reperf.py(538 B)
📄 revocation.crl(800 B)
📄 sample_doctest.py(1.02 KB)
📄 sample_doctest_no_docstrings.py(227 B)
📄 sample_doctest_no_doctests.py(269 B)
📄 secp384r1.pem(256 B)
📄 selfsigned_pythontestdotnet.pem(2.08 KB)
📄 seq_tests.py(14.18 KB)
📄 sgml_input.html(8.1 KB)
📄 signalinterproctester.py(2.7 KB)
📁 sndhdrdata
📄 sortperf.py(4.69 KB)
📄 ssl_cert.pem(1.53 KB)
📄 ssl_key.passwd.pem(2.59 KB)
📄 ssl_key.pem(2.43 KB)
📄 ssl_servers.py(7.04 KB)
📄 ssltests.py(1.03 KB)
📄 string_tests.py(64.65 KB)
📁 subprocessdata
📁 support
📄 talos-2019-0758.pem(1.3 KB)
📄 test___all__.py(4.12 KB)
📄 test___future__.py(2.36 KB)
📄 test__locale.py(7.83 KB)
📄 test__opcode.py(3.03 KB)
📄 test__osx_support.py(13.66 KB)
📄 test__xxsubinterpreters.py(68.7 KB)
📄 test_abc.py(18 KB)
📄 test_abstract_numbers.py(1.49 KB)
📄 test_aifc.py(17.68 KB)
📄 test_argparse.py(172.67 KB)
📄 test_array.py(52.57 KB)
📄 test_asdl_parser.py(4.15 KB)
📄 test_ast.py(88.53 KB)
📄 test_asyncgen.py(31.44 KB)
📄 test_asynchat.py(9.28 KB)
📁 test_asyncio
📄 test_asyncore.py(25.81 KB)
📄 test_atexit.py(5.81 KB)
📄 test_audioop.py(28.24 KB)
📄 test_audit.py(4.05 KB)
📄 test_augassign.py(7.68 KB)
📄 test_base64.py(30.17 KB)
📄 test_baseexception.py(6.86 KB)
📄 test_bdb.py(41.55 KB)
📄 test_bigaddrspace.py(2.92 KB)
📄 test_bigmem.py(44.88 KB)
📄 test_binascii.py(18 KB)
📄 test_binhex.py(1.79 KB)
📄 test_binop.py(14.14 KB)
📄 test_bisect.py(13.63 KB)
📄 test_bool.py(12.48 KB)
📄 test_buffer.py(160.04 KB)
📄 test_bufio.py(2.54 KB)
📄 test_builtin.py(78.38 KB)
📄 test_bytes.py(72.23 KB)
📄 test_bz2.py(36.76 KB)
📄 test_c_locale_coercion.py(18.82 KB)
📄 test_calendar.py(48.71 KB)
📄 test_call.py(20.88 KB)
📄 test_capi.py(30.46 KB)
📄 test_cgi.py(22.15 KB)
📄 test_cgitb.py(2.5 KB)
📄 test_charmapcodec.py(1.68 KB)
📄 test_class.py(17.42 KB)
📄 test_clinic.py(21.71 KB)
📄 test_cmath.py(24.07 KB)
📄 test_cmd.py(6.1 KB)
📄 test_cmd_line.py(33.72 KB)
📄 test_cmd_line_script.py(31.46 KB)
📄 test_code.py(13.66 KB)
📄 test_code_module.py(5.51 KB)
📄 test_codeccallbacks.py(40.97 KB)
📄 test_codecencodings_cn.py(3.86 KB)
📄 test_codecencodings_hk.py(701 B)
📄 test_codecencodings_iso2022.py(1.36 KB)
📄 test_codecencodings_jp.py(4.79 KB)
📄 test_codecencodings_kr.py(2.96 KB)
📄 test_codecencodings_tw.py(681 B)
📄 test_codecmaps_cn.py(746 B)
📄 test_codecmaps_hk.py(386 B)
📄 test_codecmaps_jp.py(1.7 KB)
📄 test_codecmaps_kr.py(1.16 KB)
📄 test_codecmaps_tw.py(705 B)
📄 test_codecs.py(129.38 KB)
📄 test_codeop.py(7.97 KB)
📄 test_collections.py(83.93 KB)
📄 test_colorsys.py(3.83 KB)
📄 test_compare.py(3.82 KB)
📄 test_compile.py(36.48 KB)
📄 test_compileall.py(26.7 KB)
📄 test_complex.py(30.24 KB)
📄 test_concurrent_futures.py(44.93 KB)
📄 test_configparser.py(84.93 KB)
📄 test_contains.py(3.49 KB)
📄 test_context.py(29.33 KB)
📄 test_contextlib.py(32.54 KB)
📄 test_contextlib_async.py(14.82 KB)
📄 test_copy.py(25.81 KB)
📄 test_copyreg.py(4.39 KB)
📄 test_coroutines.py(62.52 KB)
📄 test_cprofile.py(6.33 KB)
📄 test_crashers.py(1.17 KB)
📄 test_crypt.py(3.97 KB)
📄 test_csv.py(47.77 KB)
📄 test_ctypes.py(184 B)
📄 test_curses.py(45.47 KB)
📄 test_dataclasses.py(108.8 KB)
📄 test_datetime.py(2.15 KB)
📄 test_dbm.py(6.45 KB)
📄 test_dbm_dumb.py(10.61 KB)
📄 test_dbm_gnu.py(6.22 KB)
📄 test_dbm_ndbm.py(5.05 KB)
📄 test_decimal.py(206.63 KB)
📄 test_decorators.py(9.48 KB)
📄 test_defaultdict.py(5.88 KB)
📄 test_deque.py(34.46 KB)
📄 test_descr.py(190.58 KB)
📄 test_descrtut.py(11.53 KB)
📄 test_devpoll.py(4.5 KB)
📄 test_dict.py(45 KB)
📄 test_dict_version.py(5.88 KB)
📄 test_dictcomps.py(4.42 KB)
📄 test_dictviews.py(11.68 KB)
📄 test_difflib.py(19.64 KB)
📄 test_difflib_expect.html(100.85 KB)
📄 test_dis.py(48.4 KB)
📄 test_distutils.py(375 B)
📄 test_doctest.py(98.67 KB)
📄 test_doctest.txt(300 B)
📄 test_doctest2.py(2.3 KB)
📄 test_doctest2.txt(392 B)
📄 test_doctest3.txt(82 B)
📄 test_doctest4.txt(244 B)
📄 test_docxmlrpc.py(8.67 KB)
📄 test_dtrace.py(5.23 KB)
📄 test_dummy_thread.py(9.69 KB)
📄 test_dummy_threading.py(1.7 KB)
📄 test_dynamic.py(4.29 KB)
📄 test_dynamicclassattribute.py(9.57 KB)
📄 test_eintr.py(1.32 KB)
📁 test_email
📄 test_embed.py(49.23 KB)
📄 test_ensurepip.py(9.83 KB)
📄 test_enum.py(113.68 KB)
📄 test_enumerate.py(8.46 KB)
📄 test_eof.py(1.94 KB)
📄 test_epoll.py(9.03 KB)
📄 test_errno.py(1.04 KB)
📄 test_exception_hierarchy.py(7.43 KB)
📄 test_exception_variations.py(3.86 KB)
📄 test_exceptions.py(49.81 KB)
📄 test_extcall.py(13.49 KB)
📄 test_faulthandler.py(28.13 KB)
📄 test_fcntl.py(6.21 KB)
📄 test_file.py(11.02 KB)
📄 test_file_eintr.py(10.6 KB)
📄 test_filecmp.py(8.69 KB)
📄 test_fileinput.py(37.33 KB)
📄 test_fileio.py(19.96 KB)
📄 test_finalization.py(14.66 KB)
📄 test_float.py(63.41 KB)
📄 test_flufl.py(1.32 KB)
📄 test_fnmatch.py(5.07 KB)
📄 test_fork1.py(3.67 KB)
📄 test_format.py(22.58 KB)
📄 test_fractions.py(29.83 KB)
📄 test_frame.py(5.67 KB)
📄 test_frozen.py(943 B)
📄 test_fstring.py(46.16 KB)
📄 test_ftplib.py(39.71 KB)
📄 test_funcattrs.py(13.54 KB)
📄 test_functools.py(90.59 KB)
📄 test_future.py(11.9 KB)
📄 test_future3.py(490 B)
📄 test_future4.py(222 B)
📄 test_future5.py(510 B)
📄 test_gc.py(40.49 KB)
📄 test_gdb.py(40.88 KB)
📄 test_generator_stop.py(943 B)
📄 test_generators.py(58.51 KB)
📄 test_genericclass.py(9.28 KB)
📄 test_genericpath.py(21.7 KB)
📄 test_genexps.py(7.12 KB)
📄 test_getargs2.py(50 KB)
📄 test_getopt.py(6.75 KB)
📄 test_getpass.py(6.29 KB)
📄 test_gettext.py(41.38 KB)
📄 test_glob.py(13.03 KB)
📄 test_global.py(1.31 KB)
📄 test_grammar.py(57.5 KB)
📄 test_grp.py(3.54 KB)
📄 test_gzip.py(29.9 KB)
📄 test_hash.py(11.45 KB)
📄 test_hashlib.py(39.43 KB)
📄 test_heapq.py(16.4 KB)
📄 test_hmac.py(22.24 KB)
📄 test_html.py(4.23 KB)
📄 test_htmlparser.py(33.19 KB)
📄 test_http_cookiejar.py(78.36 KB)
📄 test_http_cookies.py(18.71 KB)
📄 test_httplib.py(76.98 KB)
📄 test_httpservers.py(45.24 KB)
📄 test_idle.py(825 B)
📄 test_imaplib.py(38.95 KB)
📄 test_imghdr.py(4.66 KB)
📄 test_imp.py(17.73 KB)
📁 test_import
📁 test_importlib
📄 test_index.py(8.37 KB)
📄 test_inspect.py(151.79 KB)
📄 test_int.py(20.8 KB)
📄 test_int_literal.py(6.89 KB)
📄 test_io.py(163.94 KB)
📄 test_ioctl.py(3.2 KB)
📄 test_ipaddress.py(90.98 KB)
📄 test_isinstance.py(10.25 KB)
📄 test_iter.py(31.81 KB)
📄 test_iterlen.py(7.1 KB)
📄 test_itertools.py(101.41 KB)
📁 test_json
📄 test_keyword.py(1.23 KB)
📄 test_keywordonlyarg.py(6.85 KB)
📄 test_kqueue.py(8.76 KB)
📄 test_largefile.py(6.83 KB)
📄 test_lib2to3.py(101 B)
📄 test_linecache.py(7.79 KB)
📄 test_list.py(7.4 KB)
📄 test_listcomps.py(3.76 KB)
📄 test_lltrace.py(1012 B)
📄 test_locale.py(23.87 KB)
📄 test_logging.py(182.43 KB)
📄 test_long.py(53.21 KB)
📄 test_longexp.py(233 B)
📄 test_lzma.py(87.92 KB)
📄 test_mailbox.py(91.92 KB)
📄 test_mailcap.py(9.88 KB)
📄 test_marshal.py(20.57 KB)
📄 test_math.py(82.18 KB)
📄 test_memoryio.py(31.48 KB)
📄 test_memoryview.py(17.78 KB)
📄 test_metaclass.py(6.2 KB)
📄 test_mimetypes.py(12.14 KB)
📄 test_minidom.py(66.95 KB)
📄 test_mmap.py(29.04 KB)
📄 test_module.py(10.3 KB)
📄 test_modulefinder.py(12.2 KB)
📄 test_msilib.py(5.06 KB)
📄 test_multibytecodec.py(15.04 KB)
📄 test_multiprocessing_fork.py(477 B)
📄 test_multiprocessing_forkserver.py(392 B)
📄 test_multiprocessing_main_handling.py(11.45 KB)
📄 test_multiprocessing_spawn.py(277 B)
📄 test_named_expressions.py(16.51 KB)
📄 test_netrc.py(5.96 KB)
📄 test_nis.py(1.13 KB)
📄 test_nntplib.py(61.7 KB)
📄 test_normalization.py(3.66 KB)
📄 test_ntpath.py(35.08 KB)
📄 test_numeric_tower.py(7.18 KB)
📄 test_opcodes.py(3.61 KB)
📄 test_openpty.py(600 B)
📄 test_operator.py(23.54 KB)
📄 test_optparse.py(60.99 KB)
📄 test_ordered_dict.py(30.22 KB)
📄 test_os.py(150.53 KB)
📄 test_ossaudiodev.py(7.06 KB)
📄 test_osx_env.py(1.3 KB)
📄 test_parser.py(35.72 KB)
📄 test_pathlib.py(97.12 KB)
📄 test_pdb.py(55.36 KB)
📄 test_peepholer.py(19.41 KB)
📄 test_pickle.py(19.16 KB)
📄 test_picklebuffer.py(4.96 KB)
📄 test_pickletools.py(4.33 KB)
📄 test_pipes.py(6.59 KB)
📄 test_pkg.py(9.59 KB)
📄 test_pkgimport.py(2.67 KB)
📄 test_pkgutil.py(19.25 KB)
📄 test_platform.py(14.31 KB)
📄 test_plistlib.py(41.43 KB)
📄 test_poll.py(7.23 KB)
📄 test_popen.py(1.98 KB)
📄 test_poplib.py(16.97 KB)
📄 test_positional_only_arg.py(17.5 KB)
📄 test_posix.py(75.76 KB)
📄 test_posixpath.py(29.19 KB)
📄 test_pow.py(5.44 KB)
📄 test_pprint.py(43.85 KB)
📄 test_print.py(7.37 KB)
📄 test_profile.py(8.72 KB)
📄 test_property.py(8.77 KB)
📄 test_pstats.py(3.04 KB)
📄 test_pty.py(11.97 KB)
📄 test_pulldom.py(12.66 KB)
📄 test_pwd.py(4.17 KB)
📄 test_py_compile.py(10.78 KB)
📄 test_pyclbr.py(10 KB)
📄 test_pydoc.py(56.98 KB)
📄 test_pyexpat.py(26.54 KB)
📄 test_queue.py(20.36 KB)
📄 test_quopri.py(7.78 KB)
📄 test_raise.py(12.86 KB)
📄 test_random.py(45.59 KB)
📄 test_range.py(23.35 KB)
📄 test_re.py(106.41 KB)
📄 test_readline.py(12.95 KB)
📄 test_regrtest.py(46.36 KB)
📄 test_repl.py(3.96 KB)
📄 test_reprlib.py(15.12 KB)
📄 test_resource.py(7.02 KB)
📄 test_richcmp.py(11.91 KB)
📄 test_rlcompleter.py(6.3 KB)
📄 test_robotparser.py(10.69 KB)
📄 test_runpy.py(33.86 KB)
📄 test_sax.py(46.9 KB)
📄 test_sched.py(6.41 KB)
📄 test_scope.py(19.7 KB)
📄 test_script_helper.py(5.78 KB)
📄 test_secrets.py(4.28 KB)
📄 test_select.py(2.69 KB)
📄 test_selectors.py(17.79 KB)
📄 test_set.py(64.41 KB)
📄 test_setcomps.py(3.7 KB)
📄 test_shelve.py(6.24 KB)
📄 test_shlex.py(13.29 KB)
📄 test_shutil.py(101.55 KB)
📄 test_signal.py(46.62 KB)
📄 test_site.py(24.71 KB)
📄 test_slice.py(8.25 KB)
📄 test_smtpd.py(40.14 KB)
📄 test_smtplib.py(56.51 KB)
📄 test_smtpnet.py(2.87 KB)
📄 test_sndhdr.py(1.43 KB)
📄 test_socket.py(232.71 KB)
📄 test_socketserver.py(17.7 KB)
📄 test_sort.py(13.42 KB)
📄 test_source_encoding.py(7.89 KB)
📄 test_spwd.py(2.71 KB)
📄 test_sqlite.py(948 B)
📄 test_ssl.py(203.3 KB)
📄 test_startfile.py(1.29 KB)
📄 test_stat.py(8.3 KB)
📄 test_statistics.py(106.5 KB)
📄 test_strftime.py(7.54 KB)
📄 test_string.py(19.8 KB)
📄 test_string_literals.py(9.88 KB)
📄 test_stringprep.py(3.04 KB)
📄 test_strptime.py(34.42 KB)
📄 test_strtod.py(20.06 KB)
📄 test_struct.py(34.41 KB)
📄 test_structmembers.py(4.7 KB)
📄 test_structseq.py(3.87 KB)
📄 test_subclassinit.py(8.12 KB)
📄 test_subprocess.py(142.64 KB)
📄 test_sunau.py(6.07 KB)
📄 test_sundry.py(2.07 KB)
📄 test_super.py(9.6 KB)
📄 test_support.py(24.12 KB)
📄 test_symbol.py(2.06 KB)
📄 test_symtable.py(9.13 KB)
📄 test_syntax.py(25.75 KB)
📄 test_sys.py(55.24 KB)
📄 test_sys_setprofile.py(12.31 KB)
📄 test_sys_settrace.py(43.08 KB)
📄 test_sysconfig.py(17.01 KB)
📄 test_syslog.py(1.15 KB)
📄 test_tabnanny.py(13.44 KB)
📄 test_tarfile.py(98.31 KB)
📄 test_tcl.py(30.74 KB)
📄 test_telnetlib.py(12.7 KB)
📄 test_tempfile.py(52.57 KB)
📄 test_textwrap.py(38.84 KB)
📄 test_thread.py(8.41 KB)
📄 test_threaded_import.py(8.9 KB)
📄 test_threadedtempfile.py(1.85 KB)
📄 test_threading.py(47.52 KB)
📄 test_threading_local.py(6.09 KB)
📄 test_threadsignals.py(10.09 KB)
📄 test_time.py(38.43 KB)
📄 test_timeit.py(14.8 KB)
📄 test_timeout.py(11.19 KB)
📄 test_tix.py(756 B)
📄 test_tk.py(362 B)
📄 test_tokenize.py(63.18 KB)
📁 test_tools
📄 test_trace.py(19.89 KB)
📄 test_traceback.py(46.97 KB)
📄 test_tracemalloc.py(37.41 KB)
📄 test_ttk_guionly.py(746 B)
📄 test_ttk_textonly.py(299 B)
📄 test_tuple.py(18.85 KB)
📄 test_turtle.py(12.79 KB)
📄 test_type_comments.py(10.13 KB)
📄 test_typechecks.py(2.55 KB)
📄 test_types.py(58 KB)
📄 test_typing.py(122.05 KB)
📄 test_ucn.py(9.35 KB)
📄 test_unary.py(1.63 KB)
📄 test_unicode.py(129.94 KB)
📄 test_unicode_file.py(5.74 KB)
📄 test_unicode_file_functions.py(6.84 KB)
📄 test_unicode_identifiers.py(891 B)
📄 test_unicodedata.py(12.7 KB)
📄 test_unittest.py(286 B)
📄 test_univnewlines.py(3.83 KB)
📄 test_unpack.py(3.01 KB)
📄 test_unpack_ex.py(8.73 KB)
📄 test_urllib.py(71.24 KB)
📄 test_urllib2.py(76.95 KB)
📄 test_urllib2_localnet.py(24.24 KB)
📄 test_urllib2net.py(12.39 KB)
📄 test_urllib_response.py(1.69 KB)
📄 test_urllibnet.py(8.9 KB)
📄 test_urlparse.py(64.87 KB)
📄 test_userdict.py(7.64 KB)
📄 test_userlist.py(1.97 KB)
📄 test_userstring.py(2.4 KB)
📄 test_utf8_mode.py(9.22 KB)
📄 test_utf8source.py(1.15 KB)
📄 test_uu.py(8.02 KB)
📄 test_uuid.py(35.74 KB)
📄 test_venv.py(20.46 KB)
📄 test_wait3.py(1.16 KB)
📄 test_wait4.py(1.15 KB)
📁 test_warnings
📄 test_wave.py(6.57 KB)
📄 test_weakref.py(69.47 KB)
📄 test_weakset.py(15.03 KB)
📄 test_webbrowser.py(10.47 KB)
📄 test_winconsoleio.py(6.14 KB)
📄 test_winreg.py(21.38 KB)
📄 test_winsound.py(4.57 KB)
📄 test_with.py(25.78 KB)
📄 test_wsgiref.py(30.1 KB)
📄 test_xdrlib.py(2.17 KB)
📄 test_xml_dom_minicompat.py(4.18 KB)
📄 test_xml_etree.py(147.87 KB)
📄 test_xml_etree_c.py(8.06 KB)
📄 test_xmlrpc.py(55.96 KB)
📄 test_xmlrpc_net.py(1015 B)
📄 test_xxtestfuzz.py(670 B)
📄 test_yield_from.py(30.01 KB)
📄 test_zipapp.py(15.92 KB)
📄 test_zipfile.py(115.45 KB)
📄 test_zipfile64.py(5.8 KB)
📄 test_zipimport.py(29.28 KB)
📄 test_zipimport_support.py(10.44 KB)
📄 test_zlib.py(34.48 KB)
📄 testcodec.py(1.02 KB)
📄 testtar.tar(425 KB)
📄 tf_inherit_check.py(714 B)
📄 threaded_import_hangers.py(1.45 KB)
📄 time_hashlib.py(2.87 KB)
📄 tokenize_tests-latin1-coding-cookie-and-utf8-bom-sig.txt(443 B)
📄 tokenize_tests-no-coding-cookie-and-utf8-bom-sig-only.txt(302 B)
📄 tokenize_tests-utf8-coding-cookie-and-no-utf8-bom-sig.txt(421 B)
📄 tokenize_tests-utf8-coding-cookie-and-utf8-bom-sig.txt(326 B)
📄 tokenize_tests.txt(2.65 KB)
📁 tracedmodules
📄 win_console_handler.py(1.38 KB)
📁 xmltestdata
📄 xmltests.py(499 B)
📄 zip_cp437_header.zip(270 B)
📄 zipdir.zip(374 B)
📁 ziptestdata

Editing: test_coroutines.py

import contextlib
import copy
import inspect
import pickle
import sys
import types
import unittest
import warnings
from test import support
from test.support.script_helper import assert_python_ok

class AsyncYieldFrom:
    def __init__(self, obj):
        self.obj = obj

def __await__(self):
        yield from self.obj

class AsyncYield:
    def __init__(self, value):
        self.value = value

def __await__(self):
        yield self.value

def run_async(coro):
    assert coro.__class__ in {types.GeneratorType, types.CoroutineType}

buffer = []
    result = None
    while True:
        try:
            buffer.append(coro.send(None))
        except StopIteration as ex:
            result = ex.args[0] if ex.args else None
            break
    return buffer, result

def run_async__await__(coro):
    assert coro.__class__ is types.CoroutineType
    aw = coro.__await__()
    buffer = []
    result = None
    i = 0
    while True:
        try:
            if i % 2:
                buffer.append(next(aw))
            else:
                buffer.append(aw.send(None))
            i += 1
        except StopIteration as ex:
            result = ex.args[0] if ex.args else None
            break
    return buffer, result

@contextlib.contextmanager
def silence_coro_gc():
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        yield
        support.gc_collect()

class AsyncBadSyntaxTest(unittest.TestCase):

def test_badsyntax_1(self):
        samples = [
            """def foo():
                await something()
            """,

"""await something()""",

"""async def foo():
                yield from []
            """,

"""async def foo():
                await await fut
            """,

"""async def foo(a=await something()):
                pass
            """,

"""async def foo(a:await something()):
                pass
            """,

"""async def foo():
                def bar():
                 [i async for i in els]
            """,

"""async def foo():
                def bar():
                 [await i for i in els]
            """,

"""async def foo():
                def bar():
                 [i for i in els
                    async for b in els]
            """,

"""async def foo():
                def bar():
                 [i for i in els
                    for c in b
                    async for b in els]
            """,

"""async def foo():
                def bar():
                 [i for i in els
                    async for b in els
                    for c in b]
            """,

"""async def foo():
                def bar():
                 [i for i in els
                    for b in await els]
            """,

"""async def foo():
                def bar():
                 [i for i in els
                    for b in els
                        if await b]
            """,

"""async def foo():
                def bar():
                 [i for i in await els]
            """,

"""async def foo():
                def bar():
                 [i for i in els if await i]
            """,

"""def bar():
                 [i async for i in els]
            """,

"""def bar():
                 {i: i async for i in els}
            """,

"""def bar():
                 {i async for i in els}
            """,

"""def bar():
                 [await i for i in els]
            """,

"""def bar():
                 [i for i in els
                    async for b in els]
            """,

"""def bar():
                 [i for i in els
                    for c in b
                    async for b in els]
            """,

"""def bar():
                 [i for i in els
                    async for b in els
                    for c in b]
            """,

"""def bar():
                 [i for i in els
                    for b in await els]
            """,

"""def bar():
                 [i for i in els
                    for b in els
                        if await b]
            """,

"""def bar():
                 [i for i in await els]
            """,

"""def bar():
                 [i for i in els if await i]
            """,

"""async def foo():
                await
            """,

"""async def foo():
                   def bar(): pass
                   await = 1
            """,

"""async def foo():

def bar(): pass
                   await = 1
            """,

"""async def foo():
                   def bar(): pass
                   if 1:
                       await = 1
            """,

"""def foo():
                   async def bar(): pass
                   if 1:
                       await a
            """,

"""def foo():
                   async def bar(): pass
                   await a
            """,

"""def foo():
                   def baz(): pass
                   async def bar(): pass
                   await a
            """,

"""def foo():
                   def baz(): pass
                   # 456
                   async def bar(): pass
                   # 123
                   await a
            """,

"""async def foo():
                   def baz(): pass
                   # 456
                   async def bar(): pass
                   # 123
                   await = 2
            """,

"""def foo():

def baz(): pass

async def bar(): pass

await a
            """,

"""async def foo():

def baz(): pass

async def bar(): pass

await = 2
            """,

"""async def foo():
                   def async(): pass
            """,

"""async def foo():
                   def await(): pass
            """,

"""async def foo():
                   def bar():
                       await
            """,

"""async def foo():
                   return lambda async: await
            """,

"""async def foo():
                   return lambda a: await
            """,

"""await a()""",

"""async def foo(a=await b):
                   pass
            """,

"""async def foo(a:await b):
                   pass
            """,

"""def baz():
                   async def foo(a=await b):
                       pass
            """,

"""async def foo(async):
                   pass
            """,

"""async def foo():
                   def bar():
                        def baz():
                            async = 1
            """,

"""async def foo():
                   def bar():
                        def baz():
                            pass
                        async = 1
            """,

"""def foo():
                   async def bar():

async def baz():
                            pass

def baz():
                            42

async = 1
            """,

"""async def foo():
                   def bar():
                        def baz():
                            pass\nawait foo()
            """,

"""def foo():
                   def bar():
                        async def baz():
                            pass\nawait foo()
            """,

"""async def foo(await):
                   pass
            """,

"""def foo():

async def bar(): pass

await a
            """,

"""def foo():
                   async def bar():
                        pass\nawait a
            """,
            """def foo():
                   async for i in arange(2):
                       pass
            """,
            """def foo():
                   async with resource:
                       pass
            """,
            """async with resource:
                   pass
            """,
            """async for i in arange(2):
                   pass
            """,
            ]

for code in samples:
            with self.subTest(code=code), self.assertRaises(SyntaxError):
                compile(code, "<test>", "exec")

def test_badsyntax_2(self):
        samples = [
            """def foo():
                await = 1
            """,

"""class Bar:
                def async(): pass
            """,

"""class Bar:
                async = 1
            """,

"""class async:
                pass
            """,

"""class await:
                pass
            """,

"""import math as await""",

"""def async():
                pass""",

"""def foo(*, await=1):
                pass"""

"""async = 1""",

"""print(await=1)"""
        ]

for code in samples:
            with self.subTest(code=code), self.assertRaises(SyntaxError):
                compile(code, "<test>", "exec")

def test_badsyntax_3(self):
        with self.assertRaises(SyntaxError):
            compile("async = 1", "<test>", "exec")

def test_badsyntax_4(self):
        samples = [
            '''def foo(await):
                async def foo(): pass
                async def foo():
                    pass
                return await + 1
            ''',

'''def foo(await):
                async def foo(): pass
                async def foo(): pass
                return await + 1
            ''',

'''def foo(await):

async def foo(): pass

return await + 1
            ''',

'''def foo(await):
                """spam"""
                async def foo(): \
                    pass
                # 123
                async def foo(): pass
                # 456
                return await + 1
            ''',

'''def foo(await):
                def foo(): pass
                def foo(): pass
                async def bar(): return await_
                await_ = await
                try:
                    bar().send(None)
                except StopIteration as ex:
                    return ex.args[0] + 1
            '''
        ]

for code in samples:
            with self.subTest(code=code), self.assertRaises(SyntaxError):
                compile(code, "<test>", "exec")

class TokenizerRegrTest(unittest.TestCase):

def test_oneline_defs(self):
        buf = []
        for i in range(500):
            buf.append('def i{i}(): return {i}'.format(i=i))
        buf = '\n'.join(buf)

# Test that 500 consequent, one-line defs is OK
        ns = {}
        exec(buf, ns, ns)
        self.assertEqual(ns['i499'](), 499)

# Test that 500 consequent, one-line defs *and*
        # one 'async def' following them is OK
        buf += '\nasync def foo():\n    return'
        ns = {}
        exec(buf, ns, ns)
        self.assertEqual(ns['i499'](), 499)
        self.assertTrue(inspect.iscoroutinefunction(ns['foo']))

class CoroutineTest(unittest.TestCase):

def test_gen_1(self):
        def gen(): yield
        self.assertFalse(hasattr(gen, '__await__'))

def test_func_1(self):
        async def foo():
            return 10

f = foo()
        self.assertIsInstance(f, types.CoroutineType)
        self.assertTrue(bool(foo.__code__.co_flags & inspect.CO_COROUTINE))
        self.assertFalse(bool(foo.__code__.co_flags & inspect.CO_GENERATOR))
        self.assertTrue(bool(f.cr_code.co_flags & inspect.CO_COROUTINE))
        self.assertFalse(bool(f.cr_code.co_flags & inspect.CO_GENERATOR))
        self.assertEqual(run_async(f), ([], 10))

self.assertEqual(run_async__await__(foo()), ([], 10))

def bar(): pass
        self.assertFalse(bool(bar.__code__.co_flags & inspect.CO_COROUTINE))

def test_func_2(self):
        async def foo():
            raise StopIteration

with self.assertRaisesRegex(
                RuntimeError, "coroutine raised StopIteration"):

run_async(foo())

def test_func_3(self):
        async def foo():
            raise StopIteration

coro = foo()
        self.assertRegex(repr(coro), '^<coroutine object.* at 0x.*>$')
        coro.close()

def test_func_4(self):
        async def foo():
            raise StopIteration
        coro = foo()

check = lambda: self.assertRaisesRegex(
            TypeError, "'coroutine' object is not iterable")

with check():
            list(coro)

with check():
            tuple(coro)

with check():
            sum(coro)

with check():
            iter(coro)

with check():
            for i in coro:
                pass

with check():
            [i for i in coro]

coro.close()

def test_func_5(self):
        @types.coroutine
        def bar():
            yield 1

async def foo():
            await bar()

check = lambda: self.assertRaisesRegex(
            TypeError, "'coroutine' object is not iterable")

coro = foo()
        with check():
            for el in coro:
                pass
        coro.close()

# the following should pass without an error
        for el in bar():
            self.assertEqual(el, 1)
        self.assertEqual([el for el in bar()], [1])
        self.assertEqual(tuple(bar()), (1,))
        self.assertEqual(next(iter(bar())), 1)

def test_func_6(self):
        @types.coroutine
        def bar():
            yield 1
            yield 2

async def foo():
            await bar()

f = foo()
        self.assertEqual(f.send(None), 1)
        self.assertEqual(f.send(None), 2)
        with self.assertRaises(StopIteration):
            f.send(None)

def test_func_7(self):
        async def bar():
            return 10
        coro = bar()

def foo():
            yield from coro

with self.assertRaisesRegex(
                TypeError,
                "cannot 'yield from' a coroutine object in "
                "a non-coroutine generator"):
            list(foo())

coro.close()

def test_func_8(self):
        @types.coroutine
        def bar():
            return (yield from coro)

async def foo():
            return 'spam'

coro = foo()
        self.assertEqual(run_async(bar()), ([], 'spam'))
        coro.close()

def test_func_9(self):
        async def foo():
            pass

with self.assertWarnsRegex(
                RuntimeWarning,
                r"coroutine '.*test_func_9.*foo' was never awaited"):

foo()
            support.gc_collect()

with self.assertWarnsRegex(
                RuntimeWarning,
                r"coroutine '.*test_func_9.*foo' was never awaited"):

with self.assertRaises(TypeError):
                # See bpo-32703.
                for _ in foo():
                    pass

support.gc_collect()

def test_func_10(self):
        N = 0

@types.coroutine
        def gen():
            nonlocal N
            try:
                a = yield
                yield (a ** 2)
            except ZeroDivisionError:
                N += 100
                raise
            finally:
                N += 1

async def foo():
            await gen()

coro = foo()
        aw = coro.__await__()
        self.assertIs(aw, iter(aw))
        next(aw)
        self.assertEqual(aw.send(10), 100)

self.assertEqual(N, 0)
        aw.close()
        self.assertEqual(N, 1)

coro = foo()
        aw = coro.__await__()
        next(aw)
        with self.assertRaises(ZeroDivisionError):
            aw.throw(ZeroDivisionError, None, None)
        self.assertEqual(N, 102)

def test_func_11(self):
        async def func(): pass
        coro = func()
        # Test that PyCoro_Type and _PyCoroWrapper_Type types were properly
        # initialized
        self.assertIn('__await__', dir(coro))
        self.assertIn('__iter__', dir(coro.__await__()))
        self.assertIn('coroutine_wrapper', repr(coro.__await__()))
        coro.close() # avoid RuntimeWarning

def test_func_12(self):
        async def g():
            i = me.send(None)
            await foo
        me = g()
        with self.assertRaisesRegex(ValueError,
                                    "coroutine already executing"):
            me.send(None)

def test_func_13(self):
        async def g():
            pass

coro = g()
        with self.assertRaisesRegex(
                TypeError,
                "can't send non-None value to a just-started coroutine"):
            coro.send('spam')

coro.close()

def test_func_14(self):
        @types.coroutine
        def gen():
            yield
        async def coro():
            try:
                await gen()
            except GeneratorExit:
                await gen()
        c = coro()
        c.send(None)
        with self.assertRaisesRegex(RuntimeError,
                                    "coroutine ignored GeneratorExit"):
            c.close()

def test_func_15(self):
        # See http://bugs.python.org/issue25887 for details

async def spammer():
            return 'spam'
        async def reader(coro):
            return await coro

spammer_coro = spammer()

with self.assertRaisesRegex(StopIteration, 'spam'):
            reader(spammer_coro).send(None)

with self.assertRaisesRegex(RuntimeError,
                                    'cannot reuse already awaited coroutine'):
            reader(spammer_coro).send(None)

def test_func_16(self):
        # See http://bugs.python.org/issue25887 for details

@types.coroutine
        def nop():
            yield
        async def send():
            await nop()
            return 'spam'
        async def read(coro):
            await nop()
            return await coro

spammer = send()

reader = read(spammer)
        reader.send(None)
        reader.send(None)
        with self.assertRaisesRegex(Exception, 'ham'):
            reader.throw(Exception('ham'))

reader = read(spammer)
        reader.send(None)
        with self.assertRaisesRegex(RuntimeError,
                                    'cannot reuse already awaited coroutine'):
            reader.send(None)

with self.assertRaisesRegex(RuntimeError,
                                    'cannot reuse already awaited coroutine'):
            reader.throw(Exception('wat'))

def test_func_17(self):
        # See http://bugs.python.org/issue25887 for details

async def coroutine():
            return 'spam'

coro = coroutine()
        with self.assertRaisesRegex(StopIteration, 'spam'):
            coro.send(None)

with self.assertRaisesRegex(RuntimeError,
                                    'cannot reuse already awaited coroutine'):
            coro.send(None)

with self.assertRaisesRegex(RuntimeError,
                                    'cannot reuse already awaited coroutine'):
            coro.throw(Exception('wat'))

# Closing a coroutine shouldn't raise any exception even if it's
        # already closed/exhausted (similar to generators)
        coro.close()
        coro.close()

def test_func_18(self):
        # See http://bugs.python.org/issue25887 for details

async def coroutine():
            return 'spam'

coro = coroutine()
        await_iter = coro.__await__()
        it = iter(await_iter)

with self.assertRaisesRegex(StopIteration, 'spam'):
            it.send(None)

with self.assertRaisesRegex(RuntimeError,
                                    'cannot reuse already awaited coroutine'):
            it.send(None)

with self.assertRaisesRegex(RuntimeError,
                                    'cannot reuse already awaited coroutine'):
            # Although the iterator protocol requires iterators to
            # raise another StopIteration here, we don't want to do
            # that.  In this particular case, the iterator will raise
            # a RuntimeError, so that 'yield from' and 'await'
            # expressions will trigger the error, instead of silently
            # ignoring the call.
            next(it)

with self.assertRaisesRegex(RuntimeError,
                                    'cannot reuse already awaited coroutine'):
            it.throw(Exception('wat'))

# Closing a coroutine shouldn't raise any exception even if it's
        # already closed/exhausted (similar to generators)
        it.close()
        it.close()

def test_func_19(self):
        CHK = 0

@types.coroutine
        def foo():
            nonlocal CHK
            yield
            try:
                yield
            except GeneratorExit:
                CHK += 1

async def coroutine():
            await foo()

coro = coroutine()

coro.send(None)
        coro.send(None)

self.assertEqual(CHK, 0)
        coro.close()
        self.assertEqual(CHK, 1)

for _ in range(3):
            # Closing a coroutine shouldn't raise any exception even if it's
            # already closed/exhausted (similar to generators)
            coro.close()
            self.assertEqual(CHK, 1)

def test_coro_wrapper_send_tuple(self):
        async def foo():
            return (10,)

result = run_async__await__(foo())
        self.assertEqual(result, ([], (10,)))

def test_coro_wrapper_send_stop_iterator(self):
        async def foo():
            return StopIteration(10)

result = run_async__await__(foo())
        self.assertIsInstance(result[1], StopIteration)
        self.assertEqual(result[1].value, 10)

def test_cr_await(self):
        @types.coroutine
        def a():
            self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_RUNNING)
            self.assertIsNone(coro_b.cr_await)
            yield
            self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_RUNNING)
            self.assertIsNone(coro_b.cr_await)

async def c():
            await a()

async def b():
            self.assertIsNone(coro_b.cr_await)
            await c()
            self.assertIsNone(coro_b.cr_await)

coro_b = b()
        self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_CREATED)
        self.assertIsNone(coro_b.cr_await)

coro_b.send(None)
        self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_SUSPENDED)
        self.assertEqual(coro_b.cr_await.cr_await.gi_code.co_name, 'a')

with self.assertRaises(StopIteration):
            coro_b.send(None)  # complete coroutine
        self.assertEqual(inspect.getcoroutinestate(coro_b), inspect.CORO_CLOSED)
        self.assertIsNone(coro_b.cr_await)

def test_corotype_1(self):
        ct = types.CoroutineType
        self.assertIn('into coroutine', ct.send.__doc__)
        self.assertIn('inside coroutine', ct.close.__doc__)
        self.assertIn('in coroutine', ct.throw.__doc__)
        self.assertIn('of the coroutine', ct.__dict__['__name__'].__doc__)
        self.assertIn('of the coroutine', ct.__dict__['__qualname__'].__doc__)
        self.assertEqual(ct.__name__, 'coroutine')

async def f(): pass
        c = f()
        self.assertIn('coroutine object', repr(c))
        c.close()

def test_await_1(self):

async def foo():
            await 1
        with self.assertRaisesRegex(TypeError, "object int can.t.*await"):
            run_async(foo())

def test_await_2(self):
        async def foo():
            await []
        with self.assertRaisesRegex(TypeError, "object list can.t.*await"):
            run_async(foo())

def test_await_3(self):
        async def foo():
            await AsyncYieldFrom([1, 2, 3])

self.assertEqual(run_async(foo()), ([1, 2, 3], None))
        self.assertEqual(run_async__await__(foo()), ([1, 2, 3], None))

def test_await_4(self):
        async def bar():
            return 42

async def foo():
            return await bar()

self.assertEqual(run_async(foo()), ([], 42))

def test_await_5(self):
        class Awaitable:
            def __await__(self):
                return

async def foo():
            return (await Awaitable())

with self.assertRaisesRegex(
            TypeError, "__await__.*returned non-iterator of type"):

run_async(foo())

def test_await_6(self):
        class Awaitable:
            def __await__(self):
                return iter([52])

async def foo():
            return (await Awaitable())

self.assertEqual(run_async(foo()), ([52], None))

def test_await_7(self):
        class Awaitable:
            def __await__(self):
                yield 42
                return 100

async def foo():
            return (await Awaitable())

self.assertEqual(run_async(foo()), ([42], 100))

def test_await_8(self):
        class Awaitable:
            pass

async def foo(): return await Awaitable()

with self.assertRaisesRegex(
            TypeError, "object Awaitable can't be used in 'await' expression"):

run_async(foo())

def test_await_9(self):
        def wrap():
            return bar

async def bar():
            return 42

async def foo():
            db = {'b':  lambda: wrap}

class DB:
                b = wrap

return (await bar() + await wrap()() + await db['b']()()() +
                    await bar() * 1000 + await DB.b()())

async def foo2():
            return -await bar()

self.assertEqual(run_async(foo()), ([], 42168))
        self.assertEqual(run_async(foo2()), ([], -42))

def test_await_10(self):
        async def baz():
            return 42

async def bar():
            return baz()

async def foo():
            return await (await bar())

self.assertEqual(run_async(foo()), ([], 42))

def test_await_11(self):
        def ident(val):
            return val

async def bar():
            return 'spam'

async def foo():
            return ident(val=await bar())

async def foo2():
            return await bar(), 'ham'

self.assertEqual(run_async(foo2()), ([], ('spam', 'ham')))

def test_await_12(self):
        async def coro():
            return 'spam'
        c = coro()

class Awaitable:
            def __await__(self):
                return c

async def foo():
            return await Awaitable()

with self.assertRaisesRegex(
                TypeError, r"__await__ returned a coroutine"):
            run_async(foo())

c.close()

def test_await_13(self):
        class Awaitable:
            def __await__(self):
                return self

async def foo():
            return await Awaitable()

with self.assertRaisesRegex(
            TypeError, "__await__.*returned non-iterator of type"):

run_async(foo())

def test_await_14(self):
        class Wrapper:
            # Forces the interpreter to use CoroutineType.__await__
            def __init__(self, coro):
                assert coro.__class__ is types.CoroutineType
                self.coro = coro
            def __await__(self):
                return self.coro.__await__()

class FutureLike:
            def __await__(self):
                return (yield)

class Marker(Exception):
            pass

async def coro1():
            try:
                return await FutureLike()
            except ZeroDivisionError:
                raise Marker
        async def coro2():
            return await Wrapper(coro1())

c = coro2()
        c.send(None)
        with self.assertRaisesRegex(StopIteration, 'spam'):
            c.send('spam')

c = coro2()
        c.send(None)
        with self.assertRaises(Marker):
            c.throw(ZeroDivisionError)

def test_await_15(self):
        @types.coroutine
        def nop():
            yield

async def coroutine():
            await nop()

async def waiter(coro):
            await coro

coro = coroutine()
        coro.send(None)

with self.assertRaisesRegex(RuntimeError,
                                    "coroutine is being awaited already"):
            waiter(coro).send(None)

def test_await_16(self):
        # See https://bugs.python.org/issue29600 for details.

async def f():
            return ValueError()

async def g():
            try:
                raise KeyError
            except:
                return await f()

_, result = run_async(g())
        self.assertIsNone(result.__context__)

def test_with_1(self):
        class Manager:
            def __init__(self, name):
                self.name = name

async def __aenter__(self):
                await AsyncYieldFrom(['enter-1-' + self.name,
                                      'enter-2-' + self.name])
                return self

async def __aexit__(self, *args):
                await AsyncYieldFrom(['exit-1-' + self.name,
                                      'exit-2-' + self.name])

if self.name == 'B':
                    return True

async def foo():
            async with Manager("A") as a, Manager("B") as b:
                await AsyncYieldFrom([('managers', a.name, b.name)])
                1/0

f = foo()
        result, _ = run_async(f)

self.assertEqual(
            result, ['enter-1-A', 'enter-2-A', 'enter-1-B', 'enter-2-B',
                     ('managers', 'A', 'B'),
                     'exit-1-B', 'exit-2-B', 'exit-1-A', 'exit-2-A']
        )

async def foo():
            async with Manager("A") as a, Manager("C") as c:
                await AsyncYieldFrom([('managers', a.name, c.name)])
                1/0

with self.assertRaises(ZeroDivisionError):
            run_async(foo())

def test_with_2(self):
        class CM:
            def __aenter__(self):
                pass

async def foo():
            async with CM():
                pass

with self.assertRaisesRegex(AttributeError, '__aexit__'):
            run_async(foo())

def test_with_3(self):
        class CM:
            def __aexit__(self):
                pass

async def foo():
            async with CM():
                pass

with self.assertRaisesRegex(AttributeError, '__aenter__'):
            run_async(foo())

def test_with_4(self):
        class CM:
            def __enter__(self):
                pass

def __exit__(self):
                pass

async def foo():
            async with CM():
                pass

with self.assertRaisesRegex(AttributeError, '__aexit__'):
            run_async(foo())

def test_with_5(self):
        # While this test doesn't make a lot of sense,
        # it's a regression test for an early bug with opcodes
        # generation

class CM:
            async def __aenter__(self):
                return self

async def __aexit__(self, *exc):
                pass

async def func():
            async with CM():
                assert (1, ) == 1

with self.assertRaises(AssertionError):
            run_async(func())

def test_with_6(self):
        class CM:
            def __aenter__(self):
                return 123

def __aexit__(self, *e):
                return 456

async def foo():
            async with CM():
                pass

with self.assertRaisesRegex(
                TypeError,
                "'async with' received an object from __aenter__ "
                "that does not implement __await__: int"):
            # it's important that __aexit__ wasn't called
            run_async(foo())

def test_with_7(self):
        class CM:
            async def __aenter__(self):
                return self

def __aexit__(self, *e):
                return 444

# Exit with exception
        async def foo():
            async with CM():
                1/0

try:
            run_async(foo())
        except TypeError as exc:
            self.assertRegex(
                exc.args[0],
                "'async with' received an object from __aexit__ "
                "that does not implement __await__: int")
            self.assertTrue(exc.__context__ is not None)
            self.assertTrue(isinstance(exc.__context__, ZeroDivisionError))
        else:
            self.fail('invalid asynchronous context manager did not fail')

def test_with_8(self):
        CNT = 0

class CM:
            async def __aenter__(self):
                return self

def __aexit__(self, *e):
                return 456

# Normal exit
        async def foo():
            nonlocal CNT
            async with CM():
                CNT += 1
        with self.assertRaisesRegex(
                TypeError,
                "'async with' received an object from __aexit__ "
                "that does not implement __await__: int"):
            run_async(foo())
        self.assertEqual(CNT, 1)

# Exit with 'break'
        async def foo():
            nonlocal CNT
            for i in range(2):
                async with CM():
                    CNT += 1
                    break
        with self.assertRaisesRegex(
                TypeError,
                "'async with' received an object from __aexit__ "
                "that does not implement __await__: int"):
            run_async(foo())
        self.assertEqual(CNT, 2)

# Exit with 'continue'
        async def foo():
            nonlocal CNT
            for i in range(2):
                async with CM():
                    CNT += 1
                    continue
        with self.assertRaisesRegex(
                TypeError,
                "'async with' received an object from __aexit__ "
                "that does not implement __await__: int"):
            run_async(foo())
        self.assertEqual(CNT, 3)

# Exit with 'return'
        async def foo():
            nonlocal CNT
            async with CM():
                CNT += 1
                return
        with self.assertRaisesRegex(
                TypeError,
                "'async with' received an object from __aexit__ "
                "that does not implement __await__: int"):
            run_async(foo())
        self.assertEqual(CNT, 4)

def test_with_9(self):
        CNT = 0

class CM:
            async def __aenter__(self):
                return self

async def __aexit__(self, *e):
                1/0

async def foo():
            nonlocal CNT
            async with CM():
                CNT += 1

with self.assertRaises(ZeroDivisionError):
            run_async(foo())

self.assertEqual(CNT, 1)

def test_with_10(self):
        CNT = 0

class CM:
            async def __aenter__(self):
                return self

async def __aexit__(self, *e):
                1/0

async def foo():
            nonlocal CNT
            async with CM():
                async with CM():
                    raise RuntimeError

try:
            run_async(foo())
        except ZeroDivisionError as exc:
            self.assertTrue(exc.__context__ is not None)
            self.assertTrue(isinstance(exc.__context__, ZeroDivisionError))
            self.assertTrue(isinstance(exc.__context__.__context__,
                                       RuntimeError))
        else:
            self.fail('exception from __aexit__ did not propagate')

def test_with_11(self):
        CNT = 0

class CM:
            async def __aenter__(self):
                raise NotImplementedError

async def __aexit__(self, *e):
                1/0

async def foo():
            nonlocal CNT
            async with CM():
                raise RuntimeError

try:
            run_async(foo())
        except NotImplementedError as exc:
            self.assertTrue(exc.__context__ is None)
        else:
            self.fail('exception from __aenter__ did not propagate')

def test_with_12(self):
        CNT = 0

class CM:
            async def __aenter__(self):
                return self

async def __aexit__(self, *e):
                return True

async def foo():
            nonlocal CNT
            async with CM() as cm:
                self.assertIs(cm.__class__, CM)
                raise RuntimeError

run_async(foo())

def test_with_13(self):
        CNT = 0

class CM:
            async def __aenter__(self):
                1/0

async def __aexit__(self, *e):
                return True

async def foo():
            nonlocal CNT
            CNT += 1
            async with CM():
                CNT += 1000
            CNT += 10000

with self.assertRaises(ZeroDivisionError):
            run_async(foo())
        self.assertEqual(CNT, 1)

def test_for_1(self):
        aiter_calls = 0

class AsyncIter:
            def __init__(self):
                self.i = 0

def __aiter__(self):
                nonlocal aiter_calls
                aiter_calls += 1
                return self

async def __anext__(self):
                self.i += 1

if not (self.i % 10):
                    await AsyncYield(self.i * 10)

if self.i > 100:
                    raise StopAsyncIteration

return self.i, self.i

buffer = []
        async def test1():
            async for i1, i2 in AsyncIter():
                buffer.append(i1 + i2)

yielded, _ = run_async(test1())
        # Make sure that __aiter__ was called only once
        self.assertEqual(aiter_calls, 1)
        self.assertEqual(yielded, [i * 100 for i in range(1, 11)])
        self.assertEqual(buffer, [i*2 for i in range(1, 101)])

buffer = []
        async def test2():
            nonlocal buffer
            async for i in AsyncIter():
                buffer.append(i[0])
                if i[0] == 20:
                    break
            else:
                buffer.append('what?')
            buffer.append('end')

yielded, _ = run_async(test2())
        # Make sure that __aiter__ was called only once
        self.assertEqual(aiter_calls, 2)
        self.assertEqual(yielded, [100, 200])
        self.assertEqual(buffer, [i for i in range(1, 21)] + ['end'])

buffer = []
        async def test3():
            nonlocal buffer
            async for i in AsyncIter():
                if i[0] > 20:
                    continue
                buffer.append(i[0])
            else:
                buffer.append('what?')
            buffer.append('end')

yielded, _ = run_async(test3())
        # Make sure that __aiter__ was called only once
        self.assertEqual(aiter_calls, 3)
        self.assertEqual(yielded, [i * 100 for i in range(1, 11)])
        self.assertEqual(buffer, [i for i in range(1, 21)] +
                                 ['what?', 'end'])

def test_for_2(self):
        tup = (1, 2, 3)
        refs_before = sys.getrefcount(tup)

async def foo():
            async for i in tup:
                print('never going to happen')

with self.assertRaisesRegex(
                TypeError, "async for' requires an object.*__aiter__.*tuple"):

run_async(foo())

self.assertEqual(sys.getrefcount(tup), refs_before)

def test_for_3(self):
        class I:
            def __aiter__(self):
                return self

aiter = I()
        refs_before = sys.getrefcount(aiter)

async def foo():
            async for i in aiter:
                print('never going to happen')

with self.assertRaisesRegex(
                TypeError,
                r"that does not implement __anext__"):

run_async(foo())

self.assertEqual(sys.getrefcount(aiter), refs_before)

def test_for_4(self):
        class I:
            def __aiter__(self):
                return self

def __anext__(self):
                return ()

aiter = I()
        refs_before = sys.getrefcount(aiter)

async def foo():
            async for i in aiter:
                print('never going to happen')

with self.assertRaisesRegex(
                TypeError,
                "async for' received an invalid object.*__anext__.*tuple"):

run_async(foo())

self.assertEqual(sys.getrefcount(aiter), refs_before)

def test_for_6(self):
        I = 0

class Manager:
            async def __aenter__(self):
                nonlocal I
                I += 10000

async def __aexit__(self, *args):
                nonlocal I
                I += 100000

class Iterable:
            def __init__(self):
                self.i = 0

def __aiter__(self):
                return self

async def __anext__(self):
                if self.i > 10:
                    raise StopAsyncIteration
                self.i += 1
                return self.i

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

manager = Manager()
        iterable = Iterable()
        mrefs_before = sys.getrefcount(manager)
        irefs_before = sys.getrefcount(iterable)

async def main():
            nonlocal I

async with manager:
                async for i in iterable:
                    I += 1
            I += 1000

with warnings.catch_warnings():
            warnings.simplefilter("error")
            # Test that __aiter__ that returns an asynchronous iterator
            # directly does not throw any warnings.
            run_async(main())
        self.assertEqual(I, 111011)

self.assertEqual(sys.getrefcount(manager), mrefs_before)
        self.assertEqual(sys.getrefcount(iterable), irefs_before)

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

async def main():
            nonlocal I

async with Manager():
                async for i in Iterable():
                    I += 1
            I += 1000

run_async(main())
        self.assertEqual(I, 333033)

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

async def main():
            nonlocal I

async with Manager():
                I += 100
                async for i in Iterable():
                    I += 1
                else:
                    I += 10000000
            I += 1000

run_async(main())
        self.assertEqual(I, 20555255)

def test_for_7(self):
        CNT = 0
        class AI:
            def __aiter__(self):
                1/0
        async def foo():
            nonlocal CNT
            async for i in AI():
                CNT += 1
            CNT += 10
        with self.assertRaises(ZeroDivisionError):
            run_async(foo())
        self.assertEqual(CNT, 0)

def test_for_8(self):
        CNT = 0
        class AI:
            def __aiter__(self):
                1/0
        async def foo():
            nonlocal CNT
            async for i in AI():
                CNT += 1
            CNT += 10
        with self.assertRaises(ZeroDivisionError):
            with warnings.catch_warnings():
                warnings.simplefilter("error")
                # Test that if __aiter__ raises an exception it propagates
                # without any kind of warning.
                run_async(foo())
        self.assertEqual(CNT, 0)

def test_for_11(self):
        class F:
            def __aiter__(self):
                return self
            def __anext__(self):
                return self
            def __await__(self):
                1 / 0

async def main():
            async for _ in F():
                pass

with self.assertRaisesRegex(TypeError,
                                    'an invalid object from __anext__') as c:
            main().send(None)

err = c.exception
        self.assertIsInstance(err.__cause__, ZeroDivisionError)

def test_for_tuple(self):
        class Done(Exception): pass

class AIter(tuple):
            i = 0
            def __aiter__(self):
                return self
            async def __anext__(self):
                if self.i >= len(self):
                    raise StopAsyncIteration
                self.i += 1
                return self[self.i - 1]

result = []
        async def foo():
            async for i in AIter([42]):
                result.append(i)
            raise Done

with self.assertRaises(Done):
            foo().send(None)
        self.assertEqual(result, [42])

def test_for_stop_iteration(self):
        class Done(Exception): pass

class AIter(StopIteration):
            i = 0
            def __aiter__(self):
                return self
            async def __anext__(self):
                if self.i:
                    raise StopAsyncIteration
                self.i += 1
                return self.value

result = []
        async def foo():
            async for i in AIter(42):
                result.append(i)
            raise Done

with self.assertRaises(Done):
            foo().send(None)
        self.assertEqual(result, [42])

def test_comp_1(self):
        async def f(i):
            return i

async def run_list():
            return [await c for c in [f(1), f(41)]]

async def run_set():
            return {await c for c in [f(1), f(41)]}

async def run_dict1():
            return {await c: 'a' for c in [f(1), f(41)]}

async def run_dict2():
            return {i: await c for i, c in enumerate([f(1), f(41)])}

self.assertEqual(run_async(run_list()), ([], [1, 41]))
        self.assertEqual(run_async(run_set()), ([], {1, 41}))
        self.assertEqual(run_async(run_dict1()), ([], {1: 'a', 41: 'a'}))
        self.assertEqual(run_async(run_dict2()), ([], {0: 1, 1: 41}))

def test_comp_2(self):
        async def f(i):
            return i

async def run_list():
            return [s for c in [f(''), f('abc'), f(''), f(['de', 'fg'])]
                    for s in await c]

self.assertEqual(
            run_async(run_list()),
            ([], ['a', 'b', 'c', 'de', 'fg']))

async def run_set():
            return {d
                    for c in [f([f([10, 30]),
                                 f([20])])]
                    for s in await c
                    for d in await s}

self.assertEqual(
            run_async(run_set()),
            ([], {10, 20, 30}))

async def run_set2():
            return {await s
                    for c in [f([f(10), f(20)])]
                    for s in await c}

self.assertEqual(
            run_async(run_set2()),
            ([], {10, 20}))

def test_comp_3(self):
        async def f(it):
            for i in it:
                yield i

async def run_list():
            return [i + 1 async for i in f([10, 20])]
        self.assertEqual(
            run_async(run_list()),
            ([], [11, 21]))

async def run_set():
            return {i + 1 async for i in f([10, 20])}
        self.assertEqual(
            run_async(run_set()),
            ([], {11, 21}))

async def run_dict():
            return {i + 1: i + 2 async for i in f([10, 20])}
        self.assertEqual(
            run_async(run_dict()),
            ([], {11: 12, 21: 22}))

async def run_gen():
            gen = (i + 1 async for i in f([10, 20]))
            return [g + 100 async for g in gen]
        self.assertEqual(
            run_async(run_gen()),
            ([], [111, 121]))

def test_comp_4(self):
        async def f(it):
            for i in it:
                yield i

async def run_list():
            return [i + 1 async for i in f([10, 20]) if i > 10]
        self.assertEqual(
            run_async(run_list()),
            ([], [21]))

async def run_set():
            return {i + 1 async for i in f([10, 20]) if i > 10}
        self.assertEqual(
            run_async(run_set()),
            ([], {21}))

async def run_dict():
            return {i + 1: i + 2 async for i in f([10, 20]) if i > 10}
        self.assertEqual(
            run_async(run_dict()),
            ([], {21: 22}))

async def run_gen():
            gen = (i + 1 async for i in f([10, 20]) if i > 10)
            return [g + 100 async for g in gen]
        self.assertEqual(
            run_async(run_gen()),
            ([], [121]))

def test_comp_4_2(self):
        async def f(it):
            for i in it:
                yield i

async def run_list():
            return [i + 10 async for i in f(range(5)) if 0 < i < 4]
        self.assertEqual(
            run_async(run_list()),
            ([], [11, 12, 13]))

async def run_set():
            return {i + 10 async for i in f(range(5)) if 0 < i < 4}
        self.assertEqual(
            run_async(run_set()),
            ([], {11, 12, 13}))

async def run_dict():
            return {i + 10: i + 100 async for i in f(range(5)) if 0 < i < 4}
        self.assertEqual(
            run_async(run_dict()),
            ([], {11: 101, 12: 102, 13: 103}))

async def run_gen():
            gen = (i + 10 async for i in f(range(5)) if 0 < i < 4)
            return [g + 100 async for g in gen]
        self.assertEqual(
            run_async(run_gen()),
            ([], [111, 112, 113]))

def test_comp_5(self):
        async def f(it):
            for i in it:
                yield i

async def run_list():
            return [i + 1 for pair in ([10, 20], [30, 40]) if pair[0] > 10
                    async for i in f(pair) if i > 30]
        self.assertEqual(
            run_async(run_list()),
            ([], [41]))

def test_comp_6(self):
        async def f(it):
            for i in it:
                yield i

async def run_list():
            return [i + 1 async for seq in f([(10, 20), (30,)])
                    for i in seq]

self.assertEqual(
            run_async(run_list()),
            ([], [11, 21, 31]))

def test_comp_7(self):
        async def f():
            yield 1
            yield 2
            raise Exception('aaa')

async def run_list():
            return [i async for i in f()]

with self.assertRaisesRegex(Exception, 'aaa'):
            run_async(run_list())

def test_comp_8(self):
        async def f():
            return [i for i in [1, 2, 3]]

self.assertEqual(
            run_async(f()),
            ([], [1, 2, 3]))

def test_comp_9(self):
        async def gen():
            yield 1
            yield 2
        async def f():
            l = [i async for i in gen()]
            return [i for i in l]

self.assertEqual(
            run_async(f()),
            ([], [1, 2]))

def test_comp_10(self):
        async def f():
            xx = {i for i in [1, 2, 3]}
            return {x: x for x in xx}

self.assertEqual(
            run_async(f()),
            ([], {1: 1, 2: 2, 3: 3}))

def test_copy(self):
        async def func(): pass
        coro = func()
        with self.assertRaises(TypeError):
            copy.copy(coro)

aw = coro.__await__()
        try:
            with self.assertRaises(TypeError):
                copy.copy(aw)
        finally:
            aw.close()

def test_pickle(self):
        async def func(): pass
        coro = func()
        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
            with self.assertRaises((TypeError, pickle.PicklingError)):
                pickle.dumps(coro, proto)

aw = coro.__await__()
        try:
            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
                with self.assertRaises((TypeError, pickle.PicklingError)):
                    pickle.dumps(aw, proto)
        finally:
            aw.close()

def test_fatal_coro_warning(self):
        # Issue 27811
        async def func(): pass
        with warnings.catch_warnings(), \
             support.catch_unraisable_exception() as cm:
            warnings.filterwarnings("error")
            coro = func()
            # only store repr() to avoid keeping the coroutine alive
            coro_repr = repr(coro)
            coro = None
            support.gc_collect()

self.assertIn("was never awaited", str(cm.unraisable.exc_value))
            self.assertEqual(repr(cm.unraisable.object), coro_repr)

def test_for_assign_raising_stop_async_iteration(self):
        class BadTarget:
            def __setitem__(self, key, value):
                raise StopAsyncIteration(42)
        tgt = BadTarget()
        async def source():
            yield 10

async def run_for():
            with self.assertRaises(StopAsyncIteration) as cm:
                async for tgt[0] in source():
                    pass
            self.assertEqual(cm.exception.args, (42,))
            return 'end'
        self.assertEqual(run_async(run_for()), ([], 'end'))

async def run_list():
            with self.assertRaises(StopAsyncIteration) as cm:
                return [0 async for tgt[0] in source()]
            self.assertEqual(cm.exception.args, (42,))
            return 'end'
        self.assertEqual(run_async(run_list()), ([], 'end'))

async def run_gen():
            gen = (0 async for tgt[0] in source())
            a = gen.asend(None)
            with self.assertRaises(RuntimeError) as cm:
                await a
            self.assertIsInstance(cm.exception.__cause__, StopAsyncIteration)
            self.assertEqual(cm.exception.__cause__.args, (42,))
            return 'end'
        self.assertEqual(run_async(run_gen()), ([], 'end'))

def test_for_assign_raising_stop_async_iteration_2(self):
        class BadIterable:
            def __iter__(self):
                raise StopAsyncIteration(42)
        async def badpairs():
            yield BadIterable()

async def run_for():
            with self.assertRaises(StopAsyncIteration) as cm:
                async for i, j in badpairs():
                    pass
            self.assertEqual(cm.exception.args, (42,))
            return 'end'
        self.assertEqual(run_async(run_for()), ([], 'end'))

async def run_list():
            with self.assertRaises(StopAsyncIteration) as cm:
                return [0 async for i, j in badpairs()]
            self.assertEqual(cm.exception.args, (42,))
            return 'end'
        self.assertEqual(run_async(run_list()), ([], 'end'))

async def run_gen():
            gen = (0 async for i, j in badpairs())
            a = gen.asend(None)
            with self.assertRaises(RuntimeError) as cm:
                await a
            self.assertIsInstance(cm.exception.__cause__, StopAsyncIteration)
            self.assertEqual(cm.exception.__cause__.args, (42,))
            return 'end'
        self.assertEqual(run_async(run_gen()), ([], 'end'))

class CoroAsyncIOCompatTest(unittest.TestCase):

def test_asyncio_1(self):
        # asyncio cannot be imported when Python is compiled without thread
        # support
        asyncio = support.import_module('asyncio')

class MyException(Exception):
            pass

buffer = []

class CM:
            async def __aenter__(self):
                buffer.append(1)
                await asyncio.sleep(0.01)
                buffer.append(2)
                return self

async def __aexit__(self, exc_type, exc_val, exc_tb):
                await asyncio.sleep(0.01)
                buffer.append(exc_type.__name__)

async def f():
            async with CM() as c:
                await asyncio.sleep(0.01)
                raise MyException
            buffer.append('unreachable')

loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
        try:
            loop.run_until_complete(f())
        except MyException:
            pass
        finally:
            loop.close()
            asyncio.set_event_loop_policy(None)

self.assertEqual(buffer, [1, 2, 'MyException'])

class OriginTrackingTest(unittest.TestCase):
    def here(self):
        info = inspect.getframeinfo(inspect.currentframe().f_back)
        return (info.filename, info.lineno)

def test_origin_tracking(self):
        orig_depth = sys.get_coroutine_origin_tracking_depth()
        try:
            async def corofn():
                pass

sys.set_coroutine_origin_tracking_depth(0)
            self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 0)

with contextlib.closing(corofn()) as coro:
                self.assertIsNone(coro.cr_origin)

sys.set_coroutine_origin_tracking_depth(1)
            self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 1)

fname, lineno = self.here()
            with contextlib.closing(corofn()) as coro:
                self.assertEqual(coro.cr_origin,
                                 ((fname, lineno + 1, "test_origin_tracking"),))

sys.set_coroutine_origin_tracking_depth(2)
            self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 2)

def nested():
                return (self.here(), corofn())
            fname, lineno = self.here()
            ((nested_fname, nested_lineno), coro) = nested()
            with contextlib.closing(coro):
                self.assertEqual(coro.cr_origin,
                                 ((nested_fname, nested_lineno, "nested"),
                                  (fname, lineno + 1, "test_origin_tracking")))

# Check we handle running out of frames correctly
            sys.set_coroutine_origin_tracking_depth(1000)
            with contextlib.closing(corofn()) as coro:
                self.assertTrue(2 < len(coro.cr_origin) < 1000)

# We can't set depth negative
            with self.assertRaises(ValueError):
                sys.set_coroutine_origin_tracking_depth(-1)
            # And trying leaves it unchanged
            self.assertEqual(sys.get_coroutine_origin_tracking_depth(), 1000)

finally:
            sys.set_coroutine_origin_tracking_depth(orig_depth)

def test_origin_tracking_warning(self):
        async def corofn():
            pass

a1_filename, a1_lineno = self.here()
        def a1():
            return corofn()  # comment in a1
        a1_lineno += 2

a2_filename, a2_lineno = self.here()
        def a2():
            return a1()  # comment in a2
        a2_lineno += 2

def check(depth, msg):
            sys.set_coroutine_origin_tracking_depth(depth)
            with self.assertWarns(RuntimeWarning) as cm:
                a2()
                support.gc_collect()
            self.assertEqual(msg, str(cm.warning))

orig_depth = sys.get_coroutine_origin_tracking_depth()
        try:
            msg = check(0, f"coroutine '{corofn.__qualname__}' was never awaited")
            check(1, "".join([
                f"coroutine '{corofn.__qualname__}' was never awaited\n",
                "Coroutine created at (most recent call last)\n",
                f'  File "{a1_filename}", line {a1_lineno}, in a1\n',
                f'    return corofn()  # comment in a1',
            ]))
            check(2, "".join([
                f"coroutine '{corofn.__qualname__}' was never awaited\n",
                "Coroutine created at (most recent call last)\n",
                f'  File "{a2_filename}", line {a2_lineno}, in a2\n',
                f'    return a1()  # comment in a2\n',
                f'  File "{a1_filename}", line {a1_lineno}, in a1\n',
                f'    return corofn()  # comment in a1',
            ]))

finally:
            sys.set_coroutine_origin_tracking_depth(orig_depth)

def test_unawaited_warning_when_module_broken(self):
        # Make sure we don't blow up too bad if
        # warnings._warn_unawaited_coroutine is broken somehow (e.g. because
        # of shutdown problems)
        async def corofn():
            pass

orig_wuc = warnings._warn_unawaited_coroutine
        try:
            warnings._warn_unawaited_coroutine = lambda coro: 1/0
            with support.catch_unraisable_exception() as cm, \
                 support.check_warnings((r'coroutine .* was never awaited',
                                         RuntimeWarning)):
                # only store repr() to avoid keeping the coroutine alive
                coro = corofn()
                coro_repr = repr(coro)

# clear reference to the coroutine without awaiting for it
                del coro
                support.gc_collect()

self.assertEqual(repr(cm.unraisable.object), coro_repr)
                self.assertEqual(cm.unraisable.exc_type, ZeroDivisionError)

del warnings._warn_unawaited_coroutine
            with support.check_warnings((r'coroutine .* was never awaited',
                                         RuntimeWarning)):
                corofn()
                support.gc_collect()

finally:
            warnings._warn_unawaited_coroutine = orig_wuc

class UnawaitedWarningDuringShutdownTest(unittest.TestCase):
    # https://bugs.python.org/issue32591#msg310726
    def test_unawaited_warning_during_shutdown(self):
        code = ("import asyncio\n"
                "async def f(): pass\n"
                "asyncio.gather(f())\n")
        assert_python_ok("-c", code)

code = ("import sys\n"
                "async def f(): pass\n"
                "sys.coro = f()\n")
        assert_python_ok("-c", code)

code = ("import sys\n"
                "async def f(): pass\n"
                "sys.corocycle = [f()]\n"
                "sys.corocycle.append(sys.corocycle)\n")
        assert_python_ok("-c", code)

@support.cpython_only
class CAPITest(unittest.TestCase):

def test_tp_await_1(self):
        from _testcapi import awaitType as at

async def foo():
            future = at(iter([1]))
            return (await future)

self.assertEqual(foo().send(None), 1)

def test_tp_await_2(self):
        # Test tp_await to __await__ mapping
        from _testcapi import awaitType as at
        future = at(iter([1]))
        self.assertEqual(next(future.__await__()), 1)

def test_tp_await_3(self):
        from _testcapi import awaitType as at

async def foo():
            future = at(1)
            return (await future)

with self.assertRaisesRegex(
                TypeError, "__await__.*returned non-iterator of type 'int'"):
            self.assertEqual(foo().send(None), 1)

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

003 File Manager

Editing: test_coroutines.py

Upload File

Create Folder