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

import copy
import parser
import pickle
import unittest
import operator
import struct
from test import support
from test.support.script_helper import assert_python_failure

#
#  First, we test that we can generate trees from valid source fragments,
#  and that these valid trees are indeed allowed by the tree-loading side
#  of the parser module.
#

class RoundtripLegalSyntaxTestCase(unittest.TestCase):

def roundtrip(self, f, s):
        st1 = f(s)
        t = st1.totuple()
        try:
            st2 = parser.sequence2st(t)
        except parser.ParserError as why:
            self.fail("could not roundtrip %r: %s" % (s, why))

self.assertEqual(t, st2.totuple(),
                         "could not re-generate syntax tree")

def check_expr(self, s):
        self.roundtrip(parser.expr, s)

def test_flags_passed(self):
        # The unicode literals flags has to be passed from the parser to AST
        # generation.
        suite = parser.suite("from __future__ import unicode_literals; x = ''")
        code = suite.compile()
        scope = {}
        exec(code, {}, scope)
        self.assertIsInstance(scope["x"], str)

def check_suite(self, s):
        self.roundtrip(parser.suite, s)

def test_yield_statement(self):
        self.check_suite("def f(): yield 1")
        self.check_suite("def f(): yield")
        self.check_suite("def f(): x += yield")
        self.check_suite("def f(): x = yield 1")
        self.check_suite("def f(): x = y = yield 1")
        self.check_suite("def f(): x = yield")
        self.check_suite("def f(): x = y = yield")
        self.check_suite("def f(): 1 + (yield)*2")
        self.check_suite("def f(): (yield 1)*2")
        self.check_suite("def f(): return; yield 1")
        self.check_suite("def f(): yield 1; return")
        self.check_suite("def f(): yield from 1")
        self.check_suite("def f(): x = yield from 1")
        self.check_suite("def f(): f((yield from 1))")
        self.check_suite("def f(): yield 1; return 1")
        self.check_suite("def f():\n"
                         "    for x in range(30):\n"
                         "        yield x\n")
        self.check_suite("def f():\n"
                         "    if (yield):\n"
                         "        yield x\n")

def test_await_statement(self):
        self.check_suite("async def f():\n await smth()")
        self.check_suite("async def f():\n foo = await smth()")
        self.check_suite("async def f():\n foo, bar = await smth()")
        self.check_suite("async def f():\n (await smth())")
        self.check_suite("async def f():\n foo((await smth()))")
        self.check_suite("async def f():\n await foo(); return 42")

def test_async_with_statement(self):
        self.check_suite("async def f():\n async with 1: pass")
        self.check_suite("async def f():\n async with a as b, c as d: pass")

def test_async_for_statement(self):
        self.check_suite("async def f():\n async for i in (): pass")
        self.check_suite("async def f():\n async for i, b in (): pass")

def test_nonlocal_statement(self):
        self.check_suite("def f():\n"
                         "    x = 0\n"
                         "    def g():\n"
                         "        nonlocal x\n")
        self.check_suite("def f():\n"
                         "    x = y = 0\n"
                         "    def g():\n"
                         "        nonlocal x, y\n")

def test_expressions(self):
        self.check_expr("foo(1)")
        self.check_expr("[1, 2, 3]")
        self.check_expr("[x**3 for x in range(20)]")
        self.check_expr("[x**3 for x in range(20) if x % 3]")
        self.check_expr("[x**3 for x in range(20) if x % 2 if x % 3]")
        self.check_expr("list(x**3 for x in range(20))")
        self.check_expr("list(x**3 for x in range(20) if x % 3)")
        self.check_expr("list(x**3 for x in range(20) if x % 2 if x % 3)")
        self.check_expr("foo(*args)")
        self.check_expr("foo(*args, **kw)")
        self.check_expr("foo(**kw)")
        self.check_expr("foo(key=value)")
        self.check_expr("foo(key=value, *args)")
        self.check_expr("foo(key=value, *args, **kw)")
        self.check_expr("foo(key=value, **kw)")
        self.check_expr("foo(a, b, c, *args)")
        self.check_expr("foo(a, b, c, *args, **kw)")
        self.check_expr("foo(a, b, c, **kw)")
        self.check_expr("foo(a, *args, keyword=23)")
        self.check_expr("foo + bar")
        self.check_expr("foo - bar")
        self.check_expr("foo * bar")
        self.check_expr("foo / bar")
        self.check_expr("foo // bar")
        self.check_expr("(foo := 1)")
        self.check_expr("lambda: 0")
        self.check_expr("lambda x: 0")
        self.check_expr("lambda *y: 0")
        self.check_expr("lambda *y, **z: 0")
        self.check_expr("lambda **z: 0")
        self.check_expr("lambda x, y: 0")
        self.check_expr("lambda foo=bar: 0")
        self.check_expr("lambda foo=bar, spaz=nifty+spit: 0")
        self.check_expr("lambda foo=bar, **z: 0")
        self.check_expr("lambda foo=bar, blaz=blat+2, **z: 0")
        self.check_expr("lambda foo=bar, blaz=blat+2, *y, **z: 0")
        self.check_expr("lambda x, *y, **z: 0")
        self.check_expr("(x for x in range(10))")
        self.check_expr("foo(x for x in range(10))")
        self.check_expr("...")
        self.check_expr("a[...]")

def test_simple_expression(self):
        # expr_stmt
        self.check_suite("a")

def test_simple_assignments(self):
        self.check_suite("a = b")
        self.check_suite("a = b = c = d = e")

def test_var_annot(self):
        self.check_suite("x: int = 5")
        self.check_suite("y: List[T] = []; z: [list] = fun()")
        self.check_suite("x: tuple = (1, 2)")
        self.check_suite("d[f()]: int = 42")
        self.check_suite("f(d[x]): str = 'abc'")
        self.check_suite("x.y.z.w: complex = 42j")
        self.check_suite("x: int")
        self.check_suite("def f():\n"
                         "    x: str\n"
                         "    y: int = 5\n")
        self.check_suite("class C:\n"
                         "    x: str\n"
                         "    y: int = 5\n")
        self.check_suite("class C:\n"
                         "    def __init__(self, x: int) -> None:\n"
                         "        self.x: int = x\n")
        # double check for nonsense
        with self.assertRaises(SyntaxError):
            exec("2+2: int", {}, {})
        with self.assertRaises(SyntaxError):
            exec("[]: int = 5", {}, {})
        with self.assertRaises(SyntaxError):
            exec("x, *y, z: int = range(5)", {}, {})
        with self.assertRaises(SyntaxError):
            exec("x: int = 1, y = 2", {}, {})
        with self.assertRaises(SyntaxError):
            exec("u = v: int", {}, {})
        with self.assertRaises(SyntaxError):
            exec("False: int", {}, {})
        with self.assertRaises(SyntaxError):
            exec("x.False: int", {}, {})
        with self.assertRaises(SyntaxError):
            exec("x.y,: int", {}, {})
        with self.assertRaises(SyntaxError):
            exec("[0]: int", {}, {})
        with self.assertRaises(SyntaxError):
            exec("f(): int", {}, {})

def test_simple_augmented_assignments(self):
        self.check_suite("a += b")
        self.check_suite("a -= b")
        self.check_suite("a *= b")
        self.check_suite("a /= b")
        self.check_suite("a //= b")
        self.check_suite("a %= b")
        self.check_suite("a &= b")
        self.check_suite("a |= b")
        self.check_suite("a ^= b")
        self.check_suite("a <<= b")
        self.check_suite("a >>= b")
        self.check_suite("a **= b")

def test_function_defs(self):
        self.check_suite("def f(): pass")
        self.check_suite("def f(*args): pass")
        self.check_suite("def f(*args, **kw): pass")
        self.check_suite("def f(**kw): pass")
        self.check_suite("def f(foo=bar): pass")
        self.check_suite("def f(foo=bar, *args): pass")
        self.check_suite("def f(foo=bar, *args, **kw): pass")
        self.check_suite("def f(foo=bar, **kw): pass")

self.check_suite("def f(a, b): pass")
        self.check_suite("def f(a, b, *args): pass")
        self.check_suite("def f(a, b, *args, **kw): pass")
        self.check_suite("def f(a, b, **kw): pass")
        self.check_suite("def f(a, b, foo=bar): pass")
        self.check_suite("def f(a, b, foo=bar, *args): pass")
        self.check_suite("def f(a, b, foo=bar, *args, **kw): pass")
        self.check_suite("def f(a, b, foo=bar, **kw): pass")

self.check_suite("@staticmethod\n"
                         "def f(): pass")
        self.check_suite("@staticmethod\n"
                         "@funcattrs(x, y)\n"
                         "def f(): pass")
        self.check_suite("@funcattrs()\n"
                         "def f(): pass")

# keyword-only arguments
        self.check_suite("def f(*, a): pass")
        self.check_suite("def f(*, a = 5): pass")
        self.check_suite("def f(*, a = 5, b): pass")
        self.check_suite("def f(*, a, b = 5): pass")
        self.check_suite("def f(*, a, b = 5, **kwds): pass")
        self.check_suite("def f(*args, a): pass")
        self.check_suite("def f(*args, a = 5): pass")
        self.check_suite("def f(*args, a = 5, b): pass")
        self.check_suite("def f(*args, a, b = 5): pass")
        self.check_suite("def f(*args, a, b = 5, **kwds): pass")

# positional-only arguments
        self.check_suite("def f(a, /): pass")
        self.check_suite("def f(a, /,): pass")
        self.check_suite("def f(a, b, /): pass")
        self.check_suite("def f(a, b, /, c): pass")
        self.check_suite("def f(a, b, /, c = 6): pass")
        self.check_suite("def f(a, b, /, c, *, d): pass")
        self.check_suite("def f(a, b, /, c = 1, *, d): pass")
        self.check_suite("def f(a, b, /, c, *, d = 1): pass")
        self.check_suite("def f(a, b=1, /, c=2, *, d = 3): pass")
        self.check_suite("def f(a=0, b=1, /, c=2, *, d = 3): pass")

# function annotations
        self.check_suite("def f(a: int): pass")
        self.check_suite("def f(a: int = 5): pass")
        self.check_suite("def f(*args: list): pass")
        self.check_suite("def f(**kwds: dict): pass")
        self.check_suite("def f(*, a: int): pass")
        self.check_suite("def f(*, a: int = 5): pass")
        self.check_suite("def f() -> int: pass")

def test_class_defs(self):
        self.check_suite("class foo():pass")
        self.check_suite("class foo(object):pass")
        self.check_suite("@class_decorator\n"
                         "class foo():pass")
        self.check_suite("@class_decorator(arg)\n"
                         "class foo():pass")
        self.check_suite("@decorator1\n"
                         "@decorator2\n"
                         "class foo():pass")

def test_import_from_statement(self):
        self.check_suite("from sys.path import *")
        self.check_suite("from sys.path import dirname")
        self.check_suite("from sys.path import (dirname)")
        self.check_suite("from sys.path import (dirname,)")
        self.check_suite("from sys.path import dirname as my_dirname")
        self.check_suite("from sys.path import (dirname as my_dirname)")
        self.check_suite("from sys.path import (dirname as my_dirname,)")
        self.check_suite("from sys.path import dirname, basename")
        self.check_suite("from sys.path import (dirname, basename)")
        self.check_suite("from sys.path import (dirname, basename,)")
        self.check_suite(
            "from sys.path import dirname as my_dirname, basename")
        self.check_suite(
            "from sys.path import (dirname as my_dirname, basename)")
        self.check_suite(
            "from sys.path import (dirname as my_dirname, basename,)")
        self.check_suite(
            "from sys.path import dirname, basename as my_basename")
        self.check_suite(
            "from sys.path import (dirname, basename as my_basename)")
        self.check_suite(
            "from sys.path import (dirname, basename as my_basename,)")
        self.check_suite("from .bogus import x")

def test_basic_import_statement(self):
        self.check_suite("import sys")
        self.check_suite("import sys as system")
        self.check_suite("import sys, math")
        self.check_suite("import sys as system, math")
        self.check_suite("import sys, math as my_math")

def test_relative_imports(self):
        self.check_suite("from . import name")
        self.check_suite("from .. import name")
        # check all the way up to '....', since '...' is tokenized
        # differently from '.' (it's an ellipsis token).
        self.check_suite("from ... import name")
        self.check_suite("from .... import name")
        self.check_suite("from .pkg import name")
        self.check_suite("from ..pkg import name")
        self.check_suite("from ...pkg import name")
        self.check_suite("from ....pkg import name")

def test_pep263(self):
        self.check_suite("# -*- coding: iso-8859-1 -*-\n"
                         "pass\n")

def test_assert(self):
        self.check_suite("assert alo < ahi and blo < bhi\n")

def test_with(self):
        self.check_suite("with open('x'): pass\n")
        self.check_suite("with open('x') as f: pass\n")
        self.check_suite("with open('x') as f, open('y') as g: pass\n")

def test_try_stmt(self):
        self.check_suite("try: pass\nexcept: pass\n")
        self.check_suite("try: pass\nfinally: pass\n")
        self.check_suite("try: pass\nexcept A: pass\nfinally: pass\n")
        self.check_suite("try: pass\nexcept A: pass\nexcept: pass\n"
                         "finally: pass\n")
        self.check_suite("try: pass\nexcept: pass\nelse: pass\n")
        self.check_suite("try: pass\nexcept: pass\nelse: pass\n"
                         "finally: pass\n")

def test_if_stmt(self):
        self.check_suite("if True:\n  pass\nelse:\n  pass\n")
        self.check_suite("if True:\n  pass\nelif True:\n  pass\nelse:\n  pass\n")

def test_position(self):
        # An absolutely minimal test of position information.  Better
        # tests would be a big project.
        code = "def f(x):\n    return x + 1"
        st = parser.suite(code)

def walk(tree):
            node_type = tree[0]
            next = tree[1]
            if isinstance(next, (tuple, list)):
                for elt in tree[1:]:
                    for x in walk(elt):
                        yield x
            else:
                yield tree

expected = [
            (1, 'def', 1, 0),
            (1, 'f', 1, 4),
            (7, '(', 1, 5),
            (1, 'x', 1, 6),
            (8, ')', 1, 7),
            (11, ':', 1, 8),
            (4, '', 1, 9),
            (5, '', 2, -1),
            (1, 'return', 2, 4),
            (1, 'x', 2, 11),
            (14, '+', 2, 13),
            (2, '1', 2, 15),
            (4, '', 2, 16),
            (6, '', 2, -1),
            (4, '', 2, -1),
            (0, '', 2, -1),
        ]

self.assertEqual(list(walk(st.totuple(line_info=True, col_info=True))),
                         expected)
        self.assertEqual(list(walk(st.totuple())),
                         [(t, n) for t, n, l, c in expected])
        self.assertEqual(list(walk(st.totuple(line_info=True))),
                         [(t, n, l) for t, n, l, c in expected])
        self.assertEqual(list(walk(st.totuple(col_info=True))),
                         [(t, n, c) for t, n, l, c in expected])
        self.assertEqual(list(walk(st.tolist(line_info=True, col_info=True))),
                         [list(x) for x in expected])
        self.assertEqual(list(walk(parser.st2tuple(st, line_info=True,
                                                   col_info=True))),
                         expected)
        self.assertEqual(list(walk(parser.st2list(st, line_info=True,
                                                  col_info=True))),
                         [list(x) for x in expected])

def test_extended_unpacking(self):
        self.check_suite("*a = y")
        self.check_suite("x, *b, = m")
        self.check_suite("[*a, *b] = y")
        self.check_suite("for [*x, b] in x: pass")

def test_raise_statement(self):
        self.check_suite("raise\n")
        self.check_suite("raise e\n")
        self.check_suite("try:\n"
                         "    suite\n"
                         "except Exception as e:\n"
                         "    raise ValueError from e\n")

def test_list_displays(self):
        self.check_expr('[]')
        self.check_expr('[*{2}, 3, *[4]]')

def test_set_displays(self):
        self.check_expr('{*{2}, 3, *[4]}')
        self.check_expr('{2}')
        self.check_expr('{2,}')
        self.check_expr('{2, 3}')
        self.check_expr('{2, 3,}')

def test_dict_displays(self):
        self.check_expr('{}')
        self.check_expr('{a:b}')
        self.check_expr('{a:b,}')
        self.check_expr('{a:b, c:d}')
        self.check_expr('{a:b, c:d,}')
        self.check_expr('{**{}}')
        self.check_expr('{**{}, 3:4, **{5:6, 7:8}}')

def test_argument_unpacking(self):
        self.check_expr("f(*a, **b)")
        self.check_expr('f(a, *b, *c, *d)')
        self.check_expr('f(**a, **b)')
        self.check_expr('f(2, *a, *b, **b, **c, **d)')
        self.check_expr("f(*b, *() or () and (), **{} and {}, **() or {})")

def test_set_comprehensions(self):
        self.check_expr('{x for x in seq}')
        self.check_expr('{f(x) for x in seq}')
        self.check_expr('{f(x) for x in seq if condition(x)}')

def test_dict_comprehensions(self):
        self.check_expr('{x:x for x in seq}')
        self.check_expr('{x**2:x[3] for x in seq if condition(x)}')
        self.check_expr('{x:x for x in seq1 for y in seq2 if condition(x, y)}')

def test_named_expressions(self):
        self.check_suite("(a := 1)")
        self.check_suite("(a := a)")
        self.check_suite("if (match := pattern.search(data)) is None: pass")
        self.check_suite("while match := pattern.search(f.read()): pass")
        self.check_suite("[y := f(x), y**2, y**3]")
        self.check_suite("filtered_data = [y for x in data if (y := f(x)) is None]")
        self.check_suite("(y := f(x))")
        self.check_suite("y0 = (y1 := f(x))")
        self.check_suite("foo(x=(y := f(x)))")
        self.check_suite("def foo(answer=(p := 42)): pass")
        self.check_suite("def foo(answer: (p := 42) = 5): pass")
        self.check_suite("lambda: (x := 1)")
        self.check_suite("(x := lambda: 1)")
        self.check_suite("(x := lambda: (y := 1))")  # not in PEP
        self.check_suite("lambda line: (m := re.match(pattern, line)) and m.group(1)")
        self.check_suite("x = (y := 0)")
        self.check_suite("(z:=(y:=(x:=0)))")
        self.check_suite("(info := (name, phone, *rest))")
        self.check_suite("(x:=1,2)")
        self.check_suite("(total := total + tax)")
        self.check_suite("len(lines := f.readlines())")
        self.check_suite("foo(x := 3, cat='vector')")
        self.check_suite("foo(cat=(category := 'vector'))")
        self.check_suite("if any(len(longline := l) >= 100 for l in lines): print(longline)")
        self.check_suite(
            "if env_base := os.environ.get('PYTHONUSERBASE', None): return env_base"
        )
        self.check_suite(
            "if self._is_special and (ans := self._check_nans(context=context)): return ans"
        )
        self.check_suite("foo(b := 2, a=1)")
        self.check_suite("foo(b := 2, a=1)")
        self.check_suite("foo((b := 2), a=1)")
        self.check_suite("foo(c=(b := 2), a=1)")
        self.check_suite("{(x := C(i)).q: x for i in y}")

#
#  Second, we take *invalid* trees and make sure we get ParserError
#  rejections for them.
#

class IllegalSyntaxTestCase(unittest.TestCase):

def check_bad_tree(self, tree, label):
        try:
            parser.sequence2st(tree)
        except parser.ParserError:
            pass
        else:
            self.fail("did not detect invalid tree for %r" % label)

def test_junk(self):
        # not even remotely valid:
        self.check_bad_tree((1, 2, 3), "<junk>")

def test_illegal_terminal(self):
        tree = \
            (257,
             (269,
              (270,
               (271,
                (277,
                 (1,))),
               (4, ''))),
             (4, ''),
             (0, ''))
        self.check_bad_tree(tree, "too small items in terminal node")
        tree = \
            (257,
             (269,
              (270,
               (271,
                (277,
                 (1, b'pass'))),
               (4, ''))),
             (4, ''),
             (0, ''))
        self.check_bad_tree(tree, "non-string second item in terminal node")
        tree = \
            (257,
             (269,
              (270,
               (271,
                (277,
                 (1, 'pass', '0', 0))),
               (4, ''))),
             (4, ''),
             (0, ''))
        self.check_bad_tree(tree, "non-integer third item in terminal node")
        tree = \
            (257,
             (269,
              (270,
               (271,
                (277,
                 (1, 'pass', 0, 0))),
               (4, ''))),
             (4, ''),
             (0, ''))
        self.check_bad_tree(tree, "too many items in terminal node")

def test_illegal_yield_1(self):
        # Illegal yield statement: def f(): return 1; yield 1
        tree = \
        (257,
         (264,
          (285,
           (259,
            (1, 'def'),
            (1, 'f'),
            (260, (7, '('), (8, ')')),
            (11, ':'),
            (291,
             (4, ''),
             (5, ''),
             (264,
              (265,
               (266,
                (272,
                 (275,
                  (1, 'return'),
                  (313,
                   (292,
                    (293,
                     (294,
                      (295,
                       (297,
                        (298,
                         (299,
                          (300,
                           (301,
                            (302, (303, (304, (305, (2, '1')))))))))))))))))),
               (264,
                (265,
                 (266,
                  (272,
                   (276,
                    (1, 'yield'),
                    (313,
                     (292,
                      (293,
                       (294,
                        (295,
                         (297,
                          (298,
                           (299,
                            (300,
                             (301,
                              (302,
                               (303, (304, (305, (2, '1')))))))))))))))))),
                 (4, ''))),
               (6, ''))))),
           (4, ''),
           (0, ''))))
        self.check_bad_tree(tree, "def f():\n  return 1\n  yield 1")

def test_illegal_yield_2(self):
        # Illegal return in generator: def f(): return 1; yield 1
        tree = \
        (257,
         (264,
          (265,
           (266,
            (278,
             (1, 'from'),
             (281, (1, '__future__')),
             (1, 'import'),
             (279, (1, 'generators')))),
           (4, ''))),
         (264,
          (285,
           (259,
            (1, 'def'),
            (1, 'f'),
            (260, (7, '('), (8, ')')),
            (11, ':'),
            (291,
             (4, ''),
             (5, ''),
             (264,
              (265,
               (266,
                (272,
                 (275,
                  (1, 'return'),
                  (313,
                   (292,
                    (293,
                     (294,
                      (295,
                       (297,
                        (298,
                         (299,
                          (300,
                           (301,
                            (302, (303, (304, (305, (2, '1')))))))))))))))))),
               (264,
                (265,
                 (266,
                  (272,
                   (276,
                    (1, 'yield'),
                    (313,
                     (292,
                      (293,
                       (294,
                        (295,
                         (297,
                          (298,
                           (299,
                            (300,
                             (301,
                              (302,
                               (303, (304, (305, (2, '1')))))))))))))))))),
                 (4, ''))),
               (6, ''))))),
           (4, ''),
           (0, ''))))
        self.check_bad_tree(tree, "def f():\n  return 1\n  yield 1")

def test_a_comma_comma_c(self):
        # Illegal input: a,,c
        tree = \
        (258,
         (311,
          (290,
           (291,
            (292,
             (293,
              (295,
               (296,
                (297,
                 (298, (299, (300, (301, (302, (303, (1, 'a')))))))))))))),
          (12, ','),
          (12, ','),
          (290,
           (291,
            (292,
             (293,
              (295,
               (296,
                (297,
                 (298, (299, (300, (301, (302, (303, (1, 'c'))))))))))))))),
         (4, ''),
         (0, ''))
        self.check_bad_tree(tree, "a,,c")

def test_illegal_operator(self):
        # Illegal input: a $= b
        tree = \
        (257,
         (264,
          (265,
           (266,
            (267,
             (312,
              (291,
               (292,
                (293,
                 (294,
                  (296,
                   (297,
                    (298,
                     (299,
                      (300, (301, (302, (303, (304, (1, 'a'))))))))))))))),
             (268, (37, '$=')),
             (312,
              (291,
               (292,
                (293,
                 (294,
                  (296,
                   (297,
                    (298,
                     (299,
                      (300, (301, (302, (303, (304, (1, 'b'))))))))))))))))),
           (4, ''))),
         (0, ''))
        self.check_bad_tree(tree, "a $= b")

def test_malformed_global(self):
        #doesn't have global keyword in ast
        tree = (257,
                (264,
                 (265,
                  (266,
                   (282, (1, 'foo'))), (4, ''))),
                (4, ''),
                (0, ''))
        self.check_bad_tree(tree, "malformed global ast")

def test_missing_import_source(self):
        # from import fred
        tree = \
            (257,
             (268,
              (269,
               (270,
                (282,
                 (284, (1, 'from'), (1, 'import'),
                  (287, (285, (1, 'fred')))))),
               (4, ''))),
             (4, ''), (0, ''))
        self.check_bad_tree(tree, "from import fred")

def test_illegal_encoding(self):
        # Illegal encoding declaration
        tree = \
            (341,
             (257, (0, '')))
        self.check_bad_tree(tree, "missed encoding")
        tree = \
            (341,
             (257, (0, '')),
              b'iso-8859-1')
        self.check_bad_tree(tree, "non-string encoding")
        tree = \
            (341,
             (257, (0, '')),
              '\udcff')
        with self.assertRaises(UnicodeEncodeError):
            parser.sequence2st(tree)

def test_invalid_node_id(self):
        tree = (257, (269, (-7, '')))
        self.check_bad_tree(tree, "negative node id")
        tree = (257, (269, (99, '')))
        self.check_bad_tree(tree, "invalid token id")
        tree = (257, (269, (9999, (0, ''))))
        self.check_bad_tree(tree, "invalid symbol id")

def test_ParserError_message(self):
        try:
            parser.sequence2st((257,(269,(257,(0,'')))))
        except parser.ParserError as why:
            self.assertIn("compound_stmt", str(why))  # Expected
            self.assertIn("file_input", str(why))     # Got

class CompileTestCase(unittest.TestCase):

# These tests are very minimal. :-(

def test_compile_expr(self):
        st = parser.expr('2 + 3')
        code = parser.compilest(st)
        self.assertEqual(eval(code), 5)

def test_compile_suite(self):
        st = parser.suite('x = 2; y = x + 3')
        code = parser.compilest(st)
        globs = {}
        exec(code, globs)
        self.assertEqual(globs['y'], 5)

def test_compile_error(self):
        st = parser.suite('1 = 3 + 4')
        self.assertRaises(SyntaxError, parser.compilest, st)

def test_compile_badunicode(self):
        st = parser.suite('a = "\\U12345678"')
        self.assertRaises(SyntaxError, parser.compilest, st)
        st = parser.suite('a = "\\u1"')
        self.assertRaises(SyntaxError, parser.compilest, st)

def test_issue_9011(self):
        # Issue 9011: compilation of an unary minus expression changed
        # the meaning of the ST, so that a second compilation produced
        # incorrect results.
        st = parser.expr('-3')
        code1 = parser.compilest(st)
        self.assertEqual(eval(code1), -3)
        code2 = parser.compilest(st)
        self.assertEqual(eval(code2), -3)

def test_compile_filename(self):
        st = parser.expr('a + 5')
        code = parser.compilest(st)
        self.assertEqual(code.co_filename, '<syntax-tree>')
        code = st.compile()
        self.assertEqual(code.co_filename, '<syntax-tree>')
        for filename in 'file.py', b'file.py':
            code = parser.compilest(st, filename)
            self.assertEqual(code.co_filename, 'file.py')
            code = st.compile(filename)
            self.assertEqual(code.co_filename, 'file.py')
        for filename in bytearray(b'file.py'), memoryview(b'file.py'):
            with self.assertWarns(DeprecationWarning):
                code = parser.compilest(st, filename)
            self.assertEqual(code.co_filename, 'file.py')
            with self.assertWarns(DeprecationWarning):
                code = st.compile(filename)
            self.assertEqual(code.co_filename, 'file.py')
        self.assertRaises(TypeError, parser.compilest, st, list(b'file.py'))
        self.assertRaises(TypeError, st.compile, list(b'file.py'))

class ParserStackLimitTestCase(unittest.TestCase):
    """try to push the parser to/over its limits.
    see http://bugs.python.org/issue1881 for a discussion
    """
    def _nested_expression(self, level):
        return "["*level+"]"*level

def test_deeply_nested_list(self):
        # This has fluctuated between 99 levels in 2.x, down to 93 levels in
        # 3.7.X and back up to 99 in 3.8.X. Related to MAXSTACK size in Parser.h
        e = self._nested_expression(99)
        st = parser.expr(e)
        st.compile()

def test_trigger_memory_error(self):
        e = self._nested_expression(100)
        rc, out, err = assert_python_failure('-c', e)
        # parsing the expression will result in an error message
        # followed by a MemoryError (see #11963)
        self.assertIn(b's_push: parser stack overflow', err)
        self.assertIn(b'MemoryError', err)

class STObjectTestCase(unittest.TestCase):
    """Test operations on ST objects themselves"""

def test_comparisons(self):
        # ST objects should support order and equality comparisons
        st1 = parser.expr('2 + 3')
        st2 = parser.suite('x = 2; y = x + 3')
        st3 = parser.expr('list(x**3 for x in range(20))')
        st1_copy = parser.expr('2 + 3')
        st2_copy = parser.suite('x = 2; y = x + 3')
        st3_copy = parser.expr('list(x**3 for x in range(20))')

# exercise fast path for object identity
        self.assertEqual(st1 == st1, True)
        self.assertEqual(st2 == st2, True)
        self.assertEqual(st3 == st3, True)
        # slow path equality
        self.assertEqual(st1, st1_copy)
        self.assertEqual(st2, st2_copy)
        self.assertEqual(st3, st3_copy)
        self.assertEqual(st1 == st2, False)
        self.assertEqual(st1 == st3, False)
        self.assertEqual(st2 == st3, False)
        self.assertEqual(st1 != st1, False)
        self.assertEqual(st2 != st2, False)
        self.assertEqual(st3 != st3, False)
        self.assertEqual(st1 != st1_copy, False)
        self.assertEqual(st2 != st2_copy, False)
        self.assertEqual(st3 != st3_copy, False)
        self.assertEqual(st2 != st1, True)
        self.assertEqual(st1 != st3, True)
        self.assertEqual(st3 != st2, True)
        # we don't particularly care what the ordering is;  just that
        # it's usable and self-consistent
        self.assertEqual(st1 < st2, not (st2 <= st1))
        self.assertEqual(st1 < st3, not (st3 <= st1))
        self.assertEqual(st2 < st3, not (st3 <= st2))
        self.assertEqual(st1 < st2, st2 > st1)
        self.assertEqual(st1 < st3, st3 > st1)
        self.assertEqual(st2 < st3, st3 > st2)
        self.assertEqual(st1 <= st2, st2 >= st1)
        self.assertEqual(st3 <= st1, st1 >= st3)
        self.assertEqual(st2 <= st3, st3 >= st2)
        # transitivity
        bottom = min(st1, st2, st3)
        top = max(st1, st2, st3)
        mid = sorted([st1, st2, st3])[1]
        self.assertTrue(bottom < mid)
        self.assertTrue(bottom < top)
        self.assertTrue(mid < top)
        self.assertTrue(bottom <= mid)
        self.assertTrue(bottom <= top)
        self.assertTrue(mid <= top)
        self.assertTrue(bottom <= bottom)
        self.assertTrue(mid <= mid)
        self.assertTrue(top <= top)
        # interaction with other types
        self.assertEqual(st1 == 1588.602459, False)
        self.assertEqual('spanish armada' != st2, True)
        self.assertRaises(TypeError, operator.ge, st3, None)
        self.assertRaises(TypeError, operator.le, False, st1)
        self.assertRaises(TypeError, operator.lt, st1, 1815)
        self.assertRaises(TypeError, operator.gt, b'waterloo', st2)

def test_copy_pickle(self):
        sts = [
            parser.expr('2 + 3'),
            parser.suite('x = 2; y = x + 3'),
            parser.expr('list(x**3 for x in range(20))')
        ]
        for st in sts:
            st_copy = copy.copy(st)
            self.assertEqual(st_copy.totuple(), st.totuple())
            st_copy = copy.deepcopy(st)
            self.assertEqual(st_copy.totuple(), st.totuple())
            for proto in range(pickle.HIGHEST_PROTOCOL+1):
                st_copy = pickle.loads(pickle.dumps(st, proto))
                self.assertEqual(st_copy.totuple(), st.totuple())

check_sizeof = support.check_sizeof

@support.cpython_only
    def test_sizeof(self):
        def XXXROUNDUP(n):
            if n <= 1:
                return n
            if n <= 128:
                return (n + 3) & ~3
            return 1 << (n - 1).bit_length()

basesize = support.calcobjsize('Piii')
        nodesize = struct.calcsize('hP3iP0h2i')
        def sizeofchildren(node):
            if node is None:
                return 0
            res = 0
            hasstr = len(node) > 1 and isinstance(node[-1], str)
            if hasstr:
                res += len(node[-1]) + 1
            children = node[1:-1] if hasstr else node[1:]
            if children:
                res += XXXROUNDUP(len(children)) * nodesize
                for child in children:
                    res += sizeofchildren(child)
            return res

def check_st_sizeof(st):
            self.check_sizeof(st, basesize + nodesize +
                                  sizeofchildren(st.totuple()))

check_st_sizeof(parser.expr('2 + 3'))
        check_st_sizeof(parser.expr('2 + 3 + 4'))
        check_st_sizeof(parser.suite('x = 2 + 3'))
        check_st_sizeof(parser.suite(''))
        check_st_sizeof(parser.suite('# -*- coding: utf-8 -*-'))
        check_st_sizeof(parser.expr('[' + '2,' * 1000 + ']'))

# XXX tests for pickling and unpickling of ST objects should go here

class OtherParserCase(unittest.TestCase):

def test_two_args_to_expr(self):
        # See bug #12264
        with self.assertRaises(TypeError):
            parser.expr("a", "b")

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

003 File Manager

Editing: test_parser.py

Upload File

Create Folder