Gecko [ beriskala.com ]

Name	Size	Permission	Date
__pycache__	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
audiodata	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
capath	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
cjkencodings	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
data	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
decimaltestdata	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
encoded_modules	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
imghdrdata	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
sndhdrdata	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
subprocessdata	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
support	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
test_asyncio	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
test_email	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
test_importlib	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
test_json	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
tracedmodules	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
xmltestdata	[ DIR ]	drwxr-xr-x	2026-05-01 04:20
185test.db	16 KB	-rw-r--r--	2019-03-18 20:21
Sine-1000Hz-300ms.aif	60.25 KB	-rw-r--r--	2019-03-18 20:21
__init__.py	47 B	-rw-r--r--	2024-04-17 20:39
__main__.py	55 B	-rw-r--r--	2024-04-17 20:39
_test_multiprocessing.py	120.53 KB	-rw-r--r--	2024-04-17 20:39
audiotests.py	12.13 KB	-rw-r--r--	2024-04-17 20:39
autotest.py	211 B	-rw-r--r--	2024-04-17 20:39
bad_coding.py	24 B	-rw-r--r--	2024-04-17 20:39
bad_coding2.py	30 B	-rw-r--r--	2024-04-17 20:39
badcert.pem	1.88 KB	-rw-r--r--	2019-03-18 20:21
badkey.pem	2.11 KB	-rw-r--r--	2019-03-18 20:21
badsyntax_3131.py	32 B	-rw-r--r--	2024-04-17 20:39
badsyntax_future10.py	95 B	-rw-r--r--	2024-04-17 20:39
badsyntax_future3.py	172 B	-rw-r--r--	2024-04-17 20:39
badsyntax_future4.py	153 B	-rw-r--r--	2024-04-17 20:39
badsyntax_future5.py	184 B	-rw-r--r--	2024-04-17 20:40
badsyntax_future6.py	161 B	-rw-r--r--	2024-04-17 20:39
badsyntax_future7.py	196 B	-rw-r--r--	2024-04-17 20:39
badsyntax_future8.py	122 B	-rw-r--r--	2024-04-17 20:39
badsyntax_future9.py	142 B	-rw-r--r--	2024-04-17 20:39
badsyntax_pep3120.py	14 B	-rw-r--r--	2024-04-17 20:39
buffer_tests.py	11.11 KB	-rw-r--r--	2024-04-17 20:39
bytecode_helper.py	1.57 KB	-rw-r--r--	2024-04-17 20:39
cfgparser.1	21 B	-rw-r--r--	2019-03-18 20:21
cfgparser.2	19.02 KB	-rw-r--r--	2019-03-18 20:21
cfgparser.3	1.55 KB	-rw-r--r--	2019-03-18 20:21
check_soundcard.vbs	411 B	-rw-r--r--	2019-03-18 20:21
cmath_testcases.txt	133.86 KB	-rw-r--r--	2019-03-18 20:21
coding20731.py	18 B	-rw-r--r--	2024-04-17 20:39
curses_tests.py	1.22 KB	-rwxr-xr-x	2024-04-17 20:39
datetimetester.py	150.77 KB	-rw-r--r--	2024-04-17 20:39
dh1024.pem	300 B	-rw-r--r--	2019-03-18 20:21
dis_module.py	76 B	-rw-r--r--	2024-04-17 20:39
doctest_aliases.py	240 B	-rw-r--r--	2024-04-17 20:39
double_const.py	1.18 KB	-rw-r--r--	2024-04-17 20:39
empty.vbs	70 B	-rw-r--r--	2019-03-18 20:21
exception_hierarchy.txt	1.69 KB	-rw-r--r--	2019-03-18 20:21
final_a.py	411 B	-rw-r--r--	2024-04-17 20:39
final_b.py	411 B	-rw-r--r--	2024-04-17 20:39
floating_points.txt	15.92 KB	-rw-r--r--	2019-03-18 20:21
fork_wait.py	2.1 KB	-rw-r--r--	2024-04-17 20:39
formatfloat_testcases.txt	7.45 KB	-rw-r--r--	2019-03-18 20:21
future_test1.py	229 B	-rw-r--r--	2024-04-17 20:39
future_test2.py	149 B	-rw-r--r--	2024-04-17 20:39
gdb_sample.py	153 B	-rw-r--r--	2024-04-17 20:39
ieee754.txt	3.21 KB	-rw-r--r--	2019-03-18 20:21
inspect_fodder.py	854 B	-rw-r--r--	2024-04-17 20:39
inspect_fodder2.py	1.39 KB	-rw-r--r--	2024-04-17 20:39
keycert.passwd.pem	1.79 KB	-rw-r--r--	2019-03-18 20:21
keycert.pem	1.74 KB	-rw-r--r--	2019-03-18 20:21
keycert2.pem	1.75 KB	-rw-r--r--	2019-03-18 20:21
keycert3.pem	3.96 KB	-rw-r--r--	2019-03-18 20:21
keycert4.pem	3.96 KB	-rw-r--r--	2019-03-18 20:21
list_tests.py	17.26 KB	-rw-r--r--	2024-04-17 20:39
lock_tests.py	26.9 KB	-rw-r--r--	2024-04-17 20:39
mailcap.txt	1.24 KB	-rw-r--r--	2019-03-18 20:21
make_ssl_certs.py	5.51 KB	-rw-r--r--	2024-04-17 20:39
mapping_tests.py	21.49 KB	-rw-r--r--	2024-04-17 20:39
math_testcases.txt	23.19 KB	-rw-r--r--	2019-03-18 20:21
memory_watchdog.py	859 B	-rw-r--r--	2024-04-17 20:39
mime.types	47.37 KB	-rw-r--r--	2019-03-18 20:21
mock_socket.py	3.31 KB	-rw-r--r--	2024-04-17 20:39
mp_fork_bomb.py	448 B	-rw-r--r--	2024-04-17 20:39
multibytecodec_support.py	14.44 KB	-rw-r--r--	2024-04-17 20:39
nokia.pem	1.88 KB	-rw-r--r--	2019-03-18 20:21
nullbytecert.pem	5.31 KB	-rw-r--r--	2019-03-18 20:21
nullcert.pem	0 B	-rw-r--r--	2019-03-18 20:21
outstanding_bugs.py	370 B	-rw-r--r--	2024-04-17 20:39
pickletester.py	95.66 KB	-rw-r--r--	2024-04-17 20:39
profilee.py	2.97 KB	-rw-r--r--	2024-04-17 20:39
pstats.pck	65.05 KB	-rw-r--r--	2019-03-18 20:21
pycacert.pem	4.21 KB	-rw-r--r--	2019-03-18 20:21
pycakey.pem	1.66 KB	-rw-r--r--	2019-03-18 20:21
pyclbr_input.py	648 B	-rw-r--r--	2024-04-17 20:39
pydoc_mod.py	708 B	-rw-r--r--	2024-04-17 20:39
pydocfodder.py	6.18 KB	-rw-r--r--	2024-04-17 20:39
pystone.py	7.57 KB	-rwxr-xr-x	2024-04-17 20:39
randv2_32.pck	7.34 KB	-rw-r--r--	2019-03-18 20:21
randv2_64.pck	7.19 KB	-rw-r--r--	2019-03-18 20:21
randv3.pck	7.82 KB	-rw-r--r--	2019-03-18 20:21
re_tests.py	31.06 KB	-rwxr-xr-x	2024-04-17 20:39
regrtest.py	60.32 KB	-rwxr-xr-x	2024-04-17 20:39
relimport.py	27 B	-rw-r--r--	2024-04-17 20:39
reperf.py	538 B	-rw-r--r--	2024-04-17 20:39
revocation.crl	625 B	-rw-r--r--	2019-03-18 20:21
sample_doctest.py	1.02 KB	-rw-r--r--	2024-04-17 20:39
sample_doctest_no_docstrings.py	227 B	-rw-r--r--	2024-04-17 20:39
sample_doctest_no_doctests.py	269 B	-rw-r--r--	2024-04-17 20:39
script_helper.py	8.68 KB	-rw-r--r--	2024-04-17 20:39
selfsigned_pythontestdotnet.pem	956 B	-rw-r--r--	2019-03-18 20:21
seq_tests.py	13.87 KB	-rw-r--r--	2024-04-17 20:39
sgml_input.html	8.1 KB	-rw-r--r--	2019-03-18 20:21
sha256.pem	8.15 KB	-rw-r--r--	2019-03-18 20:21
sortperf.py	4.69 KB	-rw-r--r--	2024-04-17 20:39
ssl_cert.pem	867 B	-rw-r--r--	2019-03-18 20:21
ssl_key.passwd.pem	963 B	-rw-r--r--	2019-03-18 20:21
ssl_key.pem	916 B	-rw-r--r--	2019-03-18 20:21
ssl_servers.py	6.88 KB	-rw-r--r--	2024-04-17 20:39
ssltests.py	640 B	-rw-r--r--	2024-04-17 20:39
string_tests.py	63.25 KB	-rw-r--r--	2024-04-17 20:39
talos-2019-0758.pem	1.3 KB	-rw-r--r--	2019-03-18 20:21
test___all__.py	4.11 KB	-rw-r--r--	2024-04-17 20:39
test___future__.py	2.44 KB	-rw-r--r--	2024-04-17 20:39
test__locale.py	7.72 KB	-rw-r--r--	2024-04-17 20:39
test__opcode.py	908 B	-rw-r--r--	2024-04-17 20:39
test__osx_support.py	11.5 KB	-rw-r--r--	2024-04-17 20:39
test_abc.py	13.33 KB	-rw-r--r--	2024-04-17 20:39
test_abstract_numbers.py	1.49 KB	-rw-r--r--	2024-04-17 20:39
test_aifc.py	15.14 KB	-rw-r--r--	2024-04-17 20:39
test_argparse.py	160.4 KB	-rw-r--r--	2024-04-17 20:39
test_array.py	44.56 KB	-rw-r--r--	2024-04-17 20:39
test_ast.py	42.97 KB	-rw-r--r--	2024-04-17 20:39
test_asynchat.py	10.9 KB	-rw-r--r--	2024-04-17 20:39
test_asyncore.py	26.76 KB	-rw-r--r--	2024-04-17 20:39
test_atexit.py	4.54 KB	-rw-r--r--	2024-04-17 20:39
test_audioop.py	28.05 KB	-rw-r--r--	2024-04-17 20:39
test_augassign.py	7.16 KB	-rw-r--r--	2024-04-17 20:39
test_base64.py	28.9 KB	-rw-r--r--	2024-04-17 20:39
test_bigaddrspace.py	2.92 KB	-rw-r--r--	2024-04-17 20:39
test_bigmem.py	44.18 KB	-rw-r--r--	2024-04-17 20:39
test_binascii.py	10.66 KB	-rw-r--r--	2024-04-17 20:39
test_binhex.py	1.47 KB	-rw-r--r--	2024-04-17 20:39
test_binop.py	12.84 KB	-rw-r--r--	2024-04-17 20:39
test_bisect.py	13.63 KB	-rw-r--r--	2024-04-17 20:39
test_bool.py	11.75 KB	-rw-r--r--	2024-04-17 20:39
test_buffer.py	155.57 KB	-rw-r--r--	2024-04-17 20:39
test_bufio.py	2.54 KB	-rw-r--r--	2024-04-17 20:39
test_builtin.py	58.71 KB	-rw-r--r--	2024-04-17 20:39
test_bytes.py	57.01 KB	-rw-r--r--	2024-04-17 20:39
test_bz2.py	32.29 KB	-rw-r--r--	2024-04-17 20:39
test_calendar.py	42.74 KB	-rw-r--r--	2024-04-17 20:39
test_call.py	3.08 KB	-rw-r--r--	2024-04-17 20:39
test_capi.py	18.04 KB	-rw-r--r--	2024-04-17 20:39
test_cgi.py	18.94 KB	-rw-r--r--	2024-04-17 20:39
test_cgitb.py	2.49 KB	-rw-r--r--	2024-04-17 20:39
test_charmapcodec.py	1.75 KB	-rw-r--r--	2024-04-17 20:39
test_class.py	14.14 KB	-rw-r--r--	2024-04-17 20:40
test_cmath.py	21.47 KB	-rw-r--r--	2024-04-17 20:39
test_cmd.py	6.11 KB	-rw-r--r--	2024-04-17 20:39
test_cmd_line.py	19.91 KB	-rw-r--r--	2024-04-17 20:39
test_cmd_line_script.py	20.21 KB	-rw-r--r--	2024-04-17 20:39
test_code.py	3.54 KB	-rw-r--r--	2024-04-17 20:39
test_code_module.py	2.94 KB	-rw-r--r--	2024-04-17 20:39
test_codeccallbacks.py	37.64 KB	-rw-r--r--	2024-04-17 20:39
test_codecencodings_cn.py	3.38 KB	-rw-r--r--	2024-04-17 20:40
test_codecencodings_hk.py	775 B	-rw-r--r--	2024-04-17 20:39
test_codecencodings_iso2022.py	1.43 KB	-rw-r--r--	2024-04-17 20:39
test_codecencodings_jp.py	4.86 KB	-rw-r--r--	2024-04-17 20:39
test_codecencodings_kr.py	3.03 KB	-rw-r--r--	2024-04-17 20:39
test_codecencodings_tw.py	755 B	-rw-r--r--	2024-04-17 20:39
test_codecmaps_cn.py	771 B	-rw-r--r--	2024-04-17 20:39
test_codecmaps_hk.py	411 B	-rw-r--r--	2024-04-17 20:39
test_codecmaps_jp.py	1.73 KB	-rw-r--r--	2024-04-17 20:39
test_codecmaps_kr.py	1.19 KB	-rw-r--r--	2024-04-17 20:39
test_codecmaps_tw.py	730 B	-rw-r--r--	2024-04-17 20:39
test_codecs.py	114.61 KB	-rw-r--r--	2024-04-17 20:39
test_codeop.py	7.45 KB	-rw-r--r--	2024-04-17 20:39
test_collections.py	50.45 KB	-rw-r--r--	2024-04-17 20:39
test_colorsys.py	3.83 KB	-rw-r--r--	2024-04-17 20:39
test_compare.py	3.9 KB	-rw-r--r--	2024-04-17 20:39
test_compile.py	22.5 KB	-rw-r--r--	2024-04-17 20:39
test_compileall.py	16.65 KB	-rw-r--r--	2024-04-17 20:39
test_complex.py	27.48 KB	-rw-r--r--	2024-04-17 20:39
test_concurrent_futures.py	23.27 KB	-rw-r--r--	2024-04-17 20:39
test_configparser.py	70.43 KB	-rw-r--r--	2024-04-17 20:39
test_contains.py	2.58 KB	-rw-r--r--	2024-04-17 20:39
test_contextlib.py	25.77 KB	-rw-r--r--	2024-04-17 20:39
test_copy.py	22.22 KB	-rw-r--r--	2024-04-17 20:39
test_copyreg.py	4.12 KB	-rw-r--r--	2024-04-17 20:39
test_cprofile.py	5.41 KB	-rw-r--r--	2024-04-17 20:39
test_crashers.py	1.18 KB	-rw-r--r--	2024-04-17 20:39
test_crypt.py	1.06 KB	-rw-r--r--	2024-04-17 20:39
test_csv.py	41.48 KB	-rw-r--r--	2024-04-17 20:39
test_ctypes.py	184 B	-rw-r--r--	2024-04-17 20:39
test_curses.py	12.66 KB	-rw-r--r--	2024-04-17 20:39
test_datetime.py	1.81 KB	-rw-r--r--	2024-04-17 20:39
test_dbm.py	5.52 KB	-rw-r--r--	2024-04-17 20:39
test_dbm_dumb.py	7.07 KB	-rw-r--r--	2024-04-17 20:39
test_dbm_gnu.py	3.28 KB	-rw-r--r--	2024-04-17 20:39
test_dbm_ndbm.py	1.58 KB	-rw-r--r--	2024-04-17 20:39
test_decimal.py	198.92 KB	-rw-r--r--	2024-04-17 20:39
test_decorators.py	9.6 KB	-rw-r--r--	2024-04-17 20:39
test_defaultdict.py	5.94 KB	-rw-r--r--	2024-04-17 20:39
test_deque.py	25.26 KB	-rw-r--r--	2024-04-17 20:39
test_descr.py	175.81 KB	-rw-r--r--	2024-04-17 20:39
test_descrtut.py	11.5 KB	-rw-r--r--	2024-04-17 20:39
test_devpoll.py	4.53 KB	-rw-r--r--	2024-04-17 20:39
test_dict.py	32.36 KB	-rw-r--r--	2024-04-17 20:39
test_dictcomps.py	3.69 KB	-rw-r--r--	2024-04-17 20:39
test_dictviews.py	9.46 KB	-rw-r--r--	2024-04-17 20:39
test_difflib.py	11.96 KB	-rw-r--r--	2024-04-17 20:39
test_difflib_expect.html	100.86 KB	-rw-r--r--	2019-03-18 20:21
test_dis.py	40.48 KB	-rw-r--r--	2024-04-17 20:40
test_distutils.py	375 B	-rw-r--r--	2024-04-17 20:39
test_doctest.py	92.94 KB	-rw-r--r--	2024-04-17 20:39
test_doctest.txt	300 B	-rw-r--r--	2019-03-18 20:21
test_doctest2.py	2.3 KB	-rw-r--r--	2024-04-17 20:39
test_doctest2.txt	392 B	-rw-r--r--	2019-03-18 20:21
test_doctest3.txt	82 B	-rw-r--r--	2019-03-18 20:21
test_doctest4.txt	244 B	-rw-r--r--	2019-03-18 20:21
test_docxmlrpc.py	8.32 KB	-rw-r--r--	2024-04-17 20:39
test_dummy_thread.py	6.99 KB	-rw-r--r--	2024-04-17 20:39
test_dummy_threading.py	1.76 KB	-rw-r--r--	2024-04-17 20:39
test_dynamic.py	4.37 KB	-rw-r--r--	2024-04-17 20:39
test_dynamicclassattribute.py	9.67 KB	-rw-r--r--	2024-04-17 20:39
test_ensurepip.py	11.42 KB	-rw-r--r--	2024-04-17 20:39
test_enum.py	56.4 KB	-rw-r--r--	2024-04-17 20:39
test_enumerate.py	8 KB	-rw-r--r--	2024-04-17 20:39
test_eof.py	855 B	-rw-r--r--	2024-04-17 20:39
test_epoll.py	8.67 KB	-rw-r--r--	2024-04-17 20:39
test_errno.py	1.14 KB	-rw-r--r--	2024-04-17 20:39
test_exception_variations.py	3.94 KB	-rw-r--r--	2024-04-17 20:39
test_exceptions.py	36.05 KB	-rw-r--r--	2024-04-17 20:39
test_extcall.py	8.64 KB	-rw-r--r--	2024-04-17 20:39
test_faulthandler.py	21.18 KB	-rw-r--r--	2024-04-17 20:39
test_fcntl.py	5.1 KB	-rw-r--r--	2024-04-17 20:39
test_file.py	11.09 KB	-rw-r--r--	2024-04-17 20:39
test_file_eintr.py	10.09 KB	-rw-r--r--	2024-04-17 20:39
test_filecmp.py	8.69 KB	-rw-r--r--	2024-04-17 20:39
test_fileinput.py	34.13 KB	-rw-r--r--	2024-04-17 20:39
test_fileio.py	15.58 KB	-rw-r--r--	2024-04-17 20:39
test_finalization.py	14.21 KB	-rw-r--r--	2024-04-17 20:39
test_float.py	59.14 KB	-rw-r--r--	2024-04-17 20:39
test_flufl.py	836 B	-rw-r--r--	2024-04-17 20:40
test_fnmatch.py	2.84 KB	-rw-r--r--	2024-04-17 20:39
test_fork1.py	3.69 KB	-rw-r--r--	2024-04-17 20:39
test_format.py	16.82 KB	-rw-r--r--	2024-04-17 20:39
test_fractions.py	24.77 KB	-rw-r--r--	2024-04-17 20:39
test_frame.py	4.42 KB	-rw-r--r--	2024-04-17 20:39
test_ftplib.py	37.37 KB	-rw-r--r--	2024-04-17 20:39
test_funcattrs.py	13.05 KB	-rw-r--r--	2024-04-17 20:39
test_functools.py	59.52 KB	-rw-r--r--	2024-04-17 20:39
test_future.py	4.05 KB	-rw-r--r--	2024-04-17 20:39
test_future3.py	490 B	-rw-r--r--	2024-04-17 20:39
test_future4.py	105 B	-rw-r--r--	2024-04-17 20:39
test_future5.py	510 B	-rw-r--r--	2024-04-17 20:39
test_gc.py	33.03 KB	-rw-r--r--	2024-04-17 20:39
test_gdb.py	36.71 KB	-rw-r--r--	2024-04-17 20:39
test_generators.py	54.27 KB	-rw-r--r--	2024-04-17 20:39
test_genericpath.py	15.84 KB	-rw-r--r--	2024-04-17 20:39
test_genexps.py	7.12 KB	-rw-r--r--	2024-04-17 20:39
test_getargs2.py	23.96 KB	-rw-r--r--	2024-04-17 20:39
test_getopt.py	6.8 KB	-rw-r--r--	2024-04-17 20:39
test_getpass.py	6.29 KB	-rw-r--r--	2024-04-17 20:39
test_gettext.py	22.97 KB	-rw-r--r--	2024-04-17 20:39
test_glob.py	7.49 KB	-rw-r--r--	2024-04-17 20:39
test_global.py	1.25 KB	-rw-r--r--	2024-04-17 20:39
test_grammar.py	33.54 KB	-rw-r--r--	2024-04-17 20:39
test_grp.py	3.18 KB	-rw-r--r--	2024-04-17 20:39
test_gzip.py	21 KB	-rw-r--r--	2024-04-17 20:39
test_hash.py	11.43 KB	-rw-r--r--	2024-04-17 20:39
test_hashlib.py	24.43 KB	-rw-r--r--	2024-04-17 20:39
test_heapq.py	14.14 KB	-rw-r--r--	2024-04-17 20:39
test_hmac.py	20.21 KB	-rw-r--r--	2024-04-17 20:39
test_html.py	4.27 KB	-rw-r--r--	2024-04-17 20:39
test_htmlparser.py	34.04 KB	-rw-r--r--	2024-04-17 20:39
test_http_cookiejar.py	73.57 KB	-rw-r--r--	2024-04-17 20:39
test_http_cookies.py	10.48 KB	-rw-r--r--	2024-04-17 20:39
test_httplib.py	47.04 KB	-rw-r--r--	2024-04-17 20:39
test_httpservers.py	32.38 KB	-rw-r--r--	2024-04-17 20:39
test_idle.py	786 B	-rw-r--r--	2024-04-17 20:39
test_imaplib.py	17.49 KB	-rw-r--r--	2024-04-17 20:39
test_imghdr.py	4.31 KB	-rw-r--r--	2024-04-17 20:39
test_imp.py	19.42 KB	-rw-r--r--	2024-04-17 20:39
test_import.py	39.28 KB	-rw-r--r--	2024-04-17 20:39
test_index.py	8.37 KB	-rw-r--r--	2024-04-17 20:39
test_inspect.py	119.28 KB	-rw-r--r--	2024-04-17 20:39
test_int.py	17.77 KB	-rw-r--r--	2024-04-17 20:39
test_int_literal.py	6.96 KB	-rw-r--r--	2024-04-17 20:39
test_io.py	133.84 KB	-rw-r--r--	2024-04-17 20:39
test_ioctl.py	3.21 KB	-rw-r--r--	2024-04-17 20:39
test_ipaddress.py	74.26 KB	-rw-r--r--	2024-04-17 20:39
test_isinstance.py	9.93 KB	-rw-r--r--	2024-04-17 20:39
test_iter.py	29.43 KB	-rw-r--r--	2024-04-17 20:39
test_iterlen.py	7.12 KB	-rw-r--r--	2024-04-17 20:39
test_itertools.py	87.8 KB	-rw-r--r--	2024-04-17 20:39
test_keyword.py	5.7 KB	-rw-r--r--	2024-04-17 20:39
test_keywordonlyarg.py	7.14 KB	-rw-r--r--	2024-04-17 20:39
test_kqueue.py	8.22 KB	-rw-r--r--	2024-04-17 20:39
test_largefile.py	6.4 KB	-rw-r--r--	2024-04-17 20:39
test_lib2to3.py	101 B	-rw-r--r--	2024-04-17 20:39
test_linecache.py	4.58 KB	-rw-r--r--	2024-04-17 20:39
test_list.py	4.33 KB	-rw-r--r--	2024-04-17 20:39
test_listcomps.py	3.76 KB	-rw-r--r--	2024-04-17 20:39
test_locale.py	20.16 KB	-rw-r--r--	2024-04-17 20:39
test_logging.py	141.36 KB	-rw-r--r--	2024-04-17 20:39
test_long.py	48.02 KB	-rw-r--r--	2024-04-17 20:39
test_longexp.py	308 B	-rw-r--r--	2024-04-17 20:39
test_lzma.py	71.03 KB	-rw-r--r--	2024-04-17 20:40
test_macpath.py	6 KB	-rw-r--r--	2024-04-17 20:39
test_macurl2path.py	1.8 KB	-rw-r--r--	2024-04-17 20:39
test_mailbox.py	90.51 KB	-rw-r--r--	2024-04-17 20:39
test_mailcap.py	9 KB	-rw-r--r--	2024-04-17 20:39
test_marshal.py	17.7 KB	-rw-r--r--	2024-04-17 20:39
test_math.py	45.89 KB	-rw-r--r--	2024-04-17 20:39
test_memoryio.py	28.34 KB	-rw-r--r--	2024-04-17 20:39
test_memoryview.py	16.23 KB	-rw-r--r--	2024-04-17 20:39
test_metaclass.py	6.2 KB	-rw-r--r--	2024-04-17 20:39
test_mimetypes.py	4.18 KB	-rw-r--r--	2024-04-17 20:39
test_minidom.py	63.38 KB	-rw-r--r--	2024-04-17 20:39
test_mmap.py	26.57 KB	-rw-r--r--	2024-04-17 20:39
test_module.py	7.89 KB	-rw-r--r--	2024-04-17 20:39
test_modulefinder.py	8.74 KB	-rw-r--r--	2024-04-17 20:39
test_msilib.py	1.43 KB	-rw-r--r--	2024-04-17 20:39
test_multibytecodec.py	10.07 KB	-rw-r--r--	2024-04-17 20:39
test_multiprocessing_fork.py	174 B	-rw-r--r--	2024-04-17 20:39
test_multiprocessing_forkserver.py	180 B	-rw-r--r--	2024-04-17 20:39
test_multiprocessing_main_handling.py	11.16 KB	-rw-r--r--	2024-04-17 20:39
test_multiprocessing_spawn.py	175 B	-rw-r--r--	2024-04-17 20:39
test_netrc.py	4.5 KB	-rw-r--r--	2024-04-17 20:39
test_nis.py	1.19 KB	-rw-r--r--	2024-04-17 20:39
test_nntplib.py	58.39 KB	-rw-r--r--	2024-04-17 20:39
test_normalization.py	3.15 KB	-rw-r--r--	2024-04-17 20:39
test_ntpath.py	18.09 KB	-rw-r--r--	2024-04-17 20:39
test_numeric_tower.py	7.27 KB	-rw-r--r--	2024-04-17 20:39
test_opcodes.py	2.61 KB	-rw-r--r--	2024-04-17 20:39
test_openpty.py	682 B	-rw-r--r--	2024-04-17 20:39
test_operator.py	18.17 KB	-rw-r--r--	2024-04-17 20:39
test_optparse.py	60.8 KB	-rw-r--r--	2024-04-17 20:39
test_ordered_dict.py	11.98 KB	-rw-r--r--	2024-04-17 20:39
test_os.py	98.21 KB	-rw-r--r--	2024-04-17 20:39
test_ossaudiodev.py	7.05 KB	-rw-r--r--	2024-04-17 20:39
test_osx_env.py	1.31 KB	-rw-r--r--	2024-04-17 20:39
test_parser.py	25.5 KB	-rw-r--r--	2024-04-17 20:39
test_pathlib.py	74.59 KB	-rw-r--r--	2024-04-17 20:39
test_pdb.py	33.25 KB	-rw-r--r--	2024-04-17 20:39
test_peepholer.py	12.8 KB	-rw-r--r--	2024-04-17 20:39
test_pep247.py	2.19 KB	-rw-r--r--	2024-04-17 20:39
test_pep277.py	6.84 KB	-rw-r--r--	2024-04-17 20:39
test_pep292.py	9.58 KB	-rw-r--r--	2024-04-17 20:39
test_pep3120.py	1.24 KB	-rw-r--r--	2024-04-17 20:39
test_pep3131.py	977 B	-rw-r--r--	2024-04-17 20:39
test_pep3151.py	7.31 KB	-rw-r--r--	2024-04-17 20:39
test_pep352.py	6.88 KB	-rw-r--r--	2024-04-17 20:39
test_pep380.py	28.92 KB	-rw-r--r--	2024-04-17 20:39
test_pickle.py	15.36 KB	-rw-r--r--	2024-04-17 20:39
test_pickletools.py	2.37 KB	-rw-r--r--	2024-04-17 20:39
test_pipes.py	6.32 KB	-rw-r--r--	2024-04-17 20:39
test_pkg.py	9.53 KB	-rw-r--r--	2024-04-17 20:39
test_pkgimport.py	2.72 KB	-rw-r--r--	2024-04-17 20:39
test_pkgutil.py	14.4 KB	-rw-r--r--	2024-04-17 20:39
test_platform.py	12.12 KB	-rw-r--r--	2024-04-17 20:39
test_plistlib.py	22.74 KB	-rw-r--r--	2024-04-17 20:39
test_poll.py	6.4 KB	-rw-r--r--	2024-04-17 20:39
test_popen.py	2.03 KB	-rw-r--r--	2024-04-17 20:39
test_poplib.py	15.99 KB	-rw-r--r--	2024-04-17 20:39
test_posix.py	50.82 KB	-rw-r--r--	2024-04-17 20:39
test_posixpath.py	22.97 KB	-rw-r--r--	2024-04-17 20:39
test_pow.py	4.49 KB	-rw-r--r--	2024-04-17 20:39
test_pprint.py	29.85 KB	-rw-r--r--	2024-04-17 20:39
test_print.py	4.16 KB	-rw-r--r--	2024-04-17 20:39
test_profile.py	7.61 KB	-rw-r--r--	2024-04-17 20:39
test_property.py	7.63 KB	-rw-r--r--	2024-04-17 20:39
test_pstats.py	1.26 KB	-rw-r--r--	2024-04-17 20:40
test_pty.py	11.02 KB	-rw-r--r--	2024-04-17 20:39
test_pulldom.py	12.17 KB	-rw-r--r--	2024-04-17 20:39
test_pwd.py	4.13 KB	-rw-r--r--	2024-04-17 20:39
test_py_compile.py	4.95 KB	-rw-r--r--	2024-04-17 20:39
test_pyclbr.py	6.85 KB	-rw-r--r--	2024-04-17 20:39
test_pydoc.py	39.37 KB	-rw-r--r--	2024-04-17 20:39
test_pyexpat.py	27.2 KB	-rw-r--r--	2024-04-17 20:39
test_queue.py	12.84 KB	-rw-r--r--	2024-04-17 20:39
test_quopri.py	7.86 KB	-rw-r--r--	2024-04-17 20:39
test_raise.py	11.08 KB	-rw-r--r--	2024-04-17 20:39
test_random.py	31.32 KB	-rw-r--r--	2024-04-17 20:39
test_range.py	22.9 KB	-rw-r--r--	2024-04-17 20:39
test_re.py	73.16 KB	-rw-r--r--	2024-04-17 20:39
test_readline.py	2.37 KB	-rw-r--r--	2024-04-17 20:40
test_regrtest.py	10.36 KB	-rw-r--r--	2024-04-17 20:39
test_reprlib.py	14.27 KB	-rw-r--r--	2024-04-17 20:39
test_resource.py	6.46 KB	-rw-r--r--	2024-04-17 20:39
test_richcmp.py	10.83 KB	-rw-r--r--	2024-04-17 20:39
test_rlcompleter.py	4.59 KB	-rw-r--r--	2024-04-17 20:39
test_robotparser.py	7.35 KB	-rw-r--r--	2024-04-17 20:39
test_runpy.py	28.64 KB	-rw-r--r--	2024-04-17 20:39
test_sax.py	41.76 KB	-rw-r--r--	2024-04-17 20:39
test_sched.py	6.43 KB	-rw-r--r--	2024-04-17 20:39
test_scope.py	19.76 KB	-rw-r--r--	2024-04-17 20:39
test_script_helper.py	5.02 KB	-rw-r--r--	2024-04-17 20:39
test_select.py	2.68 KB	-rw-r--r--	2024-04-17 20:39
test_selectors.py	14.96 KB	-rw-r--r--	2024-04-17 20:39
test_set.py	62.66 KB	-rw-r--r--	2024-04-17 20:39
test_setcomps.py	3.7 KB	-rw-r--r--	2024-04-17 20:39
test_shelve.py	6.12 KB	-rw-r--r--	2024-04-17 20:39
test_shlex.py	5.77 KB	-rw-r--r--	2024-04-17 20:39
test_shutil.py	72.37 KB	-rw-r--r--	2024-04-17 20:39
test_signal.py	33.08 KB	-rw-r--r--	2024-04-17 20:40
test_site.py	18.81 KB	-rw-r--r--	2024-04-17 20:39
test_slice.py	8.08 KB	-rw-r--r--	2024-04-17 20:39
test_smtpd.py	22.06 KB	-rw-r--r--	2024-04-17 20:39
test_smtplib.py	35.02 KB	-rw-r--r--	2024-04-17 20:39
test_smtpnet.py	2.76 KB	-rw-r--r--	2024-04-17 20:39
test_sndhdr.py	868 B	-rw-r--r--	2024-04-17 20:39
test_socket.py	191.2 KB	-rw-r--r--	2024-04-17 20:39
test_socketserver.py	10.83 KB	-rw-r--r--	2024-04-17 20:39
test_sort.py	8.95 KB	-rw-r--r--	2024-04-17 20:39
test_source_encoding.py	5.14 KB	-rw-r--r--	2024-04-17 20:39
test_spwd.py	2.29 KB	-rw-r--r--	2024-04-17 20:39
test_sqlite.py	893 B	-rw-r--r--	2024-04-17 20:39
test_ssl.py	130.33 KB	-rw-r--r--	2024-04-17 20:39
test_ssl.py.openssl11	129.64 KB	-rw-r--r--	2019-03-18 20:21
test_startfile.py	1.21 KB	-rw-r--r--	2024-04-17 20:39
test_stat.py	6.83 KB	-rw-r--r--	2024-04-17 20:39
test_statistics.py	68.88 KB	-rw-r--r--	2024-04-17 20:39
test_strftime.py	7.42 KB	-rw-r--r--	2024-04-17 20:39
test_string.py	7.69 KB	-rw-r--r--	2024-04-17 20:39
test_stringprep.py	3.12 KB	-rw-r--r--	2024-04-17 20:39
test_strlit.py	8.03 KB	-rw-r--r--	2024-04-17 20:39
test_strptime.py	28.14 KB	-rw-r--r--	2024-04-17 20:39
test_strtod.py	20.11 KB	-rw-r--r--	2024-04-17 20:39
test_struct.py	26.91 KB	-rw-r--r--	2024-04-17 20:39
test_structmembers.py	4.77 KB	-rw-r--r--	2024-04-17 20:39
test_structseq.py	3.95 KB	-rw-r--r--	2024-04-17 20:39
test_subprocess.py	108.35 KB	-rw-r--r--	2024-04-17 20:39
test_sunau.py	4.55 KB	-rw-r--r--	2024-04-17 20:40
test_sundry.py	2.17 KB	-rw-r--r--	2024-04-17 20:39
test_super.py	4.43 KB	-rw-r--r--	2024-04-17 20:39
test_support.py	10.09 KB	-rw-r--r--	2024-04-17 20:39
test_symtable.py	5.82 KB	-rw-r--r--	2024-04-17 20:39
test_syntax.py	17.64 KB	-rw-r--r--	2024-04-17 20:39
test_sys.py	38.82 KB	-rw-r--r--	2024-04-17 20:39
test_sys_setprofile.py	11.09 KB	-rw-r--r--	2024-04-17 20:39
test_sys_settrace.py	24.66 KB	-rw-r--r--	2024-04-17 20:39
test_sysconfig.py	16.42 KB	-rw-r--r--	2024-04-17 20:39
test_syslog.py	1.2 KB	-rw-r--r--	2024-04-17 20:39
test_systemtap.py	8.86 KB	-rw-r--r--	2024-04-17 20:39
test_systemtap.py.systemtap	0 B	-rw-r--r--	2024-04-17 20:35
test_tarfile.py	79.11 KB	-rw-r--r--	2024-04-17 20:39
test_tcl.py	26.92 KB	-rw-r--r--	2024-04-17 20:39
test_telnetlib.py	12.68 KB	-rw-r--r--	2024-04-17 20:39
test_tempfile.py	44.4 KB	-rw-r--r--	2024-04-17 20:39
test_textwrap.py	35.65 KB	-rw-r--r--	2024-04-17 20:39
test_thread.py	8.09 KB	-rw-r--r--	2024-04-17 20:39
test_threaded_import.py	8.25 KB	-rw-r--r--	2024-04-17 20:39
test_threadedtempfile.py	1.89 KB	-rw-r--r--	2024-04-17 20:39
test_threading.py	38.23 KB	-rw-r--r--	2024-04-17 20:39
test_threading_local.py	6.14 KB	-rw-r--r--	2024-04-17 20:39
test_threadsignals.py	9.22 KB	-rw-r--r--	2024-04-17 20:39
test_time.py	29.97 KB	-rw-r--r--	2024-04-17 20:39
test_timeit.py	11.92 KB	-rw-r--r--	2024-04-17 20:39
test_timeout.py	11.11 KB	-rw-r--r--	2024-04-17 20:39
test_tk.py	458 B	-rw-r--r--	2024-04-17 20:39
test_tokenize.py	48.45 KB	-rw-r--r--	2024-04-17 20:39
test_trace.py	14.45 KB	-rw-r--r--	2024-04-17 20:39
test_traceback.py	17.82 KB	-rw-r--r--	2024-04-17 20:39
test_tracemalloc.py	30.24 KB	-rw-r--r--	2024-04-17 20:39
test_ttk_guionly.py	847 B	-rw-r--r--	2024-04-17 20:39
test_ttk_textonly.py	405 B	-rw-r--r--	2024-04-17 20:39
test_tuple.py	6.99 KB	-rw-r--r--	2024-04-17 20:39
test_typechecks.py	2.64 KB	-rw-r--r--	2024-04-17 20:39
test_types.py	42.96 KB	-rw-r--r--	2024-04-17 20:39
test_ucn.py	9.41 KB	-rw-r--r--	2024-04-17 20:39
test_unary.py	1.71 KB	-rw-r--r--	2024-04-17 20:39
test_unicode.py	122.38 KB	-rw-r--r--	2024-04-17 20:39
test_unicode_file.py	5.73 KB	-rw-r--r--	2024-04-17 20:39
test_unicodedata.py	12.06 KB	-rw-r--r--	2024-04-17 20:39
test_unittest.py	286 B	-rw-r--r--	2024-04-17 20:39
test_univnewlines.py	3.83 KB	-rw-r--r--	2024-04-17 20:39
test_unpack.py	2.56 KB	-rw-r--r--	2024-04-17 20:39
test_unpack_ex.py	4.04 KB	-rw-r--r--	2024-04-17 20:39
test_urllib.py	59.03 KB	-rw-r--r--	2024-04-17 20:39
test_urllib2.py	65.68 KB	-rw-r--r--	2024-04-17 20:39
test_urllib2_localnet.py	25.61 KB	-rw-r--r--	2024-04-17 20:39
test_urllib2net.py	11.96 KB	-rw-r--r--	2024-04-17 20:39
test_urllib_response.py	1.69 KB	-rw-r--r--	2024-04-17 20:39
test_urllibnet.py	8.78 KB	-rw-r--r--	2024-04-17 20:39
test_urlparse.py	51.51 KB	-rw-r--r--	2024-04-17 20:39
test_userdict.py	7.71 KB	-rw-r--r--	2024-04-17 20:39
test_userlist.py	1.85 KB	-rw-r--r--	2024-04-17 20:39
test_userstring.py	1.46 KB	-rw-r--r--	2024-04-17 20:39
test_uu.py	7.39 KB	-rw-r--r--	2024-04-17 20:39
test_uuid.py	21.84 KB	-rw-r--r--	2024-04-17 20:39
test_venv.py	16.16 KB	-rw-r--r--	2024-04-17 20:39
test_wait3.py	1.13 KB	-rw-r--r--	2024-04-17 20:39
test_wait4.py	1.11 KB	-rw-r--r--	2024-04-17 20:39
test_warnings.py	37.13 KB	-rw-r--r--	2024-04-17 20:39
test_wave.py	3.93 KB	-rw-r--r--	2024-04-17 20:39
test_weakref.py	62.02 KB	-rw-r--r--	2024-04-17 20:39
test_weakset.py	15.18 KB	-rw-r--r--	2024-04-17 20:39
test_webbrowser.py	5.65 KB	-rw-r--r--	2024-04-17 20:39
test_winreg.py	20.52 KB	-rw-r--r--	2024-04-17 20:39
test_winsound.py	8.86 KB	-rw-r--r--	2024-04-17 20:39
test_with.py	25.85 KB	-rw-r--r--	2024-04-17 20:40
test_wsgiref.py	22.5 KB	-rw-r--r--	2024-04-17 20:39
test_xdrlib.py	2.29 KB	-rw-r--r--	2024-04-17 20:39
test_xml_dom_minicompat.py	4.18 KB	-rw-r--r--	2024-04-17 20:39
test_xml_etree.py	106.56 KB	-rw-r--r--	2024-04-17 20:39
test_xml_etree_c.py	3.99 KB	-rw-r--r--	2024-04-17 20:39
test_xmlrpc.py	42.05 KB	-rw-r--r--	2024-04-17 20:39
test_xmlrpc_net.py	1.03 KB	-rw-r--r--	2024-04-17 20:39
test_zipfile.py	76.19 KB	-rw-r--r--	2024-04-17 20:39
test_zipfile64.py	5.56 KB	-rw-r--r--	2024-04-17 20:39
test_zipimport.py	17.69 KB	-rw-r--r--	2024-04-17 20:40
test_zipimport_support.py	10.45 KB	-rw-r--r--	2024-04-17 20:39
test_zlib.py	26.79 KB	-rw-r--r--	2024-04-17 20:39
testcodec.py	1.02 KB	-rw-r--r--	2024-04-17 20:39
testtar.tar	425 KB	-rw-r--r--	2019-03-18 20:21
tf_inherit_check.py	577 B	-rw-r--r--	2024-04-17 20:39
threaded_import_hangers.py	1.45 KB	-rw-r--r--	2024-04-17 20:39
time_hashlib.py	2.83 KB	-rw-r--r--	2024-04-17 20:39
tokenize_tests-latin1-coding-cookie-and-utf8-bom-sig.txt	444 B	-rw-r--r--	2019-03-18 20:21
tokenize_tests-no-coding-cookie-and-utf8-bom-sig-only.txt	303 B	-rw-r--r--	2019-03-18 20:21
tokenize_tests-utf8-coding-cookie-and-no-utf8-bom-sig.txt	421 B	-rw-r--r--	2019-03-18 20:21
tokenize_tests-utf8-coding-cookie-and-utf8-bom-sig.txt	327 B	-rw-r--r--	2019-03-18 20:21
tokenize_tests.txt	2.65 KB	-rw-r--r--	2019-03-18 20:21
warning_tests.py	240 B	-rw-r--r--	2024-04-17 20:39
win_console_handler.py	1.38 KB	-rw-r--r--	2024-04-17 20:39
xmltests.py	499 B	-rw-r--r--	2024-04-17 20:39
zip_cp437_header.zip	270 B	-rw-r--r--	2019-03-18 20:21
zipdir.zip	374 B	-rw-r--r--	2019-03-18 20:21

Rename

import errno
from http import client
import io
import itertools
import os
import array
import socket

import unittest
TestCase = unittest.TestCase

from test import support

here = os.path.dirname(__file__)
# Self-signed cert file for 'localhost'
CERT_localhost = os.path.join(here, 'keycert.pem')
# Self-signed cert file for 'fakehostname'
CERT_fakehostname = os.path.join(here, 'keycert2.pem')
# Self-signed cert file for self-signed.pythontest.net
CERT_selfsigned_pythontestdotnet = os.path.join(here, 'selfsigned_pythontestdotnet.pem')

HOST = support.HOST

class FakeSocket:
    def __init__(self, text, fileclass=io.BytesIO, host=None, port=None):
        if isinstance(text, str):
            text = text.encode("ascii")
        self.text = text
        self.fileclass = fileclass
        self.data = b''
        self.sendall_calls = 0
        self.file_closed = False
        self.host = host
        self.port = port

def sendall(self, data):
        self.sendall_calls += 1
        self.data += data

def makefile(self, mode, bufsize=None):
        if mode != 'r' and mode != 'rb':
            raise client.UnimplementedFileMode()
        # keep the file around so we can check how much was read from it
        self.file = self.fileclass(self.text)
        self.file.close = self.file_close #nerf close ()
        return self.file

def file_close(self):
        self.file_closed = True

def close(self):
        pass

class EPipeSocket(FakeSocket):

def __init__(self, text, pipe_trigger):
        # When sendall() is called with pipe_trigger, raise EPIPE.
        FakeSocket.__init__(self, text)
        self.pipe_trigger = pipe_trigger

def sendall(self, data):
        if self.pipe_trigger in data:
            raise OSError(errno.EPIPE, "gotcha")
        self.data += data

def close(self):
        pass

class NoEOFBytesIO(io.BytesIO):
    """Like BytesIO, but raises AssertionError on EOF.

This is used below to test that http.client doesn't try to read
    more from the underlying file than it should.
    """
    def read(self, n=-1):
        data = io.BytesIO.read(self, n)
        if data == b'':
            raise AssertionError('caller tried to read past EOF')
        return data

def readline(self, length=None):
        data = io.BytesIO.readline(self, length)
        if data == b'':
            raise AssertionError('caller tried to read past EOF')
        return data

class HeaderTests(TestCase):
    def test_auto_headers(self):
        # Some headers are added automatically, but should not be added by
        # .request() if they are explicitly set.

class HeaderCountingBuffer(list):
            def __init__(self):
                self.count = {}
            def append(self, item):
                kv = item.split(b':')
                if len(kv) > 1:
                    # item is a 'Key: Value' header string
                    lcKey = kv[0].decode('ascii').lower()
                    self.count.setdefault(lcKey, 0)
                    self.count[lcKey] += 1
                list.append(self, item)

for explicit_header in True, False:
            for header in 'Content-length', 'Host', 'Accept-encoding':
                conn = client.HTTPConnection('example.com')
                conn.sock = FakeSocket('blahblahblah')
                conn._buffer = HeaderCountingBuffer()

body = 'spamspamspam'
                headers = {}
                if explicit_header:
                    headers[header] = str(len(body))
                conn.request('POST', '/', body, headers)
                self.assertEqual(conn._buffer.count[header.lower()], 1)

def test_content_length_0(self):

class ContentLengthChecker(list):
            def __init__(self):
                list.__init__(self)
                self.content_length = None
            def append(self, item):
                kv = item.split(b':', 1)
                if len(kv) > 1 and kv[0].lower() == b'content-length':
                    self.content_length = kv[1].strip()
                list.append(self, item)

# Here, we're testing that methods expecting a body get a
        # content-length set to zero if the body is empty (either None or '')
        bodies = (None, '')
        methods_with_body = ('PUT', 'POST', 'PATCH')
        for method, body in itertools.product(methods_with_body, bodies):
            conn = client.HTTPConnection('example.com')
            conn.sock = FakeSocket(None)
            conn._buffer = ContentLengthChecker()
            conn.request(method, '/', body)
            self.assertEqual(
                conn._buffer.content_length, b'0',
                'Header Content-Length incorrect on {}'.format(method)
            )

# For these methods, we make sure that content-length is not set when
        # the body is None because it might cause unexpected behaviour on the
        # server.
        methods_without_body = (
             'GET', 'CONNECT', 'DELETE', 'HEAD', 'OPTIONS', 'TRACE',
        )
        for method in methods_without_body:
            conn = client.HTTPConnection('example.com')
            conn.sock = FakeSocket(None)
            conn._buffer = ContentLengthChecker()
            conn.request(method, '/', None)
            self.assertEqual(
                conn._buffer.content_length, None,
                'Header Content-Length set for empty body on {}'.format(method)
            )

# If the body is set to '', that's considered to be "present but
        # empty" rather than "missing", so content length would be set, even
        # for methods that don't expect a body.
        for method in methods_without_body:
            conn = client.HTTPConnection('example.com')
            conn.sock = FakeSocket(None)
            conn._buffer = ContentLengthChecker()
            conn.request(method, '/', '')
            self.assertEqual(
                conn._buffer.content_length, b'0',
                'Header Content-Length incorrect on {}'.format(method)
            )

# If the body is set, make sure Content-Length is set.
        for method in itertools.chain(methods_without_body, methods_with_body):
            conn = client.HTTPConnection('example.com')
            conn.sock = FakeSocket(None)
            conn._buffer = ContentLengthChecker()
            conn.request(method, '/', ' ')
            self.assertEqual(
                conn._buffer.content_length, b'1',
                'Header Content-Length incorrect on {}'.format(method)
            )

def test_putheader(self):
        conn = client.HTTPConnection('example.com')
        conn.sock = FakeSocket(None)
        conn.putrequest('GET','/')
        conn.putheader('Content-length', 42)
        self.assertIn(b'Content-length: 42', conn._buffer)

conn.putheader('Foo', ' bar ')
        self.assertIn(b'Foo:  bar ', conn._buffer)
        conn.putheader('Bar', '\tbaz\t')
        self.assertIn(b'Bar: \tbaz\t', conn._buffer)
        conn.putheader('Authorization', 'Bearer mytoken')
        self.assertIn(b'Authorization: Bearer mytoken', conn._buffer)
        conn.putheader('IterHeader', 'IterA', 'IterB')
        self.assertIn(b'IterHeader: IterA\r\n\tIterB', conn._buffer)
        conn.putheader('LatinHeader', b'\xFF')
        self.assertIn(b'LatinHeader: \xFF', conn._buffer)
        conn.putheader('Utf8Header', b'\xc3\x80')
        self.assertIn(b'Utf8Header: \xc3\x80', conn._buffer)
        conn.putheader('C1-Control', b'next\x85line')
        self.assertIn(b'C1-Control: next\x85line', conn._buffer)
        conn.putheader('Embedded-Fold-Space', 'is\r\n allowed')
        self.assertIn(b'Embedded-Fold-Space: is\r\n allowed', conn._buffer)
        conn.putheader('Embedded-Fold-Tab', 'is\r\n\tallowed')
        self.assertIn(b'Embedded-Fold-Tab: is\r\n\tallowed', conn._buffer)
        conn.putheader('Key Space', 'value')
        self.assertIn(b'Key Space: value', conn._buffer)
        conn.putheader('KeySpace ', 'value')
        self.assertIn(b'KeySpace : value', conn._buffer)
        conn.putheader(b'Nonbreak\xa0Space', 'value')
        self.assertIn(b'Nonbreak\xa0Space: value', conn._buffer)
        conn.putheader(b'\xa0NonbreakSpace', 'value')
        self.assertIn(b'\xa0NonbreakSpace: value', conn._buffer)

def test_ipv6host_header(self):
        # Default host header on IPv6 transaction should wrapped by [] if
        # its actual IPv6 address
        expected = b'GET /foo HTTP/1.1\r\nHost: [2001::]:81\r\n' \
                   b'Accept-Encoding: identity\r\n\r\n'
        conn = client.HTTPConnection('[2001::]:81')
        sock = FakeSocket('')
        conn.sock = sock
        conn.request('GET', '/foo')
        self.assertTrue(sock.data.startswith(expected))

expected = b'GET /foo HTTP/1.1\r\nHost: [2001:102A::]\r\n' \
                   b'Accept-Encoding: identity\r\n\r\n'
        conn = client.HTTPConnection('[2001:102A::]')
        sock = FakeSocket('')
        conn.sock = sock
        conn.request('GET', '/foo')
        self.assertTrue(sock.data.startswith(expected))

def test_malformed_headers_coped_with(self):
        # Issue 19996
        body = "HTTP/1.1 200 OK\r\nFirst: val\r\n: nval\r\nSecond: val\r\n\r\n"
        sock = FakeSocket(body)
        resp = client.HTTPResponse(sock)
        resp.begin()

self.assertEqual(resp.getheader('First'), 'val')
        self.assertEqual(resp.getheader('Second'), 'val')

def test_invalid_headers(self):
        conn = client.HTTPConnection('example.com')
        conn.sock = FakeSocket('')
        conn.putrequest('GET', '/')

# http://tools.ietf.org/html/rfc7230#section-3.2.4, whitespace is no
        # longer allowed in header names
        cases = (
            (b'Invalid\r\nName', b'ValidValue'),
            (b'Invalid\rName', b'ValidValue'),
            (b'Invalid\nName', b'ValidValue'),
            (b'\r\nInvalidName', b'ValidValue'),
            (b'\rInvalidName', b'ValidValue'),
            (b'\nInvalidName', b'ValidValue'),
            (b' InvalidName', b'ValidValue'),
            (b'\tInvalidName', b'ValidValue'),
            (b'Invalid:Name', b'ValidValue'),
            (b':InvalidName', b'ValidValue'),
            (b'ValidName', b'Invalid\r\nValue'),
            (b'ValidName', b'Invalid\rValue'),
            (b'ValidName', b'Invalid\nValue'),
            (b'ValidName', b'InvalidValue\r\n'),
            (b'ValidName', b'InvalidValue\r'),
            (b'ValidName', b'InvalidValue\n'),
        )
        for name, value in cases:
            with self.subTest((name, value)):
                with self.assertRaisesRegex(ValueError, 'Invalid header'):
                    conn.putheader(name, value)

class BasicTest(TestCase):
    def test_status_lines(self):
        # Test HTTP status lines

body = "HTTP/1.1 200 Ok\r\n\r\nText"
        sock = FakeSocket(body)
        resp = client.HTTPResponse(sock)
        resp.begin()
        self.assertEqual(resp.read(0), b'')  # Issue #20007
        self.assertFalse(resp.isclosed())
        self.assertFalse(resp.closed)
        self.assertEqual(resp.read(), b"Text")
        self.assertTrue(resp.isclosed())
        self.assertFalse(resp.closed)
        resp.close()
        self.assertTrue(resp.closed)

body = "HTTP/1.1 400.100 Not Ok\r\n\r\nText"
        sock = FakeSocket(body)
        resp = client.HTTPResponse(sock)
        self.assertRaises(client.BadStatusLine, resp.begin)

def test_bad_status_repr(self):
        exc = client.BadStatusLine('')
        self.assertEqual(repr(exc), '''BadStatusLine("\'\'",)''')

def test_partial_reads(self):
        # if we have a length, the system knows when to close itself
        # same behaviour than when we read the whole thing with read()
        body = "HTTP/1.1 200 Ok\r\nContent-Length: 4\r\n\r\nText"
        sock = FakeSocket(body)
        resp = client.HTTPResponse(sock)
        resp.begin()
        self.assertEqual(resp.read(2), b'Te')
        self.assertFalse(resp.isclosed())
        self.assertEqual(resp.read(2), b'xt')
        self.assertTrue(resp.isclosed())
        self.assertFalse(resp.closed)
        resp.close()
        self.assertTrue(resp.closed)

def test_partial_readintos(self):
        # if we have a length, the system knows when to close itself
        # same behaviour than when we read the whole thing with read()
        body = "HTTP/1.1 200 Ok\r\nContent-Length: 4\r\n\r\nText"
        sock = FakeSocket(body)
        resp = client.HTTPResponse(sock)
        resp.begin()
        b = bytearray(2)
        n = resp.readinto(b)
        self.assertEqual(n, 2)
        self.assertEqual(bytes(b), b'Te')
        self.assertFalse(resp.isclosed())
        n = resp.readinto(b)
        self.assertEqual(n, 2)
        self.assertEqual(bytes(b), b'xt')
        self.assertTrue(resp.isclosed())
        self.assertFalse(resp.closed)
        resp.close()
        self.assertTrue(resp.closed)

def test_partial_reads_no_content_length(self):
        # when no length is present, the socket should be gracefully closed when
        # all data was read
        body = "HTTP/1.1 200 Ok\r\n\r\nText"
        sock = FakeSocket(body)
        resp = client.HTTPResponse(sock)
        resp.begin()
        self.assertEqual(resp.read(2), b'Te')
        self.assertFalse(resp.isclosed())
        self.assertEqual(resp.read(2), b'xt')
        self.assertEqual(resp.read(1), b'')
        self.assertTrue(resp.isclosed())
        self.assertFalse(resp.closed)
        resp.close()
        self.assertTrue(resp.closed)

def test_partial_readintos_no_content_length(self):
        # when no length is present, the socket should be gracefully closed when
        # all data was read
        body = "HTTP/1.1 200 Ok\r\n\r\nText"
        sock = FakeSocket(body)
        resp = client.HTTPResponse(sock)
        resp.begin()
        b = bytearray(2)
        n = resp.readinto(b)
        self.assertEqual(n, 2)
        self.assertEqual(bytes(b), b'Te')
        self.assertFalse(resp.isclosed())
        n = resp.readinto(b)
        self.assertEqual(n, 2)
        self.assertEqual(bytes(b), b'xt')
        n = resp.readinto(b)
        self.assertEqual(n, 0)
        self.assertTrue(resp.isclosed())

def test_partial_reads_incomplete_body(self):
        # if the server shuts down the connection before the whole
        # content-length is delivered, the socket is gracefully closed
        body = "HTTP/1.1 200 Ok\r\nContent-Length: 10\r\n\r\nText"
        sock = FakeSocket(body)
        resp = client.HTTPResponse(sock)
        resp.begin()
        self.assertEqual(resp.read(2), b'Te')
        self.assertFalse(resp.isclosed())
        self.assertEqual(resp.read(2), b'xt')
        self.assertEqual(resp.read(1), b'')
        self.assertTrue(resp.isclosed())

def test_partial_readintos_incomplete_body(self):
        # if the server shuts down the connection before the whole
        # content-length is delivered, the socket is gracefully closed
        body = "HTTP/1.1 200 Ok\r\nContent-Length: 10\r\n\r\nText"
        sock = FakeSocket(body)
        resp = client.HTTPResponse(sock)
        resp.begin()
        b = bytearray(2)
        n = resp.readinto(b)
        self.assertEqual(n, 2)
        self.assertEqual(bytes(b), b'Te')
        self.assertFalse(resp.isclosed())
        n = resp.readinto(b)
        self.assertEqual(n, 2)
        self.assertEqual(bytes(b), b'xt')
        n = resp.readinto(b)
        self.assertEqual(n, 0)
        self.assertTrue(resp.isclosed())
        self.assertFalse(resp.closed)
        resp.close()
        self.assertTrue(resp.closed)

def test_host_port(self):
        # Check invalid host_port

for hp in ("www.python.org:abc", "user:password@www.python.org"):
            self.assertRaises(client.InvalidURL, client.HTTPConnection, hp)

for hp, h, p in (("[fe80::207:e9ff:fe9b]:8000",
                          "fe80::207:e9ff:fe9b", 8000),
                         ("www.python.org:80", "www.python.org", 80),
                         ("www.python.org:", "www.python.org", 80),
                         ("www.python.org", "www.python.org", 80),
                         ("[fe80::207:e9ff:fe9b]", "fe80::207:e9ff:fe9b", 80),
                         ("[fe80::207:e9ff:fe9b]:", "fe80::207:e9ff:fe9b", 80)):
            c = client.HTTPConnection(hp)
            self.assertEqual(h, c.host)
            self.assertEqual(p, c.port)

def test_response_headers(self):
        # test response with multiple message headers with the same field name.
        text = ('HTTP/1.1 200 OK\r\n'
                'Set-Cookie: Customer="WILE_E_COYOTE"; '
                'Version="1"; Path="/acme"\r\n'
                'Set-Cookie: Part_Number="Rocket_Launcher_0001"; Version="1";'
                ' Path="/acme"\r\n'
                '\r\n'
                'No body\r\n')
        hdr = ('Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"'
               ', '
               'Part_Number="Rocket_Launcher_0001"; Version="1"; Path="/acme"')
        s = FakeSocket(text)
        r = client.HTTPResponse(s)
        r.begin()
        cookies = r.getheader("Set-Cookie")
        self.assertEqual(cookies, hdr)

def test_read_head(self):
        # Test that the library doesn't attempt to read any data
        # from a HEAD request.  (Tickles SF bug #622042.)
        sock = FakeSocket(
            'HTTP/1.1 200 OK\r\n'
            'Content-Length: 14432\r\n'
            '\r\n',
            NoEOFBytesIO)
        resp = client.HTTPResponse(sock, method="HEAD")
        resp.begin()
        if resp.read():
            self.fail("Did not expect response from HEAD request")

def test_readinto_head(self):
        # Test that the library doesn't attempt to read any data
        # from a HEAD request.  (Tickles SF bug #622042.)
        sock = FakeSocket(
            'HTTP/1.1 200 OK\r\n'
            'Content-Length: 14432\r\n'
            '\r\n',
            NoEOFBytesIO)
        resp = client.HTTPResponse(sock, method="HEAD")
        resp.begin()
        b = bytearray(5)
        if resp.readinto(b) != 0:
            self.fail("Did not expect response from HEAD request")
        self.assertEqual(bytes(b), b'\x00'*5)

def test_too_many_headers(self):
        headers = '\r\n'.join('Header%d: foo' % i
                              for i in range(client._MAXHEADERS + 1)) + '\r\n'
        text = ('HTTP/1.1 200 OK\r\n' + headers)
        s = FakeSocket(text)
        r = client.HTTPResponse(s)
        self.assertRaisesRegex(client.HTTPException,
                               r"got more than \d+ headers", r.begin)

def test_send_file(self):
        expected = (b'GET /foo HTTP/1.1\r\nHost: example.com\r\n'
                    b'Accept-Encoding: identity\r\nContent-Length:')

with open(__file__, 'rb') as body:
            conn = client.HTTPConnection('example.com')
            sock = FakeSocket(body)
            conn.sock = sock
            conn.request('GET', '/foo', body)
            self.assertTrue(sock.data.startswith(expected), '%r != %r' %
                    (sock.data[:len(expected)], expected))

def test_send(self):
        expected = b'this is a test this is only a test'
        conn = client.HTTPConnection('example.com')
        sock = FakeSocket(None)
        conn.sock = sock
        conn.send(expected)
        self.assertEqual(expected, sock.data)
        sock.data = b''
        conn.send(array.array('b', expected))
        self.assertEqual(expected, sock.data)
        sock.data = b''
        conn.send(io.BytesIO(expected))
        self.assertEqual(expected, sock.data)

def test_send_updating_file(self):
        def data():
            yield 'data'
            yield None
            yield 'data_two'

class UpdatingFile():
            mode = 'r'
            d = data()
            def read(self, blocksize=-1):
                return self.d.__next__()

expected = b'data'

conn = client.HTTPConnection('example.com')
        sock = FakeSocket("")
        conn.sock = sock
        conn.send(UpdatingFile())
        self.assertEqual(sock.data, expected)

def test_send_iter(self):
        expected = b'GET /foo HTTP/1.1\r\nHost: example.com\r\n' \
                   b'Accept-Encoding: identity\r\nContent-Length: 11\r\n' \
                   b'\r\nonetwothree'

def body():
            yield b"one"
            yield b"two"
            yield b"three"

conn = client.HTTPConnection('example.com')
        sock = FakeSocket("")
        conn.sock = sock
        conn.request('GET', '/foo', body(), {'Content-Length': '11'})
        self.assertEqual(sock.data, expected)

def test_send_type_error(self):
        # See: Issue #12676
        conn = client.HTTPConnection('example.com')
        conn.sock = FakeSocket('')
        with self.assertRaises(TypeError):
            conn.request('POST', 'test', conn)

def test_chunked(self):
        chunked_start = (
            'HTTP/1.1 200 OK\r\n'
            'Transfer-Encoding: chunked\r\n\r\n'
            'a\r\n'
            'hello worl\r\n'
            '3\r\n'
            'd! \r\n'
            '8\r\n'
            'and now \r\n'
            '22\r\n'
            'for something completely different\r\n'
        )
        expected = b'hello world! and now for something completely different'
        sock = FakeSocket(chunked_start + '0\r\n')
        resp = client.HTTPResponse(sock, method="GET")
        resp.begin()
        self.assertEqual(resp.read(), expected)
        resp.close()

# Various read sizes
        for n in range(1, 12):
            sock = FakeSocket(chunked_start + '0\r\n')
            resp = client.HTTPResponse(sock, method="GET")
            resp.begin()
            self.assertEqual(resp.read(n) + resp.read(n) + resp.read(), expected)
            resp.close()

for x in ('', 'foo\r\n'):
            sock = FakeSocket(chunked_start + x)
            resp = client.HTTPResponse(sock, method="GET")
            resp.begin()
            try:
                resp.read()
            except client.IncompleteRead as i:
                self.assertEqual(i.partial, expected)
                expected_message = 'IncompleteRead(%d bytes read)' % len(expected)
                self.assertEqual(repr(i), expected_message)
                self.assertEqual(str(i), expected_message)
            else:
                self.fail('IncompleteRead expected')
            finally:
                resp.close()

def test_readinto_chunked(self):
        chunked_start = (
            'HTTP/1.1 200 OK\r\n'
            'Transfer-Encoding: chunked\r\n\r\n'
            'a\r\n'
            'hello worl\r\n'
            '3\r\n'
            'd! \r\n'
            '8\r\n'
            'and now \r\n'
            '22\r\n'
            'for something completely different\r\n'
        )
        expected = b'hello world! and now for something completely different'
        nexpected = len(expected)
        b = bytearray(128)

sock = FakeSocket(chunked_start + '0\r\n')
        resp = client.HTTPResponse(sock, method="GET")
        resp.begin()
        n = resp.readinto(b)
        self.assertEqual(b[:nexpected], expected)
        self.assertEqual(n, nexpected)
        resp.close()

# Various read sizes
        for n in range(1, 12):
            sock = FakeSocket(chunked_start + '0\r\n')
            resp = client.HTTPResponse(sock, method="GET")
            resp.begin()
            m = memoryview(b)
            i = resp.readinto(m[0:n])
            i += resp.readinto(m[i:n + i])
            i += resp.readinto(m[i:])
            self.assertEqual(b[:nexpected], expected)
            self.assertEqual(i, nexpected)
            resp.close()

for x in ('', 'foo\r\n'):
            sock = FakeSocket(chunked_start + x)
            resp = client.HTTPResponse(sock, method="GET")
            resp.begin()
            try:
                n = resp.readinto(b)
            except client.IncompleteRead as i:
                self.assertEqual(i.partial, expected)
                expected_message = 'IncompleteRead(%d bytes read)' % len(expected)
                self.assertEqual(repr(i), expected_message)
                self.assertEqual(str(i), expected_message)
            else:
                self.fail('IncompleteRead expected')
            finally:
                resp.close()

def test_chunked_head(self):
        chunked_start = (
            'HTTP/1.1 200 OK\r\n'
            'Transfer-Encoding: chunked\r\n\r\n'
            'a\r\n'
            'hello world\r\n'
            '1\r\n'
            'd\r\n'
        )
        sock = FakeSocket(chunked_start + '0\r\n')
        resp = client.HTTPResponse(sock, method="HEAD")
        resp.begin()
        self.assertEqual(resp.read(), b'')
        self.assertEqual(resp.status, 200)
        self.assertEqual(resp.reason, 'OK')
        self.assertTrue(resp.isclosed())
        self.assertFalse(resp.closed)
        resp.close()
        self.assertTrue(resp.closed)

def test_readinto_chunked_head(self):
        chunked_start = (
            'HTTP/1.1 200 OK\r\n'
            'Transfer-Encoding: chunked\r\n\r\n'
            'a\r\n'
            'hello world\r\n'
            '1\r\n'
            'd\r\n'
        )
        sock = FakeSocket(chunked_start + '0\r\n')
        resp = client.HTTPResponse(sock, method="HEAD")
        resp.begin()
        b = bytearray(5)
        n = resp.readinto(b)
        self.assertEqual(n, 0)
        self.assertEqual(bytes(b), b'\x00'*5)
        self.assertEqual(resp.status, 200)
        self.assertEqual(resp.reason, 'OK')
        self.assertTrue(resp.isclosed())
        self.assertFalse(resp.closed)
        resp.close()
        self.assertTrue(resp.closed)

def test_negative_content_length(self):
        sock = FakeSocket(
            'HTTP/1.1 200 OK\r\nContent-Length: -1\r\n\r\nHello\r\n')
        resp = client.HTTPResponse(sock, method="GET")
        resp.begin()
        self.assertEqual(resp.read(), b'Hello\r\n')
        self.assertTrue(resp.isclosed())

def test_incomplete_read(self):
        sock = FakeSocket('HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\nHello\r\n')
        resp = client.HTTPResponse(sock, method="GET")
        resp.begin()
        try:
            resp.read()
        except client.IncompleteRead as i:
            self.assertEqual(i.partial, b'Hello\r\n')
            self.assertEqual(repr(i),
                             "IncompleteRead(7 bytes read, 3 more expected)")
            self.assertEqual(str(i),
                             "IncompleteRead(7 bytes read, 3 more expected)")
            self.assertTrue(resp.isclosed())
        else:
            self.fail('IncompleteRead expected')

def test_epipe(self):
        sock = EPipeSocket(
            "HTTP/1.0 401 Authorization Required\r\n"
            "Content-type: text/html\r\n"
            "WWW-Authenticate: Basic realm=\"example\"\r\n",
            b"Content-Length")
        conn = client.HTTPConnection("example.com")
        conn.sock = sock
        self.assertRaises(OSError,
                          lambda: conn.request("PUT", "/url", "body"))
        resp = conn.getresponse()
        self.assertEqual(401, resp.status)
        self.assertEqual("Basic realm=\"example\"",
                         resp.getheader("www-authenticate"))

# Test lines overflowing the max line size (_MAXLINE in http.client)

def test_overflowing_status_line(self):
        body = "HTTP/1.1 200 Ok" + "k" * 65536 + "\r\n"
        resp = client.HTTPResponse(FakeSocket(body))
        self.assertRaises((client.LineTooLong, client.BadStatusLine), resp.begin)

def test_overflowing_header_line(self):
        body = (
            'HTTP/1.1 200 OK\r\n'
            'X-Foo: bar' + 'r' * 65536 + '\r\n\r\n'
        )
        resp = client.HTTPResponse(FakeSocket(body))
        self.assertRaises(client.LineTooLong, resp.begin)

def test_overflowing_chunked_line(self):
        body = (
            'HTTP/1.1 200 OK\r\n'
            'Transfer-Encoding: chunked\r\n\r\n'
            + '0' * 65536 + 'a\r\n'
            'hello world\r\n'
            '0\r\n'
        )
        resp = client.HTTPResponse(FakeSocket(body))
        resp.begin()
        self.assertRaises(client.LineTooLong, resp.read)

def test_early_eof(self):
        # Test httpresponse with no \r\n termination,
        body = "HTTP/1.1 200 Ok"
        sock = FakeSocket(body)
        resp = client.HTTPResponse(sock)
        resp.begin()
        self.assertEqual(resp.read(), b'')
        self.assertTrue(resp.isclosed())
        self.assertFalse(resp.closed)
        resp.close()
        self.assertTrue(resp.closed)

def test_delayed_ack_opt(self):
        # Test that Nagle/delayed_ack optimistaion works correctly.

# For small payloads, it should coalesce the body with
        # headers, resulting in a single sendall() call
        conn = client.HTTPConnection('example.com')
        sock = FakeSocket(None)
        conn.sock = sock
        body = b'x' * (conn.mss - 1)
        conn.request('POST', '/', body)
        self.assertEqual(sock.sendall_calls, 1)

# For large payloads, it should send the headers and
        # then the body, resulting in more than one sendall()
        # call
        conn = client.HTTPConnection('example.com')
        sock = FakeSocket(None)
        conn.sock = sock
        body = b'x' * conn.mss
        conn.request('POST', '/', body)
        self.assertGreater(sock.sendall_calls, 1)

def test_error_leak(self):
        # Test that the socket is not leaked if getresponse() fails
        conn = client.HTTPConnection('example.com')
        response = None
        class Response(client.HTTPResponse):
            def __init__(self, *pos, **kw):
                nonlocal response
                response = self  # Avoid garbage collector closing the socket
                client.HTTPResponse.__init__(self, *pos, **kw)
        conn.response_class = Response
        conn.sock = FakeSocket('')  # Emulate server dropping connection
        conn.request('GET', '/')
        self.assertRaises(client.BadStatusLine, conn.getresponse)
        self.assertTrue(response.closed)
        self.assertTrue(conn.sock.file_closed)

class OfflineTest(TestCase):
    def test_all(self):
        # Documented objects defined in the module should be in __all__
        expected = {"responses"}  # White-list documented dict() object
        # HTTPMessage, parse_headers(), and the HTTP status code constants are
        # intentionally omitted for simplicity
        blacklist = {"HTTPMessage", "parse_headers"}
        for name in dir(client):
            if name in blacklist:
                continue
            module_object = getattr(client, name)
            if getattr(module_object, "__module__", None) == "http.client":
                expected.add(name)
        self.assertCountEqual(client.__all__, expected)

def test_responses(self):
        self.assertEqual(client.responses[client.NOT_FOUND], "Not Found")

class SourceAddressTest(TestCase):
    def setUp(self):
        self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.port = support.bind_port(self.serv)
        self.source_port = support.find_unused_port()
        self.serv.listen(5)
        self.conn = None

def tearDown(self):
        if self.conn:
            self.conn.close()
            self.conn = None
        self.serv.close()
        self.serv = None

def testHTTPConnectionSourceAddress(self):
        self.conn = client.HTTPConnection(HOST, self.port,
                source_address=('', self.source_port))
        self.conn.connect()
        self.assertEqual(self.conn.sock.getsockname()[1], self.source_port)

@unittest.skipIf(not hasattr(client, 'HTTPSConnection'),
                     'http.client.HTTPSConnection not defined')
    def testHTTPSConnectionSourceAddress(self):
        self.conn = client.HTTPSConnection(HOST, self.port,
                source_address=('', self.source_port))
        # We don't test anything here other the constructor not barfing as
        # this code doesn't deal with setting up an active running SSL server
        # for an ssl_wrapped connect() to actually return from.

class TimeoutTest(TestCase):
    PORT = None

def setUp(self):
        self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        TimeoutTest.PORT = support.bind_port(self.serv)
        self.serv.listen(5)

def tearDown(self):
        self.serv.close()
        self.serv = None

def testTimeoutAttribute(self):
        # This will prove that the timeout gets through HTTPConnection
        # and into the socket.

# default -- use global socket timeout
        self.assertIsNone(socket.getdefaulttimeout())
        socket.setdefaulttimeout(30)
        try:
            httpConn = client.HTTPConnection(HOST, TimeoutTest.PORT)
            httpConn.connect()
        finally:
            socket.setdefaulttimeout(None)
        self.assertEqual(httpConn.sock.gettimeout(), 30)
        httpConn.close()

# no timeout -- do not use global socket default
        self.assertIsNone(socket.getdefaulttimeout())
        socket.setdefaulttimeout(30)
        try:
            httpConn = client.HTTPConnection(HOST, TimeoutTest.PORT,
                                              timeout=None)
            httpConn.connect()
        finally:
            socket.setdefaulttimeout(None)
        self.assertEqual(httpConn.sock.gettimeout(), None)
        httpConn.close()

# a value
        httpConn = client.HTTPConnection(HOST, TimeoutTest.PORT, timeout=30)
        httpConn.connect()
        self.assertEqual(httpConn.sock.gettimeout(), 30)
        httpConn.close()

class HTTPSTest(TestCase):

def setUp(self):
        if not hasattr(client, 'HTTPSConnection'):
            self.skipTest('ssl support required')

def make_server(self, certfile):
        from test.ssl_servers import make_https_server
        return make_https_server(self, certfile=certfile)

def test_attributes(self):
        # simple test to check it's storing the timeout
        h = client.HTTPSConnection(HOST, TimeoutTest.PORT, timeout=30)
        self.assertEqual(h.timeout, 30)

def test_networked(self):
        # Default settings: requires a valid cert from a trusted CA
        import ssl
        support.requires('network')
        with support.transient_internet('self-signed.pythontest.net'):
            h = client.HTTPSConnection('self-signed.pythontest.net', 443)
            with self.assertRaises(ssl.SSLError) as exc_info:
                h.request('GET', '/')
            self.assertEqual(exc_info.exception.reason, 'CERTIFICATE_VERIFY_FAILED')

def test_networked_noverification(self):
        # Switch off cert verification
        import ssl
        support.requires('network')
        with support.transient_internet('self-signed.pythontest.net'):
            context = ssl._create_unverified_context()
            h = client.HTTPSConnection('self-signed.pythontest.net', 443,
                                       context=context)
            h.request('GET', '/')
            resp = h.getresponse()
            h.close()
            self.assertIn('nginx', resp.getheader('server'))

@support.system_must_validate_cert
    def test_networked_trusted_by_default_cert(self):
        # Default settings: requires a valid cert from a trusted CA
        support.requires('network')
        with support.transient_internet('www.python.org'):
            h = client.HTTPSConnection('www.python.org', 443)
            h.request('GET', '/')
            resp = h.getresponse()
            content_type = resp.getheader('content-type')
            h.close()
            self.assertIn('text/html', content_type)

def test_networked_good_cert(self):
        # We feed the server's cert as a validating cert
        import ssl
        support.requires('network')
        with support.transient_internet('self-signed.pythontest.net'):
            context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
            context.verify_mode = ssl.CERT_REQUIRED
            context.load_verify_locations(CERT_selfsigned_pythontestdotnet)
            h = client.HTTPSConnection('self-signed.pythontest.net', 443, context=context)
            h.request('GET', '/')
            resp = h.getresponse()
            server_string = resp.getheader('server')
            h.close()
            self.assertIn('nginx', server_string)

def test_networked_bad_cert(self):
        # We feed a "CA" cert that is unrelated to the server's cert
        import ssl
        support.requires('network')
        with support.transient_internet('self-signed.pythontest.net'):
            context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
            context.verify_mode = ssl.CERT_REQUIRED
            context.load_verify_locations(CERT_localhost)
            h = client.HTTPSConnection('self-signed.pythontest.net', 443, context=context)
            with self.assertRaises(ssl.SSLError) as exc_info:
                h.request('GET', '/')
            self.assertEqual(exc_info.exception.reason, 'CERTIFICATE_VERIFY_FAILED')

def test_local_unknown_cert(self):
        # The custom cert isn't known to the default trust bundle
        import ssl
        server = self.make_server(CERT_localhost)
        h = client.HTTPSConnection('localhost', server.port)
        with self.assertRaises(ssl.SSLError) as exc_info:
            h.request('GET', '/')
        self.assertEqual(exc_info.exception.reason, 'CERTIFICATE_VERIFY_FAILED')

def test_local_good_hostname(self):
        # The (valid) cert validates the HTTP hostname
        import ssl
        server = self.make_server(CERT_localhost)
        context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
        context.verify_mode = ssl.CERT_REQUIRED
        context.load_verify_locations(CERT_localhost)
        h = client.HTTPSConnection('localhost', server.port, context=context)
        h.request('GET', '/nonexistent')
        resp = h.getresponse()
        self.assertEqual(resp.status, 404)

def test_local_bad_hostname(self):
        # The (valid) cert doesn't validate the HTTP hostname
        import ssl
        server = self.make_server(CERT_fakehostname)
        context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
        context.verify_mode = ssl.CERT_REQUIRED
        context.check_hostname = True
        context.load_verify_locations(CERT_fakehostname)
        h = client.HTTPSConnection('localhost', server.port, context=context)
        with self.assertRaises(ssl.CertificateError):
            h.request('GET', '/')
        # Same with explicit check_hostname=True
        h = client.HTTPSConnection('localhost', server.port, context=context,
                                   check_hostname=True)
        with self.assertRaises(ssl.CertificateError):
            h.request('GET', '/')
        # With check_hostname=False, the mismatching is ignored
        context.check_hostname = False
        h = client.HTTPSConnection('localhost', server.port, context=context,
                                   check_hostname=False)
        h.request('GET', '/nonexistent')
        resp = h.getresponse()
        self.assertEqual(resp.status, 404)
        # The context's check_hostname setting is used if one isn't passed to
        # HTTPSConnection.
        context.check_hostname = False
        h = client.HTTPSConnection('localhost', server.port, context=context)
        h.request('GET', '/nonexistent')
        self.assertEqual(h.getresponse().status, 404)
        # Passing check_hostname to HTTPSConnection should override the
        # context's setting.
        h = client.HTTPSConnection('localhost', server.port, context=context,
                                   check_hostname=True)
        with self.assertRaises(ssl.CertificateError):
            h.request('GET', '/')

@unittest.skipIf(not hasattr(client, 'HTTPSConnection'),
                     'http.client.HTTPSConnection not available')
    def test_host_port(self):
        # Check invalid host_port

for hp in ("www.python.org:abc", "user:password@www.python.org"):
            self.assertRaises(client.InvalidURL, client.HTTPSConnection, hp)

for hp, h, p in (("[fe80::207:e9ff:fe9b]:8000",
                          "fe80::207:e9ff:fe9b", 8000),
                         ("www.python.org:443", "www.python.org", 443),
                         ("www.python.org:", "www.python.org", 443),
                         ("www.python.org", "www.python.org", 443),
                         ("[fe80::207:e9ff:fe9b]", "fe80::207:e9ff:fe9b", 443),
                         ("[fe80::207:e9ff:fe9b]:", "fe80::207:e9ff:fe9b",
                             443)):
            c = client.HTTPSConnection(hp)
            self.assertEqual(h, c.host)
            self.assertEqual(p, c.port)

class RequestBodyTest(TestCase):
    """Test cases where a request includes a message body."""

def setUp(self):
        self.conn = client.HTTPConnection('example.com')
        self.conn.sock = self.sock = FakeSocket("")
        self.conn.sock = self.sock

def get_headers_and_fp(self):
        f = io.BytesIO(self.sock.data)
        f.readline()  # read the request line
        message = client.parse_headers(f)
        return message, f

def test_manual_content_length(self):
        # Set an incorrect content-length so that we can verify that
        # it will not be over-ridden by the library.
        self.conn.request("PUT", "/url", "body",
                          {"Content-Length": "42"})
        message, f = self.get_headers_and_fp()
        self.assertEqual("42", message.get("content-length"))
        self.assertEqual(4, len(f.read()))

def test_ascii_body(self):
        self.conn.request("PUT", "/url", "body")
        message, f = self.get_headers_and_fp()
        self.assertEqual("text/plain", message.get_content_type())
        self.assertIsNone(message.get_charset())
        self.assertEqual("4", message.get("content-length"))
        self.assertEqual(b'body', f.read())

def test_latin1_body(self):
        self.conn.request("PUT", "/url", "body\xc1")
        message, f = self.get_headers_and_fp()
        self.assertEqual("text/plain", message.get_content_type())
        self.assertIsNone(message.get_charset())
        self.assertEqual("5", message.get("content-length"))
        self.assertEqual(b'body\xc1', f.read())

def test_bytes_body(self):
        self.conn.request("PUT", "/url", b"body\xc1")
        message, f = self.get_headers_and_fp()
        self.assertEqual("text/plain", message.get_content_type())
        self.assertIsNone(message.get_charset())
        self.assertEqual("5", message.get("content-length"))
        self.assertEqual(b'body\xc1', f.read())

def test_file_body(self):
        self.addCleanup(support.unlink, support.TESTFN)
        with open(support.TESTFN, "w") as f:
            f.write("body")
        with open(support.TESTFN) as f:
            self.conn.request("PUT", "/url", f)
            message, f = self.get_headers_and_fp()
            self.assertEqual("text/plain", message.get_content_type())
            self.assertIsNone(message.get_charset())
            self.assertEqual("4", message.get("content-length"))
            self.assertEqual(b'body', f.read())

def test_binary_file_body(self):
        self.addCleanup(support.unlink, support.TESTFN)
        with open(support.TESTFN, "wb") as f:
            f.write(b"body\xc1")
        with open(support.TESTFN, "rb") as f:
            self.conn.request("PUT", "/url", f)
            message, f = self.get_headers_and_fp()
            self.assertEqual("text/plain", message.get_content_type())
            self.assertIsNone(message.get_charset())
            self.assertEqual("5", message.get("content-length"))
            self.assertEqual(b'body\xc1', f.read())

class HTTPResponseTest(TestCase):

def setUp(self):
        body = "HTTP/1.1 200 Ok\r\nMy-Header: first-value\r\nMy-Header: \
                second-value\r\n\r\nText"
        sock = FakeSocket(body)
        self.resp = client.HTTPResponse(sock)
        self.resp.begin()

def test_getting_header(self):
        header = self.resp.getheader('My-Header')
        self.assertEqual(header, 'first-value, second-value')

header = self.resp.getheader('My-Header', 'some default')
        self.assertEqual(header, 'first-value, second-value')

def test_getting_nonexistent_header_with_string_default(self):
        header = self.resp.getheader('No-Such-Header', 'default-value')
        self.assertEqual(header, 'default-value')

def test_getting_nonexistent_header_with_iterable_default(self):
        header = self.resp.getheader('No-Such-Header', ['default', 'values'])
        self.assertEqual(header, 'default, values')

header = self.resp.getheader('No-Such-Header', ('default', 'values'))
        self.assertEqual(header, 'default, values')

def test_getting_nonexistent_header_without_default(self):
        header = self.resp.getheader('No-Such-Header')
        self.assertEqual(header, None)

def test_getting_header_defaultint(self):
        header = self.resp.getheader('No-Such-Header',default=42)
        self.assertEqual(header, 42)

class TunnelTests(TestCase):
    def setUp(self):
        response_text = (
            'HTTP/1.0 200 OK\r\n\r\n' # Reply to CONNECT
            'HTTP/1.1 200 OK\r\n' # Reply to HEAD
            'Content-Length: 42\r\n\r\n'
        )

def create_connection(address, timeout=None, source_address=None):
            return FakeSocket(response_text, host=address[0], port=address[1])

self.host = 'proxy.com'
        self.conn = client.HTTPConnection(self.host)
        self.conn._create_connection = create_connection

def tearDown(self):
        self.conn.close()

def test_set_tunnel_host_port_headers(self):
        tunnel_host = 'destination.com'
        tunnel_port = 8888
        tunnel_headers = {'User-Agent': 'Mozilla/5.0 (compatible, MSIE 11)'}
        self.conn.set_tunnel(tunnel_host, port=tunnel_port,
                             headers=tunnel_headers)
        self.conn.request('HEAD', '/', '')
        self.assertEqual(self.conn.sock.host, self.host)
        self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
        self.assertEqual(self.conn._tunnel_host, tunnel_host)
        self.assertEqual(self.conn._tunnel_port, tunnel_port)
        self.assertEqual(self.conn._tunnel_headers, tunnel_headers)

def test_disallow_set_tunnel_after_connect(self):
        # Once connected, we shouldn't be able to tunnel anymore
        self.conn.connect()
        self.assertRaises(RuntimeError, self.conn.set_tunnel,
                          'destination.com')

def test_connect_with_tunnel(self):
        self.conn.set_tunnel('destination.com')
        self.conn.request('HEAD', '/', '')
        self.assertEqual(self.conn.sock.host, self.host)
        self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
        self.assertIn(b'CONNECT destination.com', self.conn.sock.data)
        # issue22095
        self.assertNotIn(b'Host: destination.com:None', self.conn.sock.data)
        self.assertIn(b'Host: destination.com', self.conn.sock.data)

# This test should be removed when CONNECT gets the HTTP/1.1 blessing
        self.assertNotIn(b'Host: proxy.com', self.conn.sock.data)

def test_connect_put_request(self):
        self.conn.set_tunnel('destination.com')
        self.conn.request('PUT', '/', '')
        self.assertEqual(self.conn.sock.host, self.host)
        self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
        self.assertIn(b'CONNECT destination.com', self.conn.sock.data)
        self.assertIn(b'Host: destination.com', self.conn.sock.data)

@support.reap_threads
def test_main(verbose=None):
    support.run_unittest(HeaderTests, OfflineTest, BasicTest, TimeoutTest,
                         HTTPSTest, RequestBodyTest, SourceAddressTest,
                         HTTPResponseTest, TunnelTests)

if __name__ == '__main__':
    test_main()