003 File Manager
Current Path:
/usr/local/lib/python3.8/test
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_fstring.py
# -*- coding: utf-8 -*- # There are tests here with unicode string literals and # identifiers. There's a code in ast.c that was added because of a # failure with a non-ascii-only expression. So, I have tests for # that. There are workarounds that would let me run tests for that # code without unicode identifiers and strings, but just using them # directly seems like the easiest and therefore safest thing to do. # Unicode identifiers in tests is allowed by PEP 3131. import ast import types import decimal import unittest a_global = 'global variable' # You could argue that I'm too strict in looking for specific error # values with assertRaisesRegex, but without it it's way too easy to # make a syntax error in the test strings. Especially with all of the # triple quotes, raw strings, backslashes, etc. I think it's a # worthwhile tradeoff. When I switched to this method, I found many # examples where I wasn't testing what I thought I was. class TestCase(unittest.TestCase): def assertAllRaise(self, exception_type, regex, error_strings): for str in error_strings: with self.subTest(str=str): with self.assertRaisesRegex(exception_type, regex): eval(str) def test__format__lookup(self): # Make sure __format__ is looked up on the type, not the instance. class X: def __format__(self, spec): return 'class' x = X() # Add a bound __format__ method to the 'y' instance, but not # the 'x' instance. y = X() y.__format__ = types.MethodType(lambda self, spec: 'instance', y) self.assertEqual(f'{y}', format(y)) self.assertEqual(f'{y}', 'class') self.assertEqual(format(x), format(y)) # __format__ is not called this way, but still make sure it # returns what we expect (so we can make sure we're bypassing # it). self.assertEqual(x.__format__(''), 'class') self.assertEqual(y.__format__(''), 'instance') # This is how __format__ is actually called. self.assertEqual(type(x).__format__(x, ''), 'class') self.assertEqual(type(y).__format__(y, ''), 'class') def test_ast(self): # Inspired by http://bugs.python.org/issue24975 class X: def __init__(self): self.called = False def __call__(self): self.called = True return 4 x = X() expr = """ a = 10 f'{a * x()}'""" t = ast.parse(expr) c = compile(t, '', 'exec') # Make sure x was not called. self.assertFalse(x.called) # Actually run the code. exec(c) # Make sure x was called. self.assertTrue(x.called) def test_ast_line_numbers(self): expr = """ a = 10 f'{a * x()}'""" t = ast.parse(expr) self.assertEqual(type(t), ast.Module) self.assertEqual(len(t.body), 2) # check `a = 10` self.assertEqual(type(t.body[0]), ast.Assign) self.assertEqual(t.body[0].lineno, 2) # check `f'...'` self.assertEqual(type(t.body[1]), ast.Expr) self.assertEqual(type(t.body[1].value), ast.JoinedStr) self.assertEqual(len(t.body[1].value.values), 1) self.assertEqual(type(t.body[1].value.values[0]), ast.FormattedValue) self.assertEqual(t.body[1].lineno, 3) self.assertEqual(t.body[1].value.lineno, 3) self.assertEqual(t.body[1].value.values[0].lineno, 3) # check the binop location binop = t.body[1].value.values[0].value self.assertEqual(type(binop), ast.BinOp) self.assertEqual(type(binop.left), ast.Name) self.assertEqual(type(binop.op), ast.Mult) self.assertEqual(type(binop.right), ast.Call) self.assertEqual(binop.lineno, 3) self.assertEqual(binop.left.lineno, 3) self.assertEqual(binop.right.lineno, 3) self.assertEqual(binop.col_offset, 3) self.assertEqual(binop.left.col_offset, 3) self.assertEqual(binop.right.col_offset, 7) def test_ast_line_numbers_multiple_formattedvalues(self): expr = """ f'no formatted values' f'eggs {a * x()} spam {b + y()}'""" t = ast.parse(expr) self.assertEqual(type(t), ast.Module) self.assertEqual(len(t.body), 2) # check `f'no formatted value'` self.assertEqual(type(t.body[0]), ast.Expr) self.assertEqual(type(t.body[0].value), ast.JoinedStr) self.assertEqual(t.body[0].lineno, 2) # check `f'...'` self.assertEqual(type(t.body[1]), ast.Expr) self.assertEqual(type(t.body[1].value), ast.JoinedStr) self.assertEqual(len(t.body[1].value.values), 4) self.assertEqual(type(t.body[1].value.values[0]), ast.Constant) self.assertEqual(type(t.body[1].value.values[0].value), str) self.assertEqual(type(t.body[1].value.values[1]), ast.FormattedValue) self.assertEqual(type(t.body[1].value.values[2]), ast.Constant) self.assertEqual(type(t.body[1].value.values[2].value), str) self.assertEqual(type(t.body[1].value.values[3]), ast.FormattedValue) self.assertEqual(t.body[1].lineno, 3) self.assertEqual(t.body[1].value.lineno, 3) self.assertEqual(t.body[1].value.values[0].lineno, 3) self.assertEqual(t.body[1].value.values[1].lineno, 3) self.assertEqual(t.body[1].value.values[2].lineno, 3) self.assertEqual(t.body[1].value.values[3].lineno, 3) # check the first binop location binop1 = t.body[1].value.values[1].value self.assertEqual(type(binop1), ast.BinOp) self.assertEqual(type(binop1.left), ast.Name) self.assertEqual(type(binop1.op), ast.Mult) self.assertEqual(type(binop1.right), ast.Call) self.assertEqual(binop1.lineno, 3) self.assertEqual(binop1.left.lineno, 3) self.assertEqual(binop1.right.lineno, 3) self.assertEqual(binop1.col_offset, 8) self.assertEqual(binop1.left.col_offset, 8) self.assertEqual(binop1.right.col_offset, 12) # check the second binop location binop2 = t.body[1].value.values[3].value self.assertEqual(type(binop2), ast.BinOp) self.assertEqual(type(binop2.left), ast.Name) self.assertEqual(type(binop2.op), ast.Add) self.assertEqual(type(binop2.right), ast.Call) self.assertEqual(binop2.lineno, 3) self.assertEqual(binop2.left.lineno, 3) self.assertEqual(binop2.right.lineno, 3) self.assertEqual(binop2.col_offset, 23) self.assertEqual(binop2.left.col_offset, 23) self.assertEqual(binop2.right.col_offset, 27) def test_ast_line_numbers_nested(self): expr = """ a = 10 f'{a * f"-{x()}-"}'""" t = ast.parse(expr) self.assertEqual(type(t), ast.Module) self.assertEqual(len(t.body), 2) # check `a = 10` self.assertEqual(type(t.body[0]), ast.Assign) self.assertEqual(t.body[0].lineno, 2) # check `f'...'` self.assertEqual(type(t.body[1]), ast.Expr) self.assertEqual(type(t.body[1].value), ast.JoinedStr) self.assertEqual(len(t.body[1].value.values), 1) self.assertEqual(type(t.body[1].value.values[0]), ast.FormattedValue) self.assertEqual(t.body[1].lineno, 3) self.assertEqual(t.body[1].value.lineno, 3) self.assertEqual(t.body[1].value.values[0].lineno, 3) # check the binop location binop = t.body[1].value.values[0].value self.assertEqual(type(binop), ast.BinOp) self.assertEqual(type(binop.left), ast.Name) self.assertEqual(type(binop.op), ast.Mult) self.assertEqual(type(binop.right), ast.JoinedStr) self.assertEqual(binop.lineno, 3) self.assertEqual(binop.left.lineno, 3) self.assertEqual(binop.right.lineno, 3) self.assertEqual(binop.col_offset, 3) self.assertEqual(binop.left.col_offset, 3) self.assertEqual(binop.right.col_offset, 7) # check the nested call location self.assertEqual(len(binop.right.values), 3) self.assertEqual(type(binop.right.values[0]), ast.Constant) self.assertEqual(type(binop.right.values[0].value), str) self.assertEqual(type(binop.right.values[1]), ast.FormattedValue) self.assertEqual(type(binop.right.values[2]), ast.Constant) self.assertEqual(type(binop.right.values[2].value), str) self.assertEqual(binop.right.values[0].lineno, 3) self.assertEqual(binop.right.values[1].lineno, 3) self.assertEqual(binop.right.values[2].lineno, 3) call = binop.right.values[1].value self.assertEqual(type(call), ast.Call) self.assertEqual(call.lineno, 3) self.assertEqual(call.col_offset, 11) def test_ast_line_numbers_duplicate_expression(self): """Duplicate expression NOTE: this is currently broken, always sets location of the first expression. """ expr = """ a = 10 f'{a * x()} {a * x()} {a * x()}' """ t = ast.parse(expr) self.assertEqual(type(t), ast.Module) self.assertEqual(len(t.body), 2) # check `a = 10` self.assertEqual(type(t.body[0]), ast.Assign) self.assertEqual(t.body[0].lineno, 2) # check `f'...'` self.assertEqual(type(t.body[1]), ast.Expr) self.assertEqual(type(t.body[1].value), ast.JoinedStr) self.assertEqual(len(t.body[1].value.values), 5) self.assertEqual(type(t.body[1].value.values[0]), ast.FormattedValue) self.assertEqual(type(t.body[1].value.values[1]), ast.Constant) self.assertEqual(type(t.body[1].value.values[1].value), str) self.assertEqual(type(t.body[1].value.values[2]), ast.FormattedValue) self.assertEqual(type(t.body[1].value.values[3]), ast.Constant) self.assertEqual(type(t.body[1].value.values[3].value), str) self.assertEqual(type(t.body[1].value.values[4]), ast.FormattedValue) self.assertEqual(t.body[1].lineno, 3) self.assertEqual(t.body[1].value.lineno, 3) self.assertEqual(t.body[1].value.values[0].lineno, 3) self.assertEqual(t.body[1].value.values[1].lineno, 3) self.assertEqual(t.body[1].value.values[2].lineno, 3) self.assertEqual(t.body[1].value.values[3].lineno, 3) self.assertEqual(t.body[1].value.values[4].lineno, 3) # check the first binop location binop = t.body[1].value.values[0].value self.assertEqual(type(binop), ast.BinOp) self.assertEqual(type(binop.left), ast.Name) self.assertEqual(type(binop.op), ast.Mult) self.assertEqual(type(binop.right), ast.Call) self.assertEqual(binop.lineno, 3) self.assertEqual(binop.left.lineno, 3) self.assertEqual(binop.right.lineno, 3) self.assertEqual(binop.col_offset, 3) self.assertEqual(binop.left.col_offset, 3) self.assertEqual(binop.right.col_offset, 7) # check the second binop location binop = t.body[1].value.values[2].value self.assertEqual(type(binop), ast.BinOp) self.assertEqual(type(binop.left), ast.Name) self.assertEqual(type(binop.op), ast.Mult) self.assertEqual(type(binop.right), ast.Call) self.assertEqual(binop.lineno, 3) self.assertEqual(binop.left.lineno, 3) self.assertEqual(binop.right.lineno, 3) self.assertEqual(binop.col_offset, 3) # FIXME: this is wrong self.assertEqual(binop.left.col_offset, 3) # FIXME: this is wrong self.assertEqual(binop.right.col_offset, 7) # FIXME: this is wrong # check the third binop location binop = t.body[1].value.values[4].value self.assertEqual(type(binop), ast.BinOp) self.assertEqual(type(binop.left), ast.Name) self.assertEqual(type(binop.op), ast.Mult) self.assertEqual(type(binop.right), ast.Call) self.assertEqual(binop.lineno, 3) self.assertEqual(binop.left.lineno, 3) self.assertEqual(binop.right.lineno, 3) self.assertEqual(binop.col_offset, 3) # FIXME: this is wrong self.assertEqual(binop.left.col_offset, 3) # FIXME: this is wrong self.assertEqual(binop.right.col_offset, 7) # FIXME: this is wrong def test_ast_line_numbers_multiline_fstring(self): # See bpo-30465 for details. expr = """ a = 10 f''' {a * x()} non-important content ''' """ t = ast.parse(expr) self.assertEqual(type(t), ast.Module) self.assertEqual(len(t.body), 2) # check `a = 10` self.assertEqual(type(t.body[0]), ast.Assign) self.assertEqual(t.body[0].lineno, 2) # check `f'...'` self.assertEqual(type(t.body[1]), ast.Expr) self.assertEqual(type(t.body[1].value), ast.JoinedStr) self.assertEqual(len(t.body[1].value.values), 3) self.assertEqual(type(t.body[1].value.values[0]), ast.Constant) self.assertEqual(type(t.body[1].value.values[0].value), str) self.assertEqual(type(t.body[1].value.values[1]), ast.FormattedValue) self.assertEqual(type(t.body[1].value.values[2]), ast.Constant) self.assertEqual(type(t.body[1].value.values[2].value), str) self.assertEqual(t.body[1].lineno, 3) self.assertEqual(t.body[1].value.lineno, 3) self.assertEqual(t.body[1].value.values[0].lineno, 3) self.assertEqual(t.body[1].value.values[1].lineno, 3) self.assertEqual(t.body[1].value.values[2].lineno, 3) self.assertEqual(t.body[1].col_offset, 0) self.assertEqual(t.body[1].value.col_offset, 0) self.assertEqual(t.body[1].value.values[0].col_offset, 0) self.assertEqual(t.body[1].value.values[1].col_offset, 0) self.assertEqual(t.body[1].value.values[2].col_offset, 0) # NOTE: the following lineno information and col_offset is correct for # expressions within FormattedValues. binop = t.body[1].value.values[1].value self.assertEqual(type(binop), ast.BinOp) self.assertEqual(type(binop.left), ast.Name) self.assertEqual(type(binop.op), ast.Mult) self.assertEqual(type(binop.right), ast.Call) self.assertEqual(binop.lineno, 4) self.assertEqual(binop.left.lineno, 4) self.assertEqual(binop.right.lineno, 6) self.assertEqual(binop.col_offset, 4) self.assertEqual(binop.left.col_offset, 4) self.assertEqual(binop.right.col_offset, 7) def test_docstring(self): def f(): f'''Not a docstring''' self.assertIsNone(f.__doc__) def g(): '''Not a docstring''' \ f'' self.assertIsNone(g.__doc__) def test_literal_eval(self): with self.assertRaisesRegex(ValueError, 'malformed node or string'): ast.literal_eval("f'x'") def test_ast_compile_time_concat(self): x = [''] expr = """x[0] = 'foo' f'{3}'""" t = ast.parse(expr) c = compile(t, '', 'exec') exec(c) self.assertEqual(x[0], 'foo3') def test_compile_time_concat_errors(self): self.assertAllRaise(SyntaxError, 'cannot mix bytes and nonbytes literals', [r"""f'' b''""", r"""b'' f''""", ]) def test_literal(self): self.assertEqual(f'', '') self.assertEqual(f'a', 'a') self.assertEqual(f' ', ' ') def test_unterminated_string(self): self.assertAllRaise(SyntaxError, 'f-string: unterminated string', [r"""f'{"x'""", r"""f'{"x}'""", r"""f'{("x'""", r"""f'{("x}'""", ]) def test_mismatched_parens(self): self.assertAllRaise(SyntaxError, r"f-string: closing parenthesis '\}' " r"does not match opening parenthesis '\('", ["f'{((}'", ]) self.assertAllRaise(SyntaxError, r"f-string: closing parenthesis '\)' " r"does not match opening parenthesis '\['", ["f'{a[4)}'", ]) self.assertAllRaise(SyntaxError, r"f-string: closing parenthesis '\]' " r"does not match opening parenthesis '\('", ["f'{a(4]}'", ]) self.assertAllRaise(SyntaxError, r"f-string: closing parenthesis '\}' " r"does not match opening parenthesis '\['", ["f'{a[4}'", ]) self.assertAllRaise(SyntaxError, r"f-string: closing parenthesis '\}' " r"does not match opening parenthesis '\('", ["f'{a(4}'", ]) self.assertRaises(SyntaxError, eval, "f'{" + "("*500 + "}'") def test_double_braces(self): self.assertEqual(f'{{', '{') self.assertEqual(f'a{{', 'a{') self.assertEqual(f'{{b', '{b') self.assertEqual(f'a{{b', 'a{b') self.assertEqual(f'}}', '}') self.assertEqual(f'a}}', 'a}') self.assertEqual(f'}}b', '}b') self.assertEqual(f'a}}b', 'a}b') self.assertEqual(f'{{}}', '{}') self.assertEqual(f'a{{}}', 'a{}') self.assertEqual(f'{{b}}', '{b}') self.assertEqual(f'{{}}c', '{}c') self.assertEqual(f'a{{b}}', 'a{b}') self.assertEqual(f'a{{}}c', 'a{}c') self.assertEqual(f'{{b}}c', '{b}c') self.assertEqual(f'a{{b}}c', 'a{b}c') self.assertEqual(f'{{{10}', '{10') self.assertEqual(f'}}{10}', '}10') self.assertEqual(f'}}{{{10}', '}{10') self.assertEqual(f'}}a{{{10}', '}a{10') self.assertEqual(f'{10}{{', '10{') self.assertEqual(f'{10}}}', '10}') self.assertEqual(f'{10}}}{{', '10}{') self.assertEqual(f'{10}}}a{{' '}', '10}a{}') # Inside of strings, don't interpret doubled brackets. self.assertEqual(f'{"{{}}"}', '{{}}') self.assertAllRaise(TypeError, 'unhashable type', ["f'{ {{}} }'", # dict in a set ]) def test_compile_time_concat(self): x = 'def' self.assertEqual('abc' f'## {x}ghi', 'abc## defghi') self.assertEqual('abc' f'{x}' 'ghi', 'abcdefghi') self.assertEqual('abc' f'{x}' 'gh' f'i{x:4}', 'abcdefghidef ') self.assertEqual('{x}' f'{x}', '{x}def') self.assertEqual('{x' f'{x}', '{xdef') self.assertEqual('{x}' f'{x}', '{x}def') self.assertEqual('{{x}}' f'{x}', '{{x}}def') self.assertEqual('{{x' f'{x}', '{{xdef') self.assertEqual('x}}' f'{x}', 'x}}def') self.assertEqual(f'{x}' 'x}}', 'defx}}') self.assertEqual(f'{x}' '', 'def') self.assertEqual('' f'{x}' '', 'def') self.assertEqual('' f'{x}', 'def') self.assertEqual(f'{x}' '2', 'def2') self.assertEqual('1' f'{x}' '2', '1def2') self.assertEqual('1' f'{x}', '1def') self.assertEqual(f'{x}' f'-{x}', 'def-def') self.assertEqual('' f'', '') self.assertEqual('' f'' '', '') self.assertEqual('' f'' '' f'', '') self.assertEqual(f'', '') self.assertEqual(f'' '', '') self.assertEqual(f'' '' f'', '') self.assertEqual(f'' '' f'' '', '') self.assertAllRaise(SyntaxError, "f-string: expecting '}'", ["f'{3' f'}'", # can't concat to get a valid f-string ]) def test_comments(self): # These aren't comments, since they're in strings. d = {'#': 'hash'} self.assertEqual(f'{"#"}', '#') self.assertEqual(f'{d["#"]}', 'hash') self.assertAllRaise(SyntaxError, "f-string expression part cannot include '#'", ["f'{1#}'", # error because the expression becomes "(1#)" "f'{3(#)}'", "f'{#}'", ]) self.assertAllRaise(SyntaxError, r"f-string: unmatched '\)'", ["f'{)#}'", # When wrapped in parens, this becomes # '()#)'. Make sure that doesn't compile. ]) def test_many_expressions(self): # Create a string with many expressions in it. Note that # because we have a space in here as a literal, we're actually # going to use twice as many ast nodes: one for each literal # plus one for each expression. def build_fstr(n, extra=''): return "f'" + ('{x} ' * n) + extra + "'" x = 'X' width = 1 # Test around 256. for i in range(250, 260): self.assertEqual(eval(build_fstr(i)), (x+' ')*i) # Test concatenating 2 largs fstrings. self.assertEqual(eval(build_fstr(255)*256), (x+' ')*(255*256)) s = build_fstr(253, '{x:{width}} ') self.assertEqual(eval(s), (x+' ')*254) # Test lots of expressions and constants, concatenated. s = "f'{1}' 'x' 'y'" * 1024 self.assertEqual(eval(s), '1xy' * 1024) def test_format_specifier_expressions(self): width = 10 precision = 4 value = decimal.Decimal('12.34567') self.assertEqual(f'result: {value:{width}.{precision}}', 'result: 12.35') self.assertEqual(f'result: {value:{width!r}.{precision}}', 'result: 12.35') self.assertEqual(f'result: {value:{width:0}.{precision:1}}', 'result: 12.35') self.assertEqual(f'result: {value:{1}{0:0}.{precision:1}}', 'result: 12.35') self.assertEqual(f'result: {value:{ 1}{ 0:0}.{ precision:1}}', 'result: 12.35') self.assertEqual(f'{10:#{1}0x}', ' 0xa') self.assertEqual(f'{10:{"#"}1{0}{"x"}}', ' 0xa') self.assertEqual(f'{-10:-{"#"}1{0}x}', ' -0xa') self.assertEqual(f'{-10:{"-"}#{1}0{"x"}}', ' -0xa') self.assertEqual(f'{10:#{3 != {4:5} and width}x}', ' 0xa') self.assertAllRaise(SyntaxError, "f-string: expecting '}'", ["""f'{"s"!r{":10"}}'""", # This looks like a nested format spec. ]) self.assertAllRaise(SyntaxError, "invalid syntax", [# Invalid syntax inside a nested spec. "f'{4:{/5}}'", ]) self.assertAllRaise(SyntaxError, "f-string: expressions nested too deeply", [# Can't nest format specifiers. "f'result: {value:{width:{0}}.{precision:1}}'", ]) self.assertAllRaise(SyntaxError, 'f-string: invalid conversion character', [# No expansion inside conversion or for # the : or ! itself. """f'{"s"!{"r"}}'""", ]) def test_side_effect_order(self): class X: def __init__(self): self.i = 0 def __format__(self, spec): self.i += 1 return str(self.i) x = X() self.assertEqual(f'{x} {x}', '1 2') def test_missing_expression(self): self.assertAllRaise(SyntaxError, 'f-string: empty expression not allowed', ["f'{}'", "f'{ }'" "f' {} '", "f'{!r}'", "f'{ !r}'", "f'{10:{ }}'", "f' { } '", # The Python parser ignores also the following # whitespace characters in additional to a space. "f'''{\t\f\r\n}'''", # Catch the empty expression before the # invalid conversion. "f'{!x}'", "f'{ !xr}'", "f'{!x:}'", "f'{!x:a}'", "f'{ !xr:}'", "f'{ !xr:a}'", "f'{!}'", "f'{:}'", # We find the empty expression before the # missing closing brace. "f'{!'", "f'{!s:'", "f'{:'", "f'{:x'", ]) # Different error message is raised for other whitespace characters. self.assertAllRaise(SyntaxError, 'invalid character in identifier', ["f'''{\xa0}'''", "\xa0", ]) def test_parens_in_expressions(self): self.assertEqual(f'{3,}', '(3,)') # Add these because when an expression is evaluated, parens # are added around it. But we shouldn't go from an invalid # expression to a valid one. The added parens are just # supposed to allow whitespace (including newlines). self.assertAllRaise(SyntaxError, 'invalid syntax', ["f'{,}'", "f'{,}'", # this is (,), which is an error ]) self.assertAllRaise(SyntaxError, r"f-string: unmatched '\)'", ["f'{3)+(4}'", ]) self.assertAllRaise(SyntaxError, 'EOL while scanning string literal', ["f'{\n}'", ]) def test_backslashes_in_string_part(self): self.assertEqual(f'\t', '\t') self.assertEqual(r'\t', '\\t') self.assertEqual(rf'\t', '\\t') self.assertEqual(f'{2}\t', '2\t') self.assertEqual(f'{2}\t{3}', '2\t3') self.assertEqual(f'\t{3}', '\t3') self.assertEqual(f'\u0394', '\u0394') self.assertEqual(r'\u0394', '\\u0394') self.assertEqual(rf'\u0394', '\\u0394') self.assertEqual(f'{2}\u0394', '2\u0394') self.assertEqual(f'{2}\u0394{3}', '2\u03943') self.assertEqual(f'\u0394{3}', '\u03943') self.assertEqual(f'\U00000394', '\u0394') self.assertEqual(r'\U00000394', '\\U00000394') self.assertEqual(rf'\U00000394', '\\U00000394') self.assertEqual(f'{2}\U00000394', '2\u0394') self.assertEqual(f'{2}\U00000394{3}', '2\u03943') self.assertEqual(f'\U00000394{3}', '\u03943') self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}', '\u0394') self.assertEqual(f'{2}\N{GREEK CAPITAL LETTER DELTA}', '2\u0394') self.assertEqual(f'{2}\N{GREEK CAPITAL LETTER DELTA}{3}', '2\u03943') self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}{3}', '\u03943') self.assertEqual(f'2\N{GREEK CAPITAL LETTER DELTA}', '2\u0394') self.assertEqual(f'2\N{GREEK CAPITAL LETTER DELTA}3', '2\u03943') self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}3', '\u03943') self.assertEqual(f'\x20', ' ') self.assertEqual(r'\x20', '\\x20') self.assertEqual(rf'\x20', '\\x20') self.assertEqual(f'{2}\x20', '2 ') self.assertEqual(f'{2}\x20{3}', '2 3') self.assertEqual(f'\x20{3}', ' 3') self.assertEqual(f'2\x20', '2 ') self.assertEqual(f'2\x203', '2 3') self.assertEqual(f'\x203', ' 3') with self.assertWarns(DeprecationWarning): # invalid escape sequence value = eval(r"f'\{6*7}'") self.assertEqual(value, '\\42') self.assertEqual(f'\\{6*7}', '\\42') self.assertEqual(fr'\{6*7}', '\\42') AMPERSAND = 'spam' # Get the right unicode character (&), or pick up local variable # depending on the number of backslashes. self.assertEqual(f'\N{AMPERSAND}', '&') self.assertEqual(f'\\N{AMPERSAND}', '\\Nspam') self.assertEqual(fr'\N{AMPERSAND}', '\\Nspam') self.assertEqual(f'\\\N{AMPERSAND}', '\\&') def test_misformed_unicode_character_name(self): # These test are needed because unicode names are parsed # differently inside f-strings. self.assertAllRaise(SyntaxError, r"\(unicode error\) 'unicodeescape' codec can't decode bytes in position .*: malformed \\N character escape", [r"f'\N'", r"f'\N{'", r"f'\N{GREEK CAPITAL LETTER DELTA'", # Here are the non-f-string versions, # which should give the same errors. r"'\N'", r"'\N{'", r"'\N{GREEK CAPITAL LETTER DELTA'", ]) def test_no_backslashes_in_expression_part(self): self.assertAllRaise(SyntaxError, 'f-string expression part cannot include a backslash', [r"f'{\'a\'}'", r"f'{\t3}'", r"f'{\}'", r"rf'{\'a\'}'", r"rf'{\t3}'", r"rf'{\}'", r"""rf'{"\N{LEFT CURLY BRACKET}"}'""", r"f'{\n}'", ]) def test_no_escapes_for_braces(self): """ Only literal curly braces begin an expression. """ # \x7b is '{'. self.assertEqual(f'\x7b1+1}}', '{1+1}') self.assertEqual(f'\x7b1+1', '{1+1') self.assertEqual(f'\u007b1+1', '{1+1') self.assertEqual(f'\N{LEFT CURLY BRACKET}1+1\N{RIGHT CURLY BRACKET}', '{1+1}') def test_newlines_in_expressions(self): self.assertEqual(f'{0}', '0') self.assertEqual(rf'''{3+ 4}''', '7') def test_lambda(self): x = 5 self.assertEqual(f'{(lambda y:x*y)("8")!r}', "'88888'") self.assertEqual(f'{(lambda y:x*y)("8")!r:10}', "'88888' ") self.assertEqual(f'{(lambda y:x*y)("8"):10}', "88888 ") # lambda doesn't work without parens, because the colon # makes the parser think it's a format_spec self.assertAllRaise(SyntaxError, 'unexpected EOF while parsing', ["f'{lambda x:x}'", ]) def test_yield(self): # Not terribly useful, but make sure the yield turns # a function into a generator def fn(y): f'y:{yield y*2}' g = fn(4) self.assertEqual(next(g), 8) def test_yield_send(self): def fn(x): yield f'x:{yield (lambda i: x * i)}' g = fn(10) the_lambda = next(g) self.assertEqual(the_lambda(4), 40) self.assertEqual(g.send('string'), 'x:string') def test_expressions_with_triple_quoted_strings(self): self.assertEqual(f"{'''x'''}", 'x') self.assertEqual(f"{'''eric's'''}", "eric's") # Test concatenation within an expression self.assertEqual(f'{"x" """eric"s""" "y"}', 'xeric"sy') self.assertEqual(f'{"x" """eric"s"""}', 'xeric"s') self.assertEqual(f'{"""eric"s""" "y"}', 'eric"sy') self.assertEqual(f'{"""x""" """eric"s""" "y"}', 'xeric"sy') self.assertEqual(f'{"""x""" """eric"s""" """y"""}', 'xeric"sy') self.assertEqual(f'{r"""x""" """eric"s""" """y"""}', 'xeric"sy') def test_multiple_vars(self): x = 98 y = 'abc' self.assertEqual(f'{x}{y}', '98abc') self.assertEqual(f'X{x}{y}', 'X98abc') self.assertEqual(f'{x}X{y}', '98Xabc') self.assertEqual(f'{x}{y}X', '98abcX') self.assertEqual(f'X{x}Y{y}', 'X98Yabc') self.assertEqual(f'X{x}{y}Y', 'X98abcY') self.assertEqual(f'{x}X{y}Y', '98XabcY') self.assertEqual(f'X{x}Y{y}Z', 'X98YabcZ') def test_closure(self): def outer(x): def inner(): return f'x:{x}' return inner self.assertEqual(outer('987')(), 'x:987') self.assertEqual(outer(7)(), 'x:7') def test_arguments(self): y = 2 def f(x, width): return f'x={x*y:{width}}' self.assertEqual(f('foo', 10), 'x=foofoo ') x = 'bar' self.assertEqual(f(10, 10), 'x= 20') def test_locals(self): value = 123 self.assertEqual(f'v:{value}', 'v:123') def test_missing_variable(self): with self.assertRaises(NameError): f'v:{value}' def test_missing_format_spec(self): class O: def __format__(self, spec): if not spec: return '*' return spec self.assertEqual(f'{O():x}', 'x') self.assertEqual(f'{O()}', '*') self.assertEqual(f'{O():}', '*') self.assertEqual(f'{3:}', '3') self.assertEqual(f'{3!s:}', '3') def test_global(self): self.assertEqual(f'g:{a_global}', 'g:global variable') self.assertEqual(f'g:{a_global!r}', "g:'global variable'") a_local = 'local variable' self.assertEqual(f'g:{a_global} l:{a_local}', 'g:global variable l:local variable') self.assertEqual(f'g:{a_global!r}', "g:'global variable'") self.assertEqual(f'g:{a_global} l:{a_local!r}', "g:global variable l:'local variable'") self.assertIn("module 'unittest' from", f'{unittest}') def test_shadowed_global(self): a_global = 'really a local' self.assertEqual(f'g:{a_global}', 'g:really a local') self.assertEqual(f'g:{a_global!r}', "g:'really a local'") a_local = 'local variable' self.assertEqual(f'g:{a_global} l:{a_local}', 'g:really a local l:local variable') self.assertEqual(f'g:{a_global!r}', "g:'really a local'") self.assertEqual(f'g:{a_global} l:{a_local!r}', "g:really a local l:'local variable'") def test_call(self): def foo(x): return 'x=' + str(x) self.assertEqual(f'{foo(10)}', 'x=10') def test_nested_fstrings(self): y = 5 self.assertEqual(f'{f"{0}"*3}', '000') self.assertEqual(f'{f"{y}"*3}', '555') def test_invalid_string_prefixes(self): self.assertAllRaise(SyntaxError, 'unexpected EOF while parsing', ["fu''", "uf''", "Fu''", "fU''", "Uf''", "uF''", "ufr''", "urf''", "fur''", "fru''", "rfu''", "ruf''", "FUR''", "Fur''", "fb''", "fB''", "Fb''", "FB''", "bf''", "bF''", "Bf''", "BF''", ]) def test_leading_trailing_spaces(self): self.assertEqual(f'{ 3}', '3') self.assertEqual(f'{ 3}', '3') self.assertEqual(f'{3 }', '3') self.assertEqual(f'{3 }', '3') self.assertEqual(f'expr={ {x: y for x, y in [(1, 2), ]}}', 'expr={1: 2}') self.assertEqual(f'expr={ {x: y for x, y in [(1, 2), ]} }', 'expr={1: 2}') def test_not_equal(self): # There's a special test for this because there's a special # case in the f-string parser to look for != as not ending an # expression. Normally it would, while looking for !s or !r. self.assertEqual(f'{3!=4}', 'True') self.assertEqual(f'{3!=4:}', 'True') self.assertEqual(f'{3!=4!s}', 'True') self.assertEqual(f'{3!=4!s:.3}', 'Tru') def test_equal_equal(self): # Because an expression ending in = has special meaning, # there's a special test for ==. Make sure it works. self.assertEqual(f'{0==1}', 'False') def test_conversions(self): self.assertEqual(f'{3.14:10.10}', ' 3.14') self.assertEqual(f'{3.14!s:10.10}', '3.14 ') self.assertEqual(f'{3.14!r:10.10}', '3.14 ') self.assertEqual(f'{3.14!a:10.10}', '3.14 ') self.assertEqual(f'{"a"}', 'a') self.assertEqual(f'{"a"!r}', "'a'") self.assertEqual(f'{"a"!a}', "'a'") # Not a conversion. self.assertEqual(f'{"a!r"}', "a!r") # Not a conversion, but show that ! is allowed in a format spec. self.assertEqual(f'{3.14:!<10.10}', '3.14!!!!!!') self.assertAllRaise(SyntaxError, 'f-string: invalid conversion character', ["f'{3!g}'", "f'{3!A}'", "f'{3!3}'", "f'{3!G}'", "f'{3!!}'", "f'{3!:}'", "f'{3! s}'", # no space before conversion char ]) self.assertAllRaise(SyntaxError, "f-string: expecting '}'", ["f'{x!s{y}}'", "f'{3!ss}'", "f'{3!ss:}'", "f'{3!ss:s}'", ]) def test_assignment(self): self.assertAllRaise(SyntaxError, 'invalid syntax', ["f'' = 3", "f'{0}' = x", "f'{x}' = x", ]) def test_del(self): self.assertAllRaise(SyntaxError, 'invalid syntax', ["del f''", "del '' f''", ]) def test_mismatched_braces(self): self.assertAllRaise(SyntaxError, "f-string: single '}' is not allowed", ["f'{{}'", "f'{{}}}'", "f'}'", "f'x}'", "f'x}x'", r"f'\u007b}'", # Can't have { or } in a format spec. "f'{3:}>10}'", "f'{3:}}>10}'", ]) self.assertAllRaise(SyntaxError, "f-string: expecting '}'", ["f'{3:{{>10}'", "f'{3'", "f'{3!'", "f'{3:'", "f'{3!s'", "f'{3!s:'", "f'{3!s:3'", "f'x{'", "f'x{x'", "f'{x'", "f'{3:s'", "f'{{{'", "f'{{}}{'", "f'{'", ]) # But these are just normal strings. self.assertEqual(f'{"{"}', '{') self.assertEqual(f'{"}"}', '}') self.assertEqual(f'{3:{"}"}>10}', '}}}}}}}}}3') self.assertEqual(f'{2:{"{"}>10}', '{{{{{{{{{2') def test_if_conditional(self): # There's special logic in compile.c to test if the # conditional for an if (and while) are constants. Exercise # that code. def test_fstring(x, expected): flag = 0 if f'{x}': flag = 1 else: flag = 2 self.assertEqual(flag, expected) def test_concat_empty(x, expected): flag = 0 if '' f'{x}': flag = 1 else: flag = 2 self.assertEqual(flag, expected) def test_concat_non_empty(x, expected): flag = 0 if ' ' f'{x}': flag = 1 else: flag = 2 self.assertEqual(flag, expected) test_fstring('', 2) test_fstring(' ', 1) test_concat_empty('', 2) test_concat_empty(' ', 1) test_concat_non_empty('', 1) test_concat_non_empty(' ', 1) def test_empty_format_specifier(self): x = 'test' self.assertEqual(f'{x}', 'test') self.assertEqual(f'{x:}', 'test') self.assertEqual(f'{x!s:}', 'test') self.assertEqual(f'{x!r:}', "'test'") def test_str_format_differences(self): d = {'a': 'string', 0: 'integer', } a = 0 self.assertEqual(f'{d[0]}', 'integer') self.assertEqual(f'{d["a"]}', 'string') self.assertEqual(f'{d[a]}', 'integer') self.assertEqual('{d[a]}'.format(d=d), 'string') self.assertEqual('{d[0]}'.format(d=d), 'integer') def test_errors(self): # see issue 26287 self.assertAllRaise(TypeError, 'unsupported', [r"f'{(lambda: 0):x}'", r"f'{(0,):x}'", ]) self.assertAllRaise(ValueError, 'Unknown format code', [r"f'{1000:j}'", r"f'{1000:j}'", ]) def test_loop(self): for i in range(1000): self.assertEqual(f'i:{i}', 'i:' + str(i)) def test_dict(self): d = {'"': 'dquote', "'": 'squote', 'foo': 'bar', } self.assertEqual(f'''{d["'"]}''', 'squote') self.assertEqual(f"""{d['"']}""", 'dquote') self.assertEqual(f'{d["foo"]}', 'bar') self.assertEqual(f"{d['foo']}", 'bar') def test_backslash_char(self): # Check eval of a backslash followed by a control char. # See bpo-30682: this used to raise an assert in pydebug mode. self.assertEqual(eval('f"\\\n"'), '') self.assertEqual(eval('f"\\\r"'), '') def test_debug_conversion(self): x = 'A string' self.assertEqual(f'{x=}', 'x=' + repr(x)) self.assertEqual(f'{x =}', 'x =' + repr(x)) self.assertEqual(f'{x=!s}', 'x=' + str(x)) self.assertEqual(f'{x=!r}', 'x=' + repr(x)) self.assertEqual(f'{x=!a}', 'x=' + ascii(x)) x = 2.71828 self.assertEqual(f'{x=:.2f}', 'x=' + format(x, '.2f')) self.assertEqual(f'{x=:}', 'x=' + format(x, '')) self.assertEqual(f'{x=!r:^20}', 'x=' + format(repr(x), '^20')) self.assertEqual(f'{x=!s:^20}', 'x=' + format(str(x), '^20')) self.assertEqual(f'{x=!a:^20}', 'x=' + format(ascii(x), '^20')) x = 9 self.assertEqual(f'{3*x+15=}', '3*x+15=42') # There is code in ast.c that deals with non-ascii expression values. So, # use a unicode identifier to trigger that. tenΟ = 31.4 self.assertEqual(f'{tenΟ=:.2f}', 'tenΟ=31.40') # Also test with Unicode in non-identifiers. self.assertEqual(f'{"Ξ£"=}', '"Ξ£"=\'Ξ£\'') # Make sure nested fstrings still work. self.assertEqual(f'{f"{3.1415=:.1f}":*^20}', '*****3.1415=3.1*****') # Make sure text before and after an expression with = works # correctly. pi = 'Ο' self.assertEqual(f'alpha Ξ± {pi=} Ο omega', "alpha Ξ± pi='Ο' Ο omega") # Check multi-line expressions. self.assertEqual(f'''{ 3 =}''', '\n3\n=3') # Since = is handled specially, make sure all existing uses of # it still work. self.assertEqual(f'{0==1}', 'False') self.assertEqual(f'{0!=1}', 'True') self.assertEqual(f'{0<=1}', 'True') self.assertEqual(f'{0>=1}', 'False') self.assertEqual(f'{(x:="5")}', '5') self.assertEqual(x, '5') self.assertEqual(f'{(x:=5)}', '5') self.assertEqual(x, 5) self.assertEqual(f'{"="}', '=') x = 20 # This isn't an assignment expression, it's 'x', with a format # spec of '=10'. See test_walrus: you need to use parens. self.assertEqual(f'{x:=10}', ' 20') # Test named function parameters, to make sure '=' parsing works # there. def f(a): nonlocal x oldx = x x = a return oldx x = 0 self.assertEqual(f'{f(a="3=")}', '0') self.assertEqual(x, '3=') self.assertEqual(f'{f(a=4)}', '3=') self.assertEqual(x, 4) # Make sure __format__ is being called. class C: def __format__(self, s): return f'FORMAT-{s}' def __repr__(self): return 'REPR' self.assertEqual(f'{C()=}', 'C()=REPR') self.assertEqual(f'{C()=!r}', 'C()=REPR') self.assertEqual(f'{C()=:}', 'C()=FORMAT-') self.assertEqual(f'{C()=: }', 'C()=FORMAT- ') self.assertEqual(f'{C()=:x}', 'C()=FORMAT-x') self.assertEqual(f'{C()=!r:*^20}', 'C()=********REPR********') self.assertRaises(SyntaxError, eval, "f'{C=]'") # Make sure leading and following text works. x = 'foo' self.assertEqual(f'X{x=}Y', 'Xx='+repr(x)+'Y') # Make sure whitespace around the = works. self.assertEqual(f'X{x =}Y', 'Xx ='+repr(x)+'Y') self.assertEqual(f'X{x= }Y', 'Xx= '+repr(x)+'Y') self.assertEqual(f'X{x = }Y', 'Xx = '+repr(x)+'Y') # These next lines contains tabs. Backslash escapes don't # work in f-strings. # patchcheck doesn't like these tabs. So the only way to test # this will be to dynamically created and exec the f-strings. But # that's such a hassle I'll save it for another day. For now, convert # the tabs to spaces just to shut up patchcheck. #self.assertEqual(f'X{x =}Y', 'Xx\t='+repr(x)+'Y') #self.assertEqual(f'X{x = }Y', 'Xx\t=\t'+repr(x)+'Y') def test_walrus(self): x = 20 # This isn't an assignment expression, it's 'x', with a format # spec of '=10'. self.assertEqual(f'{x:=10}', ' 20') # This is an assignment expression, which requires parens. self.assertEqual(f'{(x:=10)}', '10') self.assertEqual(x, 10) if __name__ == '__main__': unittest.main()
Upload File
Create Folder