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
namespace_pkgs	[ 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_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--	2017-09-19 12:02
Sine-1000Hz-300ms.aif	60.25 KB	-rw-r--r--	2017-09-19 12:02
__init__.py	47 B	-rw-r--r--	2024-04-17 20:28
__main__.py	474 B	-rw-r--r--	2024-04-17 20:28
audiotests.py	9.34 KB	-rw-r--r--	2024-04-17 20:28
autotest.py	211 B	-rw-r--r--	2024-04-17 20:28
bad_coding.py	24 B	-rw-r--r--	2024-04-17 20:28
bad_coding2.py	30 B	-rw-r--r--	2024-04-17 20:28
badcert.pem	1.88 KB	-rw-r--r--	2017-09-19 12:02
badkey.pem	2.11 KB	-rw-r--r--	2017-09-19 12:02
badsyntax_3131.py	32 B	-rw-r--r--	2024-04-17 20:28
badsyntax_future3.py	172 B	-rw-r--r--	2024-04-17 20:28
badsyntax_future4.py	153 B	-rw-r--r--	2024-04-17 20:28
badsyntax_future5.py	184 B	-rw-r--r--	2024-04-17 20:28
badsyntax_future6.py	161 B	-rw-r--r--	2024-04-17 20:28
badsyntax_future7.py	196 B	-rw-r--r--	2024-04-17 20:28
badsyntax_future8.py	122 B	-rw-r--r--	2024-04-17 20:28
badsyntax_future9.py	142 B	-rw-r--r--	2024-04-17 20:28
badsyntax_pep3120.py	14 B	-rw-r--r--	2024-04-17 20:28
buffer_tests.py	10.79 KB	-rw-r--r--	2024-04-17 20:28
cfgparser.1	21 B	-rw-r--r--	2017-09-19 12:02
cfgparser.2	19.02 KB	-rw-r--r--	2017-09-19 12:02
cfgparser.3	1.55 KB	-rw-r--r--	2017-09-19 12:02
check_soundcard.vbs	411 B	-rw-r--r--	2017-09-19 12:02
cmath_testcases.txt	133.86 KB	-rw-r--r--	2017-09-19 12:02
coding20731.py	18 B	-rw-r--r--	2024-04-17 20:28
curses_tests.py	1.22 KB	-rwxr-xr-x	2024-04-17 20:28
datetimetester.py	146.82 KB	-rw-r--r--	2024-04-17 20:28
dh1024.pem	300 B	-rw-r--r--	2017-09-19 12:02
dis_module.py	76 B	-rw-r--r--	2024-04-17 20:28
doctest_aliases.py	240 B	-rw-r--r--	2024-04-17 20:28
double_const.py	1.18 KB	-rw-r--r--	2024-04-17 20:28
empty.vbs	70 B	-rw-r--r--	2017-09-19 12:02
exception_hierarchy.txt	1.69 KB	-rw-r--r--	2017-09-19 12:02
floating_points.txt	15.92 KB	-rw-r--r--	2017-09-19 12:02
fork_wait.py	2.1 KB	-rw-r--r--	2024-04-17 20:28
formatfloat_testcases.txt	7.45 KB	-rw-r--r--	2017-09-19 12:02
future_test1.py	229 B	-rw-r--r--	2024-04-17 20:28
future_test2.py	149 B	-rw-r--r--	2024-04-17 20:28
gdb_sample.py	153 B	-rw-r--r--	2024-04-17 20:28
ieee754.txt	3.21 KB	-rw-r--r--	2017-09-19 12:02
inspect_fodder.py	854 B	-rw-r--r--	2024-04-17 20:28
inspect_fodder2.py	1.39 KB	-rw-r--r--	2024-04-17 20:28
keycert.passwd.pem	1.79 KB	-rw-r--r--	2017-09-19 12:02
keycert.pem	1.74 KB	-rw-r--r--	2017-09-19 12:02
keycert2.pem	1.75 KB	-rw-r--r--	2017-09-19 12:02
list_tests.py	17.26 KB	-rw-r--r--	2024-04-17 20:28
lock_tests.py	25.47 KB	-rw-r--r--	2024-04-17 20:28
mailcap.txt	1.24 KB	-rw-r--r--	2017-09-19 12:02
make_ssl_certs.py	1.84 KB	-rw-r--r--	2024-04-17 20:28
mapping_tests.py	21.5 KB	-rw-r--r--	2024-04-17 20:28
math_testcases.txt	23.19 KB	-rw-r--r--	2017-09-19 12:02
memory_watchdog.py	859 B	-rw-r--r--	2024-04-17 20:28
mime.types	47.37 KB	-rw-r--r--	2017-09-19 12:02
mock_socket.py	3.32 KB	-rw-r--r--	2024-04-17 20:28
mp_fork_bomb.py	323 B	-rw-r--r--	2024-04-17 20:28
multibytecodec_support.py	14.25 KB	-rw-r--r--	2024-04-17 20:28
nokia.pem	1.88 KB	-rw-r--r--	2017-09-19 12:02
nullbytecert.pem	5.31 KB	-rw-r--r--	2017-09-19 12:02
nullcert.pem	0 B	-rw-r--r--	2017-09-19 12:02
outstanding_bugs.py	370 B	-rw-r--r--	2024-04-17 20:28
pickletester.py	60.31 KB	-rw-r--r--	2024-04-17 20:28
profilee.py	2.97 KB	-rw-r--r--	2024-04-17 20:28
pstats.pck	65.05 KB	-rw-r--r--	2017-09-19 12:02
pyclbr_input.py	648 B	-rw-r--r--	2024-04-17 20:28
pydoc_mod.py	461 B	-rw-r--r--	2024-04-17 20:28
pydocfodder.py	6.18 KB	-rw-r--r--	2024-04-17 20:28
pystone.py	7.22 KB	-rwxr-xr-x	2024-04-17 20:28
randv2_32.pck	7.34 KB	-rw-r--r--	2017-09-19 12:02
randv2_64.pck	7.19 KB	-rw-r--r--	2017-09-19 12:02
randv3.pck	7.82 KB	-rw-r--r--	2017-09-19 12:02
re_tests.py	31.06 KB	-rwxr-xr-x	2024-04-17 20:28
regrtest.py	63.54 KB	-rwxr-xr-x	2024-04-17 20:28
relimport.py	27 B	-rw-r--r--	2024-04-17 20:28
reperf.py	538 B	-rw-r--r--	2024-04-17 20:28
sample_doctest.py	1.02 KB	-rw-r--r--	2024-04-17 20:28
sample_doctest_no_docstrings.py	227 B	-rw-r--r--	2024-04-17 20:28
sample_doctest_no_doctests.py	269 B	-rw-r--r--	2024-04-17 20:28
script_helper.py	5.22 KB	-rw-r--r--	2024-04-17 20:28
selfsigned_pythontestdotnet.pem	956 B	-rw-r--r--	2017-09-19 12:02
seq_tests.py	13.49 KB	-rw-r--r--	2024-04-17 20:28
sgml_input.html	8.1 KB	-rw-r--r--	2017-09-19 12:02
sha256.pem	8.15 KB	-rw-r--r--	2017-09-19 12:02
sortperf.py	4.69 KB	-rw-r--r--	2024-04-17 20:28
ssl_cert.pem	867 B	-rw-r--r--	2017-09-19 12:02
ssl_key.passwd.pem	963 B	-rw-r--r--	2017-09-19 12:02
ssl_key.pem	916 B	-rw-r--r--	2017-09-19 12:02
ssl_servers.py	6.82 KB	-rw-r--r--	2024-04-17 20:28
string_tests.py	62.74 KB	-rw-r--r--	2024-04-17 20:28
test___all__.py	3.86 KB	-rw-r--r--	2024-04-17 20:28
test___future__.py	2.44 KB	-rw-r--r--	2024-04-17 20:28
test__locale.py	6.89 KB	-rw-r--r--	2024-04-17 20:28
test__osx_support.py	11.41 KB	-rw-r--r--	2024-04-17 20:28
test_abc.py	12.76 KB	-rw-r--r--	2024-04-17 20:28
test_abstract_numbers.py	1.49 KB	-rw-r--r--	2024-04-17 20:28
test_aifc.py	14.48 KB	-rw-r--r--	2024-04-17 20:28
test_argparse.py	158.6 KB	-rw-r--r--	2024-04-17 20:28
test_array.py	43.88 KB	-rw-r--r--	2024-04-17 20:28
test_ast.py	43.49 KB	-rw-r--r--	2024-04-17 20:28
test_asynchat.py	9.08 KB	-rw-r--r--	2024-04-17 20:28
test_asyncore.py	26.05 KB	-rw-r--r--	2024-04-17 20:28
test_atexit.py	3.53 KB	-rw-r--r--	2024-04-17 20:28
test_audioop.py	17.39 KB	-rw-r--r--	2024-04-17 20:28
test_augassign.py	7.44 KB	-rw-r--r--	2024-04-17 20:28
test_base64.py	14.34 KB	-rw-r--r--	2024-04-17 20:28
test_bigaddrspace.py	2.92 KB	-rw-r--r--	2024-04-17 20:28
test_bigmem.py	44.18 KB	-rw-r--r--	2024-04-17 20:28
test_binascii.py	9.94 KB	-rw-r--r--	2024-04-17 20:28
test_binhex.py	1.47 KB	-rw-r--r--	2024-04-17 20:28
test_binop.py	12.36 KB	-rw-r--r--	2024-04-17 20:28
test_bisect.py	13.65 KB	-rw-r--r--	2024-04-17 20:28
test_bool.py	11.81 KB	-rw-r--r--	2024-04-17 20:28
test_buffer.py	155.09 KB	-rw-r--r--	2024-04-17 20:28
test_bufio.py	2.54 KB	-rw-r--r--	2024-04-17 20:28
test_builtin.py	54.84 KB	-rw-r--r--	2024-04-17 20:28
test_bytes.py	52.86 KB	-rw-r--r--	2024-04-17 20:28
test_bz2.py	30.8 KB	-rw-r--r--	2024-04-17 20:28
test_calendar.py	38.7 KB	-rw-r--r--	2024-04-17 20:28
test_call.py	3.08 KB	-rw-r--r--	2024-04-17 20:28
test_capi.py	13.81 KB	-rw-r--r--	2024-04-17 20:28
test_cgi.py	17.34 KB	-rw-r--r--	2024-04-17 20:28
test_cgitb.py	2.49 KB	-rw-r--r--	2024-04-17 20:28
test_charmapcodec.py	1.75 KB	-rw-r--r--	2024-04-17 20:28
test_class.py	13.79 KB	-rw-r--r--	2024-04-17 20:28
test_cmath.py	20.38 KB	-rw-r--r--	2024-04-17 20:28
test_cmd.py	6.08 KB	-rw-r--r--	2024-04-17 20:28
test_cmd_line.py	15.35 KB	-rw-r--r--	2024-04-17 20:28
test_cmd_line_script.py	16.95 KB	-rw-r--r--	2024-04-17 20:28
test_code.py	3.54 KB	-rw-r--r--	2024-04-17 20:28
test_code_module.py	2.42 KB	-rw-r--r--	2024-04-17 20:28
test_codeccallbacks.py	33.17 KB	-rw-r--r--	2024-04-17 20:28
test_codecencodings_cn.py	3.38 KB	-rw-r--r--	2024-04-17 20:28
test_codecencodings_hk.py	775 B	-rw-r--r--	2024-04-17 20:28
test_codecencodings_iso2022.py	1.43 KB	-rw-r--r--	2024-04-17 20:28
test_codecencodings_jp.py	4.86 KB	-rw-r--r--	2024-04-17 20:28
test_codecencodings_kr.py	3.03 KB	-rw-r--r--	2024-04-17 20:28
test_codecencodings_tw.py	755 B	-rw-r--r--	2024-04-17 20:28
test_codecmaps_cn.py	930 B	-rw-r--r--	2024-04-17 20:28
test_codecmaps_hk.py	505 B	-rw-r--r--	2024-04-17 20:28
test_codecmaps_jp.py	1.88 KB	-rw-r--r--	2024-04-17 20:28
test_codecmaps_kr.py	1.34 KB	-rw-r--r--	2024-04-17 20:28
test_codecmaps_tw.py	880 B	-rw-r--r--	2024-04-17 20:28
test_codecs.py	96.02 KB	-rw-r--r--	2024-04-17 20:28
test_codeop.py	7.45 KB	-rw-r--r--	2024-04-17 20:28
test_coding.py	2.51 KB	-rw-r--r--	2024-04-17 20:28
test_collections.py	54.31 KB	-rw-r--r--	2024-04-17 20:28
test_colorsys.py	2.77 KB	-rw-r--r--	2024-04-17 20:28
test_compare.py	1.63 KB	-rw-r--r--	2024-04-17 20:28
test_compile.py	18.62 KB	-rw-r--r--	2024-04-17 20:28
test_compileall.py	15.73 KB	-rw-r--r--	2024-04-17 20:28
test_complex.py	27.09 KB	-rw-r--r--	2024-04-17 20:28
test_concurrent_futures.py	22.57 KB	-rw-r--r--	2024-04-17 20:28
test_configparser.py	69.26 KB	-rw-r--r--	2024-04-17 20:28
test_contains.py	2.58 KB	-rw-r--r--	2024-04-17 20:28
test_contextlib.py	21.39 KB	-rw-r--r--	2024-04-17 20:28
test_copy.py	21.9 KB	-rw-r--r--	2024-04-17 20:28
test_copyreg.py	4.12 KB	-rw-r--r--	2024-04-17 20:28
test_cprofile.py	5.32 KB	-rw-r--r--	2024-04-17 20:28
test_crashers.py	1.18 KB	-rw-r--r--	2024-04-17 20:28
test_crypt.py	1.24 KB	-rw-r--r--	2024-04-17 20:28
test_csv.py	40.9 KB	-rw-r--r--	2024-04-17 20:28
test_ctypes.py	400 B	-rw-r--r--	2024-04-17 20:28
test_curses.py	10.7 KB	-rw-r--r--	2024-04-17 20:28
test_datetime.py	1.81 KB	-rw-r--r--	2024-04-17 20:28
test_dbm.py	5.52 KB	-rw-r--r--	2024-04-17 20:28
test_dbm_dumb.py	5.49 KB	-rw-r--r--	2024-04-17 20:28
test_dbm_gnu.py	2.85 KB	-rw-r--r--	2024-04-17 20:28
test_dbm_ndbm.py	1.13 KB	-rw-r--r--	2024-04-17 20:28
test_decimal.py	197.66 KB	-rw-r--r--	2024-04-17 20:28
test_decorators.py	9.6 KB	-rw-r--r--	2024-04-17 20:28
test_defaultdict.py	5.94 KB	-rw-r--r--	2024-04-17 20:28
test_deque.py	25 KB	-rw-r--r--	2024-04-17 20:28
test_descr.py	156.64 KB	-rw-r--r--	2024-04-17 20:28
test_descrtut.py	11.5 KB	-rw-r--r--	2024-04-17 20:28
test_devpoll.py	3.49 KB	-rw-r--r--	2024-04-17 20:28
test_dict.py	31.11 KB	-rw-r--r--	2024-04-17 20:28
test_dictcomps.py	3.69 KB	-rw-r--r--	2024-04-17 20:28
test_dictviews.py	8.51 KB	-rw-r--r--	2024-04-17 20:28
test_difflib.py	10.78 KB	-rw-r--r--	2024-04-17 20:28
test_difflib_expect.html	100.86 KB	-rw-r--r--	2017-09-19 12:02
test_dis.py	12.33 KB	-rw-r--r--	2024-04-17 20:28
test_distutils.py	375 B	-rw-r--r--	2024-04-17 20:28
test_doctest.py	81.78 KB	-rw-r--r--	2024-04-17 20:28
test_doctest.txt	300 B	-rw-r--r--	2017-09-19 12:02
test_doctest2.py	2.3 KB	-rw-r--r--	2024-04-17 20:28
test_doctest2.txt	392 B	-rw-r--r--	2017-09-19 12:02
test_doctest3.txt	82 B	-rw-r--r--	2017-09-19 12:02
test_doctest4.txt	244 B	-rw-r--r--	2017-09-19 12:02
test_docxmlrpc.py	8.33 KB	-rw-r--r--	2024-04-17 20:28
test_dummy_thread.py	6.99 KB	-rw-r--r--	2024-04-17 20:28
test_dummy_threading.py	1.76 KB	-rw-r--r--	2024-04-17 20:28
test_dynamic.py	4.37 KB	-rw-r--r--	2024-04-17 20:28
test_enumerate.py	7.96 KB	-rw-r--r--	2024-04-17 20:28
test_eof.py	855 B	-rw-r--r--	2024-04-17 20:28
test_epoll.py	7.48 KB	-rw-r--r--	2024-04-17 20:28
test_errno.py	1.14 KB	-rw-r--r--	2024-04-17 20:28
test_exception_variations.py	3.94 KB	-rw-r--r--	2024-04-17 20:28
test_exceptions.py	33.47 KB	-rw-r--r--	2024-04-17 20:28
test_extcall.py	8.64 KB	-rw-r--r--	2024-04-17 20:28
test_faulthandler.py	17.69 KB	-rw-r--r--	2024-04-17 20:28
test_fcntl.py	4.4 KB	-rw-r--r--	2024-04-17 20:28
test_file.py	11.1 KB	-rw-r--r--	2024-04-17 20:28
test_file_eintr.py	10.09 KB	-rw-r--r--	2024-04-17 20:28
test_filecmp.py	5.5 KB	-rw-r--r--	2024-04-17 20:28
test_fileinput.py	33.37 KB	-rw-r--r--	2024-04-17 20:28
test_fileio.py	15.11 KB	-rw-r--r--	2024-04-17 20:28
test_float.py	57.46 KB	-rw-r--r--	2024-04-17 20:28
test_flufl.py	836 B	-rw-r--r--	2024-04-17 20:28
test_fnmatch.py	2.84 KB	-rw-r--r--	2024-04-17 20:28
test_fork1.py	3.69 KB	-rw-r--r--	2024-04-17 20:28
test_format.py	16.04 KB	-rw-r--r--	2024-04-17 20:28
test_fractions.py	24.45 KB	-rw-r--r--	2024-04-17 20:28
test_frozen.py	2.81 KB	-rw-r--r--	2024-04-17 20:28
test_ftplib.py	35.85 KB	-rw-r--r--	2024-04-17 20:28
test_funcattrs.py	12.7 KB	-rw-r--r--	2024-04-17 20:28
test_functools.py	29.11 KB	-rw-r--r--	2024-04-17 20:28
test_future.py	3.77 KB	-rw-r--r--	2024-04-17 20:28
test_future3.py	490 B	-rw-r--r--	2024-04-17 20:28
test_future4.py	105 B	-rw-r--r--	2024-04-17 20:28
test_future5.py	510 B	-rw-r--r--	2024-04-17 20:28
test_gc.py	29 KB	-rw-r--r--	2024-04-17 20:28
test_gdb.py	35.86 KB	-rw-r--r--	2024-04-17 20:28
test_generators.py	48.5 KB	-rw-r--r--	2024-04-17 20:28
test_genericpath.py	13.3 KB	-rw-r--r--	2024-04-17 20:28
test_genexps.py	7.12 KB	-rw-r--r--	2024-04-17 20:28
test_getargs2.py	23.74 KB	-rw-r--r--	2024-04-17 20:28
test_getopt.py	6.8 KB	-rw-r--r--	2024-04-17 20:28
test_getpass.py	5.95 KB	-rw-r--r--	2024-04-17 20:28
test_gettext.py	22.11 KB	-rw-r--r--	2024-04-17 20:28
test_glob.py	6.69 KB	-rw-r--r--	2024-04-17 20:28
test_global.py	1.25 KB	-rw-r--r--	2024-04-17 20:28
test_grammar.py	31.96 KB	-rw-r--r--	2024-04-17 20:28
test_grp.py	3.18 KB	-rw-r--r--	2024-04-17 20:28
test_gzip.py	17.79 KB	-rw-r--r--	2024-04-17 20:28
test_hash.py	7.25 KB	-rw-r--r--	2024-04-17 20:28
test_hashlib.py	18.79 KB	-rw-r--r--	2024-04-17 20:28
test_heapq.py	14.14 KB	-rw-r--r--	2024-04-17 20:28
test_hmac.py	17.23 KB	-rw-r--r--	2024-04-17 20:28
test_html.py	579 B	-rw-r--r--	2024-04-17 20:28
test_htmlparser.py	30.74 KB	-rw-r--r--	2024-04-17 20:28
test_http_cookiejar.py	70 KB	-rw-r--r--	2024-04-17 20:28
test_http_cookies.py	9.98 KB	-rw-r--r--	2024-04-17 20:28
test_httplib.py	37.59 KB	-rw-r--r--	2024-04-17 20:28
test_httpservers.py	26.35 KB	-rw-r--r--	2024-04-17 20:28
test_idle.py	1.3 KB	-rw-r--r--	2024-04-17 20:28
test_imaplib.py	15.67 KB	-rw-r--r--	2024-04-17 20:28
test_imghdr.py	4.31 KB	-rw-r--r--	2024-04-17 20:28
test_imp.py	18.89 KB	-rw-r--r--	2024-04-17 20:28
test_import.py	38.55 KB	-rw-r--r--	2024-04-17 20:28
test_importhooks.py	7.83 KB	-rw-r--r--	2024-04-17 20:28
test_index.py	8.31 KB	-rw-r--r--	2024-04-17 20:28
test_inspect.py	87.19 KB	-rw-r--r--	2024-04-17 20:28
test_int.py	15.07 KB	-rw-r--r--	2024-04-17 20:28
test_int_literal.py	6.96 KB	-rw-r--r--	2024-04-17 20:28
test_io.py	119.84 KB	-rw-r--r--	2024-04-17 20:28
test_ioctl.py	3.25 KB	-rw-r--r--	2024-04-17 20:28
test_ipaddress.py	72.5 KB	-rw-r--r--	2024-04-17 20:28
test_isinstance.py	9.93 KB	-rw-r--r--	2024-04-17 20:28
test_iter.py	28.5 KB	-rw-r--r--	2024-04-17 20:28
test_iterlen.py	7.4 KB	-rw-r--r--	2024-04-17 20:28
test_itertools.py	82.48 KB	-rw-r--r--	2024-04-17 20:28
test_keywordonlyarg.py	6.7 KB	-rw-r--r--	2024-04-17 20:28
test_kqueue.py	6.61 KB	-rw-r--r--	2024-04-17 20:28
test_largefile.py	6.4 KB	-rw-r--r--	2024-04-17 20:28
test_lib2to3.py	637 B	-rw-r--r--	2024-04-17 20:28
test_linecache.py	4.04 KB	-rw-r--r--	2024-04-17 20:28
test_list.py	4.12 KB	-rw-r--r--	2024-04-17 20:28
test_listcomps.py	3.76 KB	-rw-r--r--	2024-04-17 20:28
test_locale.py	18.35 KB	-rw-r--r--	2024-04-17 20:28
test_logging.py	133.5 KB	-rw-r--r--	2024-04-17 20:28
test_long.py	49.64 KB	-rw-r--r--	2024-04-17 20:28
test_longexp.py	308 B	-rw-r--r--	2024-04-17 20:28
test_lzma.py	69.44 KB	-rw-r--r--	2024-04-17 20:28
test_macpath.py	4.82 KB	-rw-r--r--	2024-04-17 20:28
test_macurl2path.py	1.8 KB	-rw-r--r--	2024-04-17 20:28
test_mailbox.py	90.48 KB	-rw-r--r--	2024-04-17 20:28
test_mailcap.py	9 KB	-rw-r--r--	2024-04-17 20:28
test_marshal.py	11.9 KB	-rw-r--r--	2024-04-17 20:28
test_math.py	45.89 KB	-rw-r--r--	2024-04-17 20:28
test_memoryio.py	28.07 KB	-rw-r--r--	2024-04-17 20:28
test_memoryview.py	15.41 KB	-rw-r--r--	2024-04-17 20:28
test_metaclass.py	6.2 KB	-rw-r--r--	2024-04-17 20:28
test_mimetypes.py	4.18 KB	-rw-r--r--	2024-04-17 20:28
test_minidom.py	61.08 KB	-rw-r--r--	2024-04-17 20:28
test_mmap.py	25.91 KB	-rw-r--r--	2024-04-17 20:28
test_module.py	5.82 KB	-rw-r--r--	2024-04-17 20:28
test_modulefinder.py	8.24 KB	-rw-r--r--	2024-04-17 20:28
test_msilib.py	1.43 KB	-rw-r--r--	2024-04-17 20:28
test_multibytecodec.py	11.27 KB	-rw-r--r--	2024-04-17 20:28
test_multiprocessing.py	108.06 KB	-rw-r--r--	2024-04-17 20:28
test_namespace_pkgs.py	9.19 KB	-rw-r--r--	2024-04-17 20:28
test_netrc.py	4.5 KB	-rw-r--r--	2024-04-17 20:28
test_nis.py	1.19 KB	-rw-r--r--	2024-04-17 20:28
test_nntplib.py	54.81 KB	-rw-r--r--	2024-04-17 20:28
test_normalization.py	3.15 KB	-rw-r--r--	2024-04-17 20:28
test_ntpath.py	15.13 KB	-rw-r--r--	2024-04-17 20:28
test_numeric_tower.py	7.27 KB	-rw-r--r--	2024-04-17 20:28
test_opcodes.py	2.61 KB	-rw-r--r--	2024-04-17 20:28
test_openpty.py	779 B	-rw-r--r--	2024-04-17 20:28
test_operator.py	16.59 KB	-rw-r--r--	2024-04-17 20:28
test_optparse.py	60.74 KB	-rw-r--r--	2024-04-17 20:28
test_os.py	80.83 KB	-rw-r--r--	2024-04-17 20:28
test_ossaudiodev.py	7.05 KB	-rw-r--r--	2024-04-17 20:28
test_osx_env.py	1.31 KB	-rw-r--r--	2024-04-17 20:28
test_parser.py	25.5 KB	-rw-r--r--	2024-04-17 20:28
test_pdb.py	21.79 KB	-rw-r--r--	2024-04-17 20:28
test_peepholer.py	12.47 KB	-rw-r--r--	2024-04-17 20:28
test_pep247.py	2.03 KB	-rw-r--r--	2024-04-17 20:28
test_pep263.py	2.74 KB	-rw-r--r--	2024-04-17 20:28
test_pep277.py	7.7 KB	-rw-r--r--	2024-04-17 20:28
test_pep292.py	9.32 KB	-rw-r--r--	2024-04-17 20:28
test_pep3120.py	1.24 KB	-rw-r--r--	2024-04-17 20:28
test_pep3131.py	977 B	-rw-r--r--	2024-04-17 20:28
test_pep3151.py	7.34 KB	-rw-r--r--	2024-04-17 20:28
test_pep352.py	6.98 KB	-rw-r--r--	2024-04-17 20:28
test_pep380.py	28.42 KB	-rw-r--r--	2024-04-17 20:28
test_pickle.py	4.41 KB	-rw-r--r--	2024-04-17 20:28
test_pickletools.py	643 B	-rw-r--r--	2024-04-17 20:28
test_pipes.py	6.32 KB	-rw-r--r--	2024-04-17 20:28
test_pkg.py	9.39 KB	-rw-r--r--	2024-04-17 20:28
test_pkgimport.py	2.71 KB	-rw-r--r--	2024-04-17 20:28
test_pkgutil.py	12.25 KB	-rw-r--r--	2024-04-17 20:28
test_platform.py	12.12 KB	-rw-r--r--	2024-04-17 20:28
test_plistlib.py	8.42 KB	-rw-r--r--	2024-04-17 20:28
test_poll.py	6.26 KB	-rw-r--r--	2024-04-17 20:28
test_popen.py	1.92 KB	-rw-r--r--	2024-04-17 20:28
test_poplib.py	11.67 KB	-rw-r--r--	2024-04-17 20:28
test_posix.py	47.3 KB	-rw-r--r--	2024-04-17 20:28
test_posixpath.py	25.56 KB	-rw-r--r--	2024-04-17 20:28
test_pow.py	4.49 KB	-rw-r--r--	2024-04-17 20:28
test_pprint.py	27.85 KB	-rw-r--r--	2024-04-17 20:28
test_print.py	4.57 KB	-rw-r--r--	2024-04-17 20:28
test_profile.py	6.84 KB	-rw-r--r--	2024-04-17 20:28
test_property.py	7.63 KB	-rw-r--r--	2024-04-17 20:28
test_pstats.py	1.26 KB	-rw-r--r--	2024-04-17 20:28
test_pty.py	11.12 KB	-rw-r--r--	2024-04-17 20:28
test_pulldom.py	12.17 KB	-rw-r--r--	2024-04-17 20:28
test_pwd.py	4.13 KB	-rw-r--r--	2024-04-17 20:28
test_py_compile.py	2.25 KB	-rw-r--r--	2024-04-17 20:28
test_pyclbr.py	6.8 KB	-rw-r--r--	2024-04-17 20:28
test_pydoc.py	23.26 KB	-rw-r--r--	2024-04-17 20:28
test_pyexpat.py	24.45 KB	-rw-r--r--	2024-04-17 20:28
test_queue.py	12.84 KB	-rw-r--r--	2024-04-17 20:28
test_quopri.py	7.53 KB	-rw-r--r--	2024-04-17 20:28
test_raise.py	11.08 KB	-rw-r--r--	2024-04-17 20:28
test_random.py	21.67 KB	-rw-r--r--	2024-04-17 20:28
test_range.py	22.62 KB	-rw-r--r--	2024-04-17 20:28
test_re.py	56.47 KB	-rw-r--r--	2024-04-17 20:28
test_readline.py	1.66 KB	-rw-r--r--	2024-04-17 20:28
test_reprlib.py	14.21 KB	-rw-r--r--	2024-04-17 20:28
test_resource.py	5.17 KB	-rw-r--r--	2024-04-17 20:28
test_richcmp.py	10.83 KB	-rw-r--r--	2024-04-17 20:28
test_rlcompleter.py	2.74 KB	-rw-r--r--	2024-04-17 20:28
test_robotparser.py	6.9 KB	-rw-r--r--	2024-04-17 20:28
test_runpy.py	23.24 KB	-rw-r--r--	2024-04-17 20:28
test_sax.py	33.48 KB	-rw-r--r--	2024-04-17 20:28
test_sched.py	6.48 KB	-rw-r--r--	2024-04-17 20:28
test_scope.py	19.59 KB	-rw-r--r--	2024-04-17 20:28
test_select.py	2.7 KB	-rw-r--r--	2024-04-17 20:28
test_set.py	62.31 KB	-rw-r--r--	2024-04-17 20:28
test_setcomps.py	3.7 KB	-rw-r--r--	2024-04-17 20:28
test_shelve.py	5.7 KB	-rw-r--r--	2024-04-17 20:28
test_shlex.py	5.77 KB	-rw-r--r--	2024-04-17 20:28
test_shutil.py	66.87 KB	-rw-r--r--	2024-04-17 20:28
test_signal.py	31.59 KB	-rw-r--r--	2024-04-17 20:28
test_site.py	17.32 KB	-rw-r--r--	2024-04-17 20:28
test_slice.py	4.33 KB	-rw-r--r--	2024-04-17 20:28
test_smtpd.py	22.06 KB	-rw-r--r--	2024-04-17 20:28
test_smtplib.py	33.58 KB	-rw-r--r--	2024-04-17 20:28
test_smtpnet.py	1.85 KB	-rw-r--r--	2024-04-17 20:28
test_sndhdr.py	869 B	-rw-r--r--	2024-04-17 20:28
test_socket.py	181.8 KB	-rw-r--r--	2024-04-17 20:28
test_socketserver.py	10.72 KB	-rw-r--r--	2024-04-17 20:28
test_sort.py	8.95 KB	-rw-r--r--	2024-04-17 20:28
test_sqlite.py	893 B	-rw-r--r--	2024-04-17 20:28
test_ssl.py	94.63 KB	-rw-r--r--	2024-04-17 20:28
test_startfile.py	1.21 KB	-rw-r--r--	2024-04-17 20:28
test_stat.py	6.29 KB	-rw-r--r--	2024-04-17 20:28
test_strftime.py	7.55 KB	-rw-r--r--	2024-04-17 20:28
test_string.py	6.11 KB	-rw-r--r--	2024-04-17 20:28
test_stringprep.py	3.12 KB	-rw-r--r--	2024-04-17 20:28
test_strlit.py	8.03 KB	-rw-r--r--	2024-04-17 20:28
test_strptime.py	25.84 KB	-rw-r--r--	2024-04-17 20:28
test_strtod.py	20.11 KB	-rw-r--r--	2024-04-17 20:28
test_struct.py	24.67 KB	-rw-r--r--	2024-04-17 20:28
test_structmembers.py	4.77 KB	-rw-r--r--	2024-04-17 20:28
test_structseq.py	3.96 KB	-rw-r--r--	2024-04-17 20:28
test_subprocess.py	96.46 KB	-rw-r--r--	2024-04-17 20:28
test_sunau.py	3.55 KB	-rw-r--r--	2024-04-17 20:28
test_sundry.py	2.12 KB	-rw-r--r--	2024-04-17 20:28
test_super.py	3.5 KB	-rw-r--r--	2024-04-17 20:28
test_support.py	10.03 KB	-rw-r--r--	2024-04-17 20:28
test_symtable.py	5.82 KB	-rw-r--r--	2024-04-17 20:28
test_syntax.py	17.64 KB	-rw-r--r--	2024-04-17 20:28
test_sys.py	33.13 KB	-rw-r--r--	2024-04-17 20:28
test_sys_setprofile.py	11.09 KB	-rw-r--r--	2024-04-17 20:28
test_sys_settrace.py	24.37 KB	-rw-r--r--	2024-04-17 20:28
test_sysconfig.py	15.75 KB	-rw-r--r--	2024-04-17 20:28
test_syslog.py	1.08 KB	-rw-r--r--	2024-04-17 20:28
test_tarfile.py	70.04 KB	-rw-r--r--	2024-04-17 20:28
test_tcl.py	20.19 KB	-rw-r--r--	2024-04-17 20:28
test_telnetlib.py	14.84 KB	-rw-r--r--	2024-04-17 20:28
test_tempfile.py	39.85 KB	-rw-r--r--	2024-04-17 20:28
test_textwrap.py	29.83 KB	-rw-r--r--	2024-04-17 20:28
test_thread.py	8.1 KB	-rw-r--r--	2024-04-17 20:28
test_threaded_import.py	8.12 KB	-rw-r--r--	2024-04-17 20:28
test_threadedtempfile.py	2.14 KB	-rw-r--r--	2024-04-17 20:28
test_threading.py	33.87 KB	-rw-r--r--	2024-04-17 20:28
test_threading_local.py	6.19 KB	-rw-r--r--	2024-04-17 20:28
test_threadsignals.py	8.88 KB	-rw-r--r--	2024-04-17 20:28
test_time.py	25.86 KB	-rw-r--r--	2024-04-17 20:28
test_timeit.py	10.83 KB	-rw-r--r--	2024-04-17 20:28
test_timeout.py	11.11 KB	-rw-r--r--	2024-04-17 20:28
test_tk.py	747 B	-rw-r--r--	2024-04-17 20:28
test_tokenize.py	47.22 KB	-rw-r--r--	2024-04-17 20:28
test_tools.py	12.48 KB	-rw-r--r--	2024-04-17 20:28
test_trace.py	14.48 KB	-rw-r--r--	2024-04-17 20:28
test_traceback.py	14.02 KB	-rw-r--r--	2024-04-17 20:28
test_ttk_guionly.py	1.05 KB	-rw-r--r--	2024-04-17 20:28
test_ttk_textonly.py	405 B	-rw-r--r--	2024-04-17 20:28
test_tuple.py	6.78 KB	-rw-r--r--	2024-04-17 20:28
test_typechecks.py	2.64 KB	-rw-r--r--	2024-04-17 20:28
test_types.py	41.34 KB	-rw-r--r--	2024-04-17 20:28
test_ucn.py	9.41 KB	-rw-r--r--	2024-04-17 20:28
test_unary.py	1.71 KB	-rw-r--r--	2024-04-17 20:28
test_unicode.py	104.9 KB	-rw-r--r--	2024-04-17 20:28
test_unicode_file.py	5.8 KB	-rw-r--r--	2024-04-17 20:28
test_unicodedata.py	12.06 KB	-rw-r--r--	2024-04-17 20:28
test_unittest.py	286 B	-rw-r--r--	2024-04-17 20:28
test_univnewlines.py	3.83 KB	-rw-r--r--	2024-04-17 20:28
test_unpack.py	2.56 KB	-rw-r--r--	2024-04-17 20:28
test_unpack_ex.py	4.04 KB	-rw-r--r--	2024-04-17 20:28
test_urllib.py	55.37 KB	-rw-r--r--	2024-04-17 20:28
test_urllib2.py	60.39 KB	-rw-r--r--	2024-04-17 20:28
test_urllib2_localnet.py	21.78 KB	-rw-r--r--	2024-04-17 20:28
test_urllib2net.py	12.94 KB	-rw-r--r--	2024-04-17 20:28
test_urllib_response.py	871 B	-rw-r--r--	2024-04-17 20:28
test_urllibnet.py	8.89 KB	-rw-r--r--	2024-04-17 20:28
test_urlparse.py	50.39 KB	-rw-r--r--	2024-04-17 20:28
test_userdict.py	6.32 KB	-rw-r--r--	2024-04-17 20:28
test_userlist.py	1.85 KB	-rw-r--r--	2024-04-17 20:28
test_userstring.py	1.44 KB	-rw-r--r--	2024-04-17 20:28
test_uu.py	6.71 KB	-rw-r--r--	2024-04-17 20:28
test_uuid.py	21.6 KB	-rw-r--r--	2024-04-17 20:28
test_venv.py	7.32 KB	-rw-r--r--	2024-04-17 20:28
test_wait3.py	1.2 KB	-rw-r--r--	2024-04-17 20:28
test_wait4.py	1.11 KB	-rw-r--r--	2024-04-17 20:28
test_warnings.py	32.76 KB	-rw-r--r--	2024-04-17 20:28
test_wave.py	4.39 KB	-rw-r--r--	2024-04-17 20:28
test_weakref.py	49.49 KB	-rw-r--r--	2024-04-17 20:28
test_weakset.py	15.18 KB	-rw-r--r--	2024-04-17 20:28
test_webbrowser.py	5.65 KB	-rw-r--r--	2024-04-17 20:28
test_winreg.py	19.99 KB	-rw-r--r--	2024-04-17 20:28
test_winsound.py	8.86 KB	-rw-r--r--	2024-04-17 20:28
test_with.py	25.88 KB	-rw-r--r--	2024-04-17 20:28
test_wsgiref.py	21.84 KB	-rw-r--r--	2024-04-17 20:28
test_xdrlib.py	1.56 KB	-rw-r--r--	2024-04-17 20:28
test_xml_dom_minicompat.py	2.91 KB	-rw-r--r--	2024-04-17 20:28
test_xml_etree.py	88.5 KB	-rw-r--r--	2024-04-17 20:28
test_xml_etree_c.py	2.53 KB	-rw-r--r--	2024-04-17 20:28
test_xmlrpc.py	41.85 KB	-rw-r--r--	2024-04-17 20:28
test_xmlrpc_net.py	1.89 KB	-rw-r--r--	2024-04-17 20:28
test_zipfile.py	65.66 KB	-rw-r--r--	2024-04-17 20:28
test_zipfile64.py	4.17 KB	-rw-r--r--	2024-04-17 20:28
test_zipimport.py	17 KB	-rw-r--r--	2024-04-17 20:28
test_zipimport_support.py	10.28 KB	-rw-r--r--	2024-04-17 20:28
test_zlib.py	26.14 KB	-rw-r--r--	2024-04-17 20:28
testcodec.py	1.02 KB	-rw-r--r--	2024-04-17 20:28
testtar.tar	425 KB	-rw-r--r--	2017-09-19 12:02
tf_inherit_check.py	578 B	-rw-r--r--	2024-04-17 20:28
threaded_import_hangers.py	1.45 KB	-rw-r--r--	2024-04-17 20:28
time_hashlib.py	2.82 KB	-rw-r--r--	2024-04-17 20:28
tokenize_tests-latin1-coding-cookie-and-utf8-bom-sig.txt	444 B	-rw-r--r--	2017-09-19 12:02
tokenize_tests-no-coding-cookie-and-utf8-bom-sig-only.txt	303 B	-rw-r--r--	2017-09-19 12:02
tokenize_tests-utf8-coding-cookie-and-no-utf8-bom-sig.txt	421 B	-rw-r--r--	2017-09-19 12:02
tokenize_tests-utf8-coding-cookie-and-utf8-bom-sig.txt	327 B	-rw-r--r--	2017-09-19 12:02
tokenize_tests.txt	2.65 KB	-rw-r--r--	2017-09-19 12:02
warning_tests.py	240 B	-rw-r--r--	2024-04-17 20:28
win_console_handler.py	1.38 KB	-rw-r--r--	2024-04-17 20:28
xmltests.py	499 B	-rw-r--r--	2024-04-17 20:28
zip_cp437_header.zip	270 B	-rw-r--r--	2017-09-19 12:02
zipdir.zip	374 B	-rw-r--r--	2017-09-19 12:02

Rename

# Python test set -- math module
# XXXX Should not do tests around zero only

from test.support import run_unittest, verbose, requires_IEEE_754
from test import support
import unittest
import math
import os
import platform
import sys
import struct
import sysconfig

eps = 1E-05
NAN = float('nan')
INF = float('inf')
NINF = float('-inf')

# detect evidence of double-rounding: fsum is not always correctly
# rounded on machines that suffer from double rounding.
x, y = 1e16, 2.9999 # use temporary values to defeat peephole optimizer
HAVE_DOUBLE_ROUNDING = (x + y == 1e16 + 4)

# locate file with test values
if __name__ == '__main__':
    file = sys.argv[0]
else:
    file = __file__
test_dir = os.path.dirname(file) or os.curdir
math_testcases = os.path.join(test_dir, 'math_testcases.txt')
test_file = os.path.join(test_dir, 'cmath_testcases.txt')

def to_ulps(x):
    """Convert a non-NaN float x to an integer, in such a way that
    adjacent floats are converted to adjacent integers.  Then
    abs(ulps(x) - ulps(y)) gives the difference in ulps between two
    floats.

The results from this function will only make sense on platforms
    where C doubles are represented in IEEE 754 binary64 format.

"""
    n = struct.unpack('<q', struct.pack('<d', x))[0]
    if n < 0:
        n = ~(n+2**63)
    return n

def ulps_check(expected, got, ulps=20):
    """Given non-NaN floats `expected` and `got`,
    check that they're equal to within the given number of ulps.

Returns None on success and an error message on failure."""

ulps_error = to_ulps(got) - to_ulps(expected)
    if abs(ulps_error) <= ulps:
        return None
    return "error = {} ulps; permitted error = {} ulps".format(ulps_error,
                                                               ulps)

# Here's a pure Python version of the math.factorial algorithm, for
# documentation and comparison purposes.
#
# Formula:
#
#   factorial(n) = factorial_odd_part(n) << (n - count_set_bits(n))
#
# where
#
#   factorial_odd_part(n) = product_{i >= 0} product_{0 < j <= n >> i; j odd} j
#
# The outer product above is an infinite product, but once i >= n.bit_length,
# (n >> i) < 1 and the corresponding term of the product is empty.  So only the
# finitely many terms for 0 <= i < n.bit_length() contribute anything.
#
# We iterate downwards from i == n.bit_length() - 1 to i == 0.  The inner
# product in the formula above starts at 1 for i == n.bit_length(); for each i
# < n.bit_length() we get the inner product for i from that for i + 1 by
# multiplying by all j in {n >> i+1 < j <= n >> i; j odd}.  In Python terms,
# this set is range((n >> i+1) + 1 | 1, (n >> i) + 1 | 1, 2).

def count_set_bits(n):
    """Number of '1' bits in binary expansion of a nonnnegative integer."""
    return 1 + count_set_bits(n & n - 1) if n else 0

def partial_product(start, stop):
    """Product of integers in range(start, stop, 2), computed recursively.
    start and stop should both be odd, with start <= stop.

"""
    numfactors = (stop - start) >> 1
    if not numfactors:
        return 1
    elif numfactors == 1:
        return start
    else:
        mid = (start + numfactors) | 1
        return partial_product(start, mid) * partial_product(mid, stop)

def py_factorial(n):
    """Factorial of nonnegative integer n, via "Binary Split Factorial Formula"
    described at http://www.luschny.de/math/factorial/binarysplitfact.html

"""
    inner = outer = 1
    for i in reversed(range(n.bit_length())):
        inner *= partial_product((n >> i + 1) + 1 | 1, (n >> i) + 1 | 1)
        outer *= inner
    return outer << (n - count_set_bits(n))

def acc_check(expected, got, rel_err=2e-15, abs_err = 5e-323):
    """Determine whether non-NaN floats a and b are equal to within a
    (small) rounding error.  The default values for rel_err and
    abs_err are chosen to be suitable for platforms where a float is
    represented by an IEEE 754 double.  They allow an error of between
    9 and 19 ulps."""

# need to special case infinities, since inf - inf gives nan
    if math.isinf(expected) and got == expected:
        return None

error = got - expected

permitted_error = max(abs_err, rel_err * abs(expected))
    if abs(error) < permitted_error:
        return None
    return "error = {}; permitted error = {}".format(error,
                                                     permitted_error)

def parse_mtestfile(fname):
    """Parse a file with test values

-- starts a comment
    blank lines, or lines containing only a comment, are ignored
    other lines are expected to have the form
      id fn arg -> expected [flag]*

"""
    with open(fname) as fp:
        for line in fp:
            # strip comments, and skip blank lines
            if '--' in line:
                line = line[:line.index('--')]
            if not line.strip():
                continue

lhs, rhs = line.split('->')
            id, fn, arg = lhs.split()
            rhs_pieces = rhs.split()
            exp = rhs_pieces[0]
            flags = rhs_pieces[1:]

yield (id, fn, float(arg), float(exp), flags)

def parse_testfile(fname):
    """Parse a file with test values

Empty lines or lines starting with -- are ignored
    yields id, fn, arg_real, arg_imag, exp_real, exp_imag
    """
    with open(fname) as fp:
        for line in fp:
            # skip comment lines and blank lines
            if line.startswith('--') or not line.strip():
                continue

lhs, rhs = line.split('->')
            id, fn, arg_real, arg_imag = lhs.split()
            rhs_pieces = rhs.split()
            exp_real, exp_imag = rhs_pieces[0], rhs_pieces[1]
            flags = rhs_pieces[2:]

yield (id, fn,
                   float(arg_real), float(arg_imag),
                   float(exp_real), float(exp_imag),
                   flags
                  )

class MathTests(unittest.TestCase):

def ftest(self, name, value, expected):
        if abs(value-expected) > eps:
            # Use %r instead of %f so the error message
            # displays full precision. Otherwise discrepancies
            # in the last few bits will lead to very confusing
            # error messages
            self.fail('%s returned %r, expected %r' %
                      (name, value, expected))

def testConstants(self):
        self.ftest('pi', math.pi, 3.1415926)
        self.ftest('e', math.e, 2.7182818)

def testAcos(self):
        self.assertRaises(TypeError, math.acos)
        self.ftest('acos(-1)', math.acos(-1), math.pi)
        self.ftest('acos(0)', math.acos(0), math.pi/2)
        self.ftest('acos(1)', math.acos(1), 0)
        self.assertRaises(ValueError, math.acos, INF)
        self.assertRaises(ValueError, math.acos, NINF)
        self.assertTrue(math.isnan(math.acos(NAN)))

def testAcosh(self):
        self.assertRaises(TypeError, math.acosh)
        self.ftest('acosh(1)', math.acosh(1), 0)
        self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168)
        self.assertRaises(ValueError, math.acosh, 0)
        self.assertRaises(ValueError, math.acosh, -1)
        self.assertEqual(math.acosh(INF), INF)
        self.assertRaises(ValueError, math.acosh, NINF)
        self.assertTrue(math.isnan(math.acosh(NAN)))

def testAsin(self):
        self.assertRaises(TypeError, math.asin)
        self.ftest('asin(-1)', math.asin(-1), -math.pi/2)
        self.ftest('asin(0)', math.asin(0), 0)
        self.ftest('asin(1)', math.asin(1), math.pi/2)
        self.assertRaises(ValueError, math.asin, INF)
        self.assertRaises(ValueError, math.asin, NINF)
        self.assertTrue(math.isnan(math.asin(NAN)))

def testAsinh(self):
        self.assertRaises(TypeError, math.asinh)
        self.ftest('asinh(0)', math.asinh(0), 0)
        self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305)
        self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305)
        self.assertEqual(math.asinh(INF), INF)
        self.assertEqual(math.asinh(NINF), NINF)
        self.assertTrue(math.isnan(math.asinh(NAN)))

def testAtan(self):
        self.assertRaises(TypeError, math.atan)
        self.ftest('atan(-1)', math.atan(-1), -math.pi/4)
        self.ftest('atan(0)', math.atan(0), 0)
        self.ftest('atan(1)', math.atan(1), math.pi/4)
        self.ftest('atan(inf)', math.atan(INF), math.pi/2)
        self.ftest('atan(-inf)', math.atan(NINF), -math.pi/2)
        self.assertTrue(math.isnan(math.atan(NAN)))

def testAtanh(self):
        self.assertRaises(TypeError, math.atan)
        self.ftest('atanh(0)', math.atanh(0), 0)
        self.ftest('atanh(0.5)', math.atanh(0.5), 0.54930614433405489)
        self.ftest('atanh(-0.5)', math.atanh(-0.5), -0.54930614433405489)
        self.assertRaises(ValueError, math.atanh, 1)
        self.assertRaises(ValueError, math.atanh, -1)
        self.assertRaises(ValueError, math.atanh, INF)
        self.assertRaises(ValueError, math.atanh, NINF)
        self.assertTrue(math.isnan(math.atanh(NAN)))

def testAtan2(self):
        self.assertRaises(TypeError, math.atan2)
        self.ftest('atan2(-1, 0)', math.atan2(-1, 0), -math.pi/2)
        self.ftest('atan2(-1, 1)', math.atan2(-1, 1), -math.pi/4)
        self.ftest('atan2(0, 1)', math.atan2(0, 1), 0)
        self.ftest('atan2(1, 1)', math.atan2(1, 1), math.pi/4)
        self.ftest('atan2(1, 0)', math.atan2(1, 0), math.pi/2)

# math.atan2(0, x)
        self.ftest('atan2(0., -inf)', math.atan2(0., NINF), math.pi)
        self.ftest('atan2(0., -2.3)', math.atan2(0., -2.3), math.pi)
        self.ftest('atan2(0., -0.)', math.atan2(0., -0.), math.pi)
        self.assertEqual(math.atan2(0., 0.), 0.)
        self.assertEqual(math.atan2(0., 2.3), 0.)
        self.assertEqual(math.atan2(0., INF), 0.)
        self.assertTrue(math.isnan(math.atan2(0., NAN)))
        # math.atan2(-0, x)
        self.ftest('atan2(-0., -inf)', math.atan2(-0., NINF), -math.pi)
        self.ftest('atan2(-0., -2.3)', math.atan2(-0., -2.3), -math.pi)
        self.ftest('atan2(-0., -0.)', math.atan2(-0., -0.), -math.pi)
        self.assertEqual(math.atan2(-0., 0.), -0.)
        self.assertEqual(math.atan2(-0., 2.3), -0.)
        self.assertEqual(math.atan2(-0., INF), -0.)
        self.assertTrue(math.isnan(math.atan2(-0., NAN)))
        # math.atan2(INF, x)
        self.ftest('atan2(inf, -inf)', math.atan2(INF, NINF), math.pi*3/4)
        self.ftest('atan2(inf, -2.3)', math.atan2(INF, -2.3), math.pi/2)
        self.ftest('atan2(inf, -0.)', math.atan2(INF, -0.0), math.pi/2)
        self.ftest('atan2(inf, 0.)', math.atan2(INF, 0.0), math.pi/2)
        self.ftest('atan2(inf, 2.3)', math.atan2(INF, 2.3), math.pi/2)
        self.ftest('atan2(inf, inf)', math.atan2(INF, INF), math.pi/4)
        self.assertTrue(math.isnan(math.atan2(INF, NAN)))
        # math.atan2(NINF, x)
        self.ftest('atan2(-inf, -inf)', math.atan2(NINF, NINF), -math.pi*3/4)
        self.ftest('atan2(-inf, -2.3)', math.atan2(NINF, -2.3), -math.pi/2)
        self.ftest('atan2(-inf, -0.)', math.atan2(NINF, -0.0), -math.pi/2)
        self.ftest('atan2(-inf, 0.)', math.atan2(NINF, 0.0), -math.pi/2)
        self.ftest('atan2(-inf, 2.3)', math.atan2(NINF, 2.3), -math.pi/2)
        self.ftest('atan2(-inf, inf)', math.atan2(NINF, INF), -math.pi/4)
        self.assertTrue(math.isnan(math.atan2(NINF, NAN)))
        # math.atan2(+finite, x)
        self.ftest('atan2(2.3, -inf)', math.atan2(2.3, NINF), math.pi)
        self.ftest('atan2(2.3, -0.)', math.atan2(2.3, -0.), math.pi/2)
        self.ftest('atan2(2.3, 0.)', math.atan2(2.3, 0.), math.pi/2)
        self.assertEqual(math.atan2(2.3, INF), 0.)
        self.assertTrue(math.isnan(math.atan2(2.3, NAN)))
        # math.atan2(-finite, x)
        self.ftest('atan2(-2.3, -inf)', math.atan2(-2.3, NINF), -math.pi)
        self.ftest('atan2(-2.3, -0.)', math.atan2(-2.3, -0.), -math.pi/2)
        self.ftest('atan2(-2.3, 0.)', math.atan2(-2.3, 0.), -math.pi/2)
        self.assertEqual(math.atan2(-2.3, INF), -0.)
        self.assertTrue(math.isnan(math.atan2(-2.3, NAN)))
        # math.atan2(NAN, x)
        self.assertTrue(math.isnan(math.atan2(NAN, NINF)))
        self.assertTrue(math.isnan(math.atan2(NAN, -2.3)))
        self.assertTrue(math.isnan(math.atan2(NAN, -0.)))
        self.assertTrue(math.isnan(math.atan2(NAN, 0.)))
        self.assertTrue(math.isnan(math.atan2(NAN, 2.3)))
        self.assertTrue(math.isnan(math.atan2(NAN, INF)))
        self.assertTrue(math.isnan(math.atan2(NAN, NAN)))

def testCeil(self):
        self.assertRaises(TypeError, math.ceil)
        self.assertEqual(int, type(math.ceil(0.5)))
        self.ftest('ceil(0.5)', math.ceil(0.5), 1)
        self.ftest('ceil(1.0)', math.ceil(1.0), 1)
        self.ftest('ceil(1.5)', math.ceil(1.5), 2)
        self.ftest('ceil(-0.5)', math.ceil(-0.5), 0)
        self.ftest('ceil(-1.0)', math.ceil(-1.0), -1)
        self.ftest('ceil(-1.5)', math.ceil(-1.5), -1)
        #self.assertEqual(math.ceil(INF), INF)
        #self.assertEqual(math.ceil(NINF), NINF)
        #self.assertTrue(math.isnan(math.ceil(NAN)))

class TestCeil:
            def __ceil__(self):
                return 42
        class TestNoCeil:
            pass
        self.ftest('ceil(TestCeil())', math.ceil(TestCeil()), 42)
        self.assertRaises(TypeError, math.ceil, TestNoCeil())

t = TestNoCeil()
        t.__ceil__ = lambda *args: args
        self.assertRaises(TypeError, math.ceil, t)
        self.assertRaises(TypeError, math.ceil, t, 0)

@requires_IEEE_754
    def testCopysign(self):
        self.assertEqual(math.copysign(1, 42), 1.0)
        self.assertEqual(math.copysign(0., 42), 0.0)
        self.assertEqual(math.copysign(1., -42), -1.0)
        self.assertEqual(math.copysign(3, 0.), 3.0)
        self.assertEqual(math.copysign(4., -0.), -4.0)

self.assertRaises(TypeError, math.copysign)
        # copysign should let us distinguish signs of zeros
        self.assertEqual(math.copysign(1., 0.), 1.)
        self.assertEqual(math.copysign(1., -0.), -1.)
        self.assertEqual(math.copysign(INF, 0.), INF)
        self.assertEqual(math.copysign(INF, -0.), NINF)
        self.assertEqual(math.copysign(NINF, 0.), INF)
        self.assertEqual(math.copysign(NINF, -0.), NINF)
        # and of infinities
        self.assertEqual(math.copysign(1., INF), 1.)
        self.assertEqual(math.copysign(1., NINF), -1.)
        self.assertEqual(math.copysign(INF, INF), INF)
        self.assertEqual(math.copysign(INF, NINF), NINF)
        self.assertEqual(math.copysign(NINF, INF), INF)
        self.assertEqual(math.copysign(NINF, NINF), NINF)
        self.assertTrue(math.isnan(math.copysign(NAN, 1.)))
        self.assertTrue(math.isnan(math.copysign(NAN, INF)))
        self.assertTrue(math.isnan(math.copysign(NAN, NINF)))
        self.assertTrue(math.isnan(math.copysign(NAN, NAN)))
        # copysign(INF, NAN) may be INF or it may be NINF, since
        # we don't know whether the sign bit of NAN is set on any
        # given platform.
        self.assertTrue(math.isinf(math.copysign(INF, NAN)))
        # similarly, copysign(2., NAN) could be 2. or -2.
        self.assertEqual(abs(math.copysign(2., NAN)), 2.)

def testCos(self):
        self.assertRaises(TypeError, math.cos)
        self.ftest('cos(-pi/2)', math.cos(-math.pi/2), 0)
        self.ftest('cos(0)', math.cos(0), 1)
        self.ftest('cos(pi/2)', math.cos(math.pi/2), 0)
        self.ftest('cos(pi)', math.cos(math.pi), -1)
        try:
            self.assertTrue(math.isnan(math.cos(INF)))
            self.assertTrue(math.isnan(math.cos(NINF)))
        except ValueError:
            self.assertRaises(ValueError, math.cos, INF)
            self.assertRaises(ValueError, math.cos, NINF)
        self.assertTrue(math.isnan(math.cos(NAN)))

def testCosh(self):
        self.assertRaises(TypeError, math.cosh)
        self.ftest('cosh(0)', math.cosh(0), 1)
        self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
        self.assertEqual(math.cosh(INF), INF)
        self.assertEqual(math.cosh(NINF), INF)
        self.assertTrue(math.isnan(math.cosh(NAN)))

def testDegrees(self):
        self.assertRaises(TypeError, math.degrees)
        self.ftest('degrees(pi)', math.degrees(math.pi), 180.0)
        self.ftest('degrees(pi/2)', math.degrees(math.pi/2), 90.0)
        self.ftest('degrees(-pi/4)', math.degrees(-math.pi/4), -45.0)

def testExp(self):
        self.assertRaises(TypeError, math.exp)
        self.ftest('exp(-1)', math.exp(-1), 1/math.e)
        self.ftest('exp(0)', math.exp(0), 1)
        self.ftest('exp(1)', math.exp(1), math.e)
        self.assertEqual(math.exp(INF), INF)
        self.assertEqual(math.exp(NINF), 0.)
        self.assertTrue(math.isnan(math.exp(NAN)))

def testFabs(self):
        self.assertRaises(TypeError, math.fabs)
        self.ftest('fabs(-1)', math.fabs(-1), 1)
        self.ftest('fabs(0)', math.fabs(0), 0)
        self.ftest('fabs(1)', math.fabs(1), 1)

def testFactorial(self):
        self.assertEqual(math.factorial(0), 1)
        self.assertEqual(math.factorial(0.0), 1)
        total = 1
        for i in range(1, 1000):
            total *= i
            self.assertEqual(math.factorial(i), total)
            self.assertEqual(math.factorial(float(i)), total)
            self.assertEqual(math.factorial(i), py_factorial(i))
        self.assertRaises(ValueError, math.factorial, -1)
        self.assertRaises(ValueError, math.factorial, -1.0)
        self.assertRaises(ValueError, math.factorial, math.pi)
        self.assertRaises(OverflowError, math.factorial, sys.maxsize+1)
        self.assertRaises(OverflowError, math.factorial, 10e100)

def testFloor(self):
        self.assertRaises(TypeError, math.floor)
        self.assertEqual(int, type(math.floor(0.5)))
        self.ftest('floor(0.5)', math.floor(0.5), 0)
        self.ftest('floor(1.0)', math.floor(1.0), 1)
        self.ftest('floor(1.5)', math.floor(1.5), 1)
        self.ftest('floor(-0.5)', math.floor(-0.5), -1)
        self.ftest('floor(-1.0)', math.floor(-1.0), -1)
        self.ftest('floor(-1.5)', math.floor(-1.5), -2)
        # pow() relies on floor() to check for integers
        # This fails on some platforms - so check it here
        self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167)
        self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167)
        #self.assertEqual(math.ceil(INF), INF)
        #self.assertEqual(math.ceil(NINF), NINF)
        #self.assertTrue(math.isnan(math.floor(NAN)))

class TestFloor:
            def __floor__(self):
                return 42
        class TestNoFloor:
            pass
        self.ftest('floor(TestFloor())', math.floor(TestFloor()), 42)
        self.assertRaises(TypeError, math.floor, TestNoFloor())

t = TestNoFloor()
        t.__floor__ = lambda *args: args
        self.assertRaises(TypeError, math.floor, t)
        self.assertRaises(TypeError, math.floor, t, 0)

def testFmod(self):
        self.assertRaises(TypeError, math.fmod)
        self.ftest('fmod(10, 1)', math.fmod(10, 1), 0.0)
        self.ftest('fmod(10, 0.5)', math.fmod(10, 0.5), 0.0)
        self.ftest('fmod(10, 1.5)', math.fmod(10, 1.5), 1.0)
        self.ftest('fmod(-10, 1)', math.fmod(-10, 1), -0.0)
        self.ftest('fmod(-10, 0.5)', math.fmod(-10, 0.5), -0.0)
        self.ftest('fmod(-10, 1.5)', math.fmod(-10, 1.5), -1.0)
        self.assertTrue(math.isnan(math.fmod(NAN, 1.)))
        self.assertTrue(math.isnan(math.fmod(1., NAN)))
        self.assertTrue(math.isnan(math.fmod(NAN, NAN)))
        self.assertRaises(ValueError, math.fmod, 1., 0.)
        self.assertRaises(ValueError, math.fmod, INF, 1.)
        self.assertRaises(ValueError, math.fmod, NINF, 1.)
        self.assertRaises(ValueError, math.fmod, INF, 0.)
        self.assertEqual(math.fmod(3.0, INF), 3.0)
        self.assertEqual(math.fmod(-3.0, INF), -3.0)
        self.assertEqual(math.fmod(3.0, NINF), 3.0)
        self.assertEqual(math.fmod(-3.0, NINF), -3.0)
        self.assertEqual(math.fmod(0.0, 3.0), 0.0)
        self.assertEqual(math.fmod(0.0, NINF), 0.0)

def testFrexp(self):
        self.assertRaises(TypeError, math.frexp)

def testfrexp(name, result, expected):
            (mant, exp), (emant, eexp) = result, expected
            if abs(mant-emant) > eps or exp != eexp:
                self.fail('%s returned %r, expected %r'%\
                          (name, result, expected))

testfrexp('frexp(-1)', math.frexp(-1), (-0.5, 1))
        testfrexp('frexp(0)', math.frexp(0), (0, 0))
        testfrexp('frexp(1)', math.frexp(1), (0.5, 1))
        testfrexp('frexp(2)', math.frexp(2), (0.5, 2))

self.assertEqual(math.frexp(INF)[0], INF)
        self.assertEqual(math.frexp(NINF)[0], NINF)
        self.assertTrue(math.isnan(math.frexp(NAN)[0]))

@requires_IEEE_754
    @unittest.skipIf(HAVE_DOUBLE_ROUNDING,
                         "fsum is not exact on machines with double rounding")
    def testFsum(self):
        # math.fsum relies on exact rounding for correct operation.
        # There's a known problem with IA32 floating-point that causes
        # inexact rounding in some situations, and will cause the
        # math.fsum tests below to fail; see issue #2937.  On non IEEE
        # 754 platforms, and on IEEE 754 platforms that exhibit the
        # problem described in issue #2937, we simply skip the whole
        # test.

# Python version of math.fsum, for comparison.  Uses a
        # different algorithm based on frexp, ldexp and integer
        # arithmetic.
        from sys import float_info
        mant_dig = float_info.mant_dig
        etiny = float_info.min_exp - mant_dig

def msum(iterable):
            """Full precision summation.  Compute sum(iterable) without any
            intermediate accumulation of error.  Based on the 'lsum' function
            at http://code.activestate.com/recipes/393090/

"""
            tmant, texp = 0, 0
            for x in iterable:
                mant, exp = math.frexp(x)
                mant, exp = int(math.ldexp(mant, mant_dig)), exp - mant_dig
                if texp > exp:
                    tmant <<= texp-exp
                    texp = exp
                else:
                    mant <<= exp-texp
                tmant += mant
            # Round tmant * 2**texp to a float.  The original recipe
            # used float(str(tmant)) * 2.0**texp for this, but that's
            # a little unsafe because str -> float conversion can't be
            # relied upon to do correct rounding on all platforms.
            tail = max(len(bin(abs(tmant)))-2 - mant_dig, etiny - texp)
            if tail > 0:
                h = 1 << (tail-1)
                tmant = tmant // (2*h) + bool(tmant & h and tmant & 3*h-1)
                texp += tail
            return math.ldexp(tmant, texp)

test_values = [
            ([], 0.0),
            ([0.0], 0.0),
            ([1e100, 1.0, -1e100, 1e-100, 1e50, -1.0, -1e50], 1e-100),
            ([2.0**53, -0.5, -2.0**-54], 2.0**53-1.0),
            ([2.0**53, 1.0, 2.0**-100], 2.0**53+2.0),
            ([2.0**53+10.0, 1.0, 2.0**-100], 2.0**53+12.0),
            ([2.0**53-4.0, 0.5, 2.0**-54], 2.0**53-3.0),
            ([1./n for n in range(1, 1001)],
             float.fromhex('0x1.df11f45f4e61ap+2')),
            ([(-1.)**n/n for n in range(1, 1001)],
             float.fromhex('-0x1.62a2af1bd3624p-1')),
            ([1.7**(i+1)-1.7**i for i in range(1000)] + [-1.7**1000], -1.0),
            ([1e16, 1., 1e-16], 10000000000000002.0),
            ([1e16-2., 1.-2.**-53, -(1e16-2.), -(1.-2.**-53)], 0.0),
            # exercise code for resizing partials array
            ([2.**n - 2.**(n+50) + 2.**(n+52) for n in range(-1074, 972, 2)] +
             [-2.**1022],
             float.fromhex('0x1.5555555555555p+970')),
            ]

for i, (vals, expected) in enumerate(test_values):
            try:
                actual = math.fsum(vals)
            except OverflowError:
                self.fail("test %d failed: got OverflowError, expected %r "
                          "for math.fsum(%.100r)" % (i, expected, vals))
            except ValueError:
                self.fail("test %d failed: got ValueError, expected %r "
                          "for math.fsum(%.100r)" % (i, expected, vals))
            self.assertEqual(actual, expected)

from random import random, gauss, shuffle
        for j in range(1000):
            vals = [7, 1e100, -7, -1e100, -9e-20, 8e-20] * 10
            s = 0
            for i in range(200):
                v = gauss(0, random()) ** 7 - s
                s += v
                vals.append(v)
            shuffle(vals)

s = msum(vals)
            self.assertEqual(msum(vals), math.fsum(vals))

def testHypot(self):
        self.assertRaises(TypeError, math.hypot)
        self.ftest('hypot(0,0)', math.hypot(0,0), 0)
        self.ftest('hypot(3,4)', math.hypot(3,4), 5)
        self.assertEqual(math.hypot(NAN, INF), INF)
        self.assertEqual(math.hypot(INF, NAN), INF)
        self.assertEqual(math.hypot(NAN, NINF), INF)
        self.assertEqual(math.hypot(NINF, NAN), INF)
        self.assertTrue(math.isnan(math.hypot(1.0, NAN)))
        self.assertTrue(math.isnan(math.hypot(NAN, -2.0)))

def testLdexp(self):
        self.assertRaises(TypeError, math.ldexp)
        self.ftest('ldexp(0,1)', math.ldexp(0,1), 0)
        self.ftest('ldexp(1,1)', math.ldexp(1,1), 2)
        self.ftest('ldexp(1,-1)', math.ldexp(1,-1), 0.5)
        self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2)
        self.assertRaises(OverflowError, math.ldexp, 1., 1000000)
        self.assertRaises(OverflowError, math.ldexp, -1., 1000000)
        self.assertEqual(math.ldexp(1., -1000000), 0.)
        self.assertEqual(math.ldexp(-1., -1000000), -0.)
        self.assertEqual(math.ldexp(INF, 30), INF)
        self.assertEqual(math.ldexp(NINF, -213), NINF)
        self.assertTrue(math.isnan(math.ldexp(NAN, 0)))

# large second argument
        for n in [10**5, 10**10, 10**20, 10**40]:
            self.assertEqual(math.ldexp(INF, -n), INF)
            self.assertEqual(math.ldexp(NINF, -n), NINF)
            self.assertEqual(math.ldexp(1., -n), 0.)
            self.assertEqual(math.ldexp(-1., -n), -0.)
            self.assertEqual(math.ldexp(0., -n), 0.)
            self.assertEqual(math.ldexp(-0., -n), -0.)
            self.assertTrue(math.isnan(math.ldexp(NAN, -n)))

self.assertRaises(OverflowError, math.ldexp, 1., n)
            self.assertRaises(OverflowError, math.ldexp, -1., n)
            self.assertEqual(math.ldexp(0., n), 0.)
            self.assertEqual(math.ldexp(-0., n), -0.)
            self.assertEqual(math.ldexp(INF, n), INF)
            self.assertEqual(math.ldexp(NINF, n), NINF)
            self.assertTrue(math.isnan(math.ldexp(NAN, n)))

def testLog(self):
        self.assertRaises(TypeError, math.log)
        self.ftest('log(1/e)', math.log(1/math.e), -1)
        self.ftest('log(1)', math.log(1), 0)
        self.ftest('log(e)', math.log(math.e), 1)
        self.ftest('log(32,2)', math.log(32,2), 5)
        self.ftest('log(10**40, 10)', math.log(10**40, 10), 40)
        self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2)
        self.ftest('log(10**1000)', math.log(10**1000),
                   2302.5850929940457)
        self.assertRaises(ValueError, math.log, -1.5)
        self.assertRaises(ValueError, math.log, -10**1000)
        self.assertRaises(ValueError, math.log, NINF)
        self.assertEqual(math.log(INF), INF)
        self.assertTrue(math.isnan(math.log(NAN)))

def testLog1p(self):
        self.assertRaises(TypeError, math.log1p)
        n= 2**90
        self.assertAlmostEqual(math.log1p(n), math.log1p(float(n)))

@requires_IEEE_754
    def testLog2(self):
        self.assertRaises(TypeError, math.log2)

# Check some integer values
        self.assertEqual(math.log2(1), 0.0)
        self.assertEqual(math.log2(2), 1.0)
        self.assertEqual(math.log2(4), 2.0)

# Large integer values
        self.assertEqual(math.log2(2**1023), 1023.0)
        self.assertEqual(math.log2(2**1024), 1024.0)
        self.assertEqual(math.log2(2**2000), 2000.0)

self.assertRaises(ValueError, math.log2, -1.5)
        self.assertRaises(ValueError, math.log2, NINF)
        self.assertTrue(math.isnan(math.log2(NAN)))

@requires_IEEE_754
    # log2() is not accurate enough on Mac OS X Tiger (10.4)
    @support.requires_mac_ver(10, 5)
    def testLog2Exact(self):
        # Check that we get exact equality for log2 of powers of 2.
        actual = [math.log2(math.ldexp(1.0, n)) for n in range(-1074, 1024)]
        expected = [float(n) for n in range(-1074, 1024)]
        self.assertEqual(actual, expected)

def testLog10(self):
        self.assertRaises(TypeError, math.log10)
        self.ftest('log10(0.1)', math.log10(0.1), -1)
        self.ftest('log10(1)', math.log10(1), 0)
        self.ftest('log10(10)', math.log10(10), 1)
        self.ftest('log10(10**1000)', math.log10(10**1000), 1000.0)
        self.assertRaises(ValueError, math.log10, -1.5)
        self.assertRaises(ValueError, math.log10, -10**1000)
        self.assertRaises(ValueError, math.log10, NINF)
        self.assertEqual(math.log(INF), INF)
        self.assertTrue(math.isnan(math.log10(NAN)))

def testModf(self):
        self.assertRaises(TypeError, math.modf)

def testmodf(name, result, expected):
            (v1, v2), (e1, e2) = result, expected
            if abs(v1-e1) > eps or abs(v2-e2):
                self.fail('%s returned %r, expected %r'%\
                          (name, result, expected))

testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0))
        testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0))

self.assertEqual(math.modf(INF), (0.0, INF))
        self.assertEqual(math.modf(NINF), (-0.0, NINF))

modf_nan = math.modf(NAN)
        self.assertTrue(math.isnan(modf_nan[0]))
        self.assertTrue(math.isnan(modf_nan[1]))

def testPow(self):
        self.assertRaises(TypeError, math.pow)
        self.ftest('pow(0,1)', math.pow(0,1), 0)
        self.ftest('pow(1,0)', math.pow(1,0), 1)
        self.ftest('pow(2,1)', math.pow(2,1), 2)
        self.ftest('pow(2,-1)', math.pow(2,-1), 0.5)
        self.assertEqual(math.pow(INF, 1), INF)
        self.assertEqual(math.pow(NINF, 1), NINF)
        self.assertEqual((math.pow(1, INF)), 1.)
        self.assertEqual((math.pow(1, NINF)), 1.)
        self.assertTrue(math.isnan(math.pow(NAN, 1)))
        self.assertTrue(math.isnan(math.pow(2, NAN)))
        self.assertTrue(math.isnan(math.pow(0, NAN)))
        self.assertEqual(math.pow(1, NAN), 1)

# pow(0., x)
        self.assertEqual(math.pow(0., INF), 0.)
        self.assertEqual(math.pow(0., 3.), 0.)
        self.assertEqual(math.pow(0., 2.3), 0.)
        self.assertEqual(math.pow(0., 2.), 0.)
        self.assertEqual(math.pow(0., 0.), 1.)
        self.assertEqual(math.pow(0., -0.), 1.)
        self.assertRaises(ValueError, math.pow, 0., -2.)
        self.assertRaises(ValueError, math.pow, 0., -2.3)
        self.assertRaises(ValueError, math.pow, 0., -3.)
        self.assertRaises(ValueError, math.pow, 0., NINF)
        self.assertTrue(math.isnan(math.pow(0., NAN)))

# pow(INF, x)
        self.assertEqual(math.pow(INF, INF), INF)
        self.assertEqual(math.pow(INF, 3.), INF)
        self.assertEqual(math.pow(INF, 2.3), INF)
        self.assertEqual(math.pow(INF, 2.), INF)
        self.assertEqual(math.pow(INF, 0.), 1.)
        self.assertEqual(math.pow(INF, -0.), 1.)
        self.assertEqual(math.pow(INF, -2.), 0.)
        self.assertEqual(math.pow(INF, -2.3), 0.)
        self.assertEqual(math.pow(INF, -3.), 0.)
        self.assertEqual(math.pow(INF, NINF), 0.)
        self.assertTrue(math.isnan(math.pow(INF, NAN)))

# pow(-0., x)
        self.assertEqual(math.pow(-0., INF), 0.)
        self.assertEqual(math.pow(-0., 3.), -0.)
        self.assertEqual(math.pow(-0., 2.3), 0.)
        self.assertEqual(math.pow(-0., 2.), 0.)
        self.assertEqual(math.pow(-0., 0.), 1.)
        self.assertEqual(math.pow(-0., -0.), 1.)
        self.assertRaises(ValueError, math.pow, -0., -2.)
        self.assertRaises(ValueError, math.pow, -0., -2.3)
        self.assertRaises(ValueError, math.pow, -0., -3.)
        self.assertRaises(ValueError, math.pow, -0., NINF)
        self.assertTrue(math.isnan(math.pow(-0., NAN)))

# pow(NINF, x)
        self.assertEqual(math.pow(NINF, INF), INF)
        self.assertEqual(math.pow(NINF, 3.), NINF)
        self.assertEqual(math.pow(NINF, 2.3), INF)
        self.assertEqual(math.pow(NINF, 2.), INF)
        self.assertEqual(math.pow(NINF, 0.), 1.)
        self.assertEqual(math.pow(NINF, -0.), 1.)
        self.assertEqual(math.pow(NINF, -2.), 0.)
        self.assertEqual(math.pow(NINF, -2.3), 0.)
        self.assertEqual(math.pow(NINF, -3.), -0.)
        self.assertEqual(math.pow(NINF, NINF), 0.)
        self.assertTrue(math.isnan(math.pow(NINF, NAN)))

# pow(-1, x)
        self.assertEqual(math.pow(-1., INF), 1.)
        self.assertEqual(math.pow(-1., 3.), -1.)
        self.assertRaises(ValueError, math.pow, -1., 2.3)
        self.assertEqual(math.pow(-1., 2.), 1.)
        self.assertEqual(math.pow(-1., 0.), 1.)
        self.assertEqual(math.pow(-1., -0.), 1.)
        self.assertEqual(math.pow(-1., -2.), 1.)
        self.assertRaises(ValueError, math.pow, -1., -2.3)
        self.assertEqual(math.pow(-1., -3.), -1.)
        self.assertEqual(math.pow(-1., NINF), 1.)
        self.assertTrue(math.isnan(math.pow(-1., NAN)))

# pow(1, x)
        self.assertEqual(math.pow(1., INF), 1.)
        self.assertEqual(math.pow(1., 3.), 1.)
        self.assertEqual(math.pow(1., 2.3), 1.)
        self.assertEqual(math.pow(1., 2.), 1.)
        self.assertEqual(math.pow(1., 0.), 1.)
        self.assertEqual(math.pow(1., -0.), 1.)
        self.assertEqual(math.pow(1., -2.), 1.)
        self.assertEqual(math.pow(1., -2.3), 1.)
        self.assertEqual(math.pow(1., -3.), 1.)
        self.assertEqual(math.pow(1., NINF), 1.)
        self.assertEqual(math.pow(1., NAN), 1.)

# pow(x, 0) should be 1 for any x
        self.assertEqual(math.pow(2.3, 0.), 1.)
        self.assertEqual(math.pow(-2.3, 0.), 1.)
        self.assertEqual(math.pow(NAN, 0.), 1.)
        self.assertEqual(math.pow(2.3, -0.), 1.)
        self.assertEqual(math.pow(-2.3, -0.), 1.)
        self.assertEqual(math.pow(NAN, -0.), 1.)

# pow(x, y) is invalid if x is negative and y is not integral
        self.assertRaises(ValueError, math.pow, -1., 2.3)
        self.assertRaises(ValueError, math.pow, -15., -3.1)

# pow(x, NINF)
        self.assertEqual(math.pow(1.9, NINF), 0.)
        self.assertEqual(math.pow(1.1, NINF), 0.)
        self.assertEqual(math.pow(0.9, NINF), INF)
        self.assertEqual(math.pow(0.1, NINF), INF)
        self.assertEqual(math.pow(-0.1, NINF), INF)
        self.assertEqual(math.pow(-0.9, NINF), INF)
        self.assertEqual(math.pow(-1.1, NINF), 0.)
        self.assertEqual(math.pow(-1.9, NINF), 0.)

# pow(x, INF)
        self.assertEqual(math.pow(1.9, INF), INF)
        self.assertEqual(math.pow(1.1, INF), INF)
        self.assertEqual(math.pow(0.9, INF), 0.)
        self.assertEqual(math.pow(0.1, INF), 0.)
        self.assertEqual(math.pow(-0.1, INF), 0.)
        self.assertEqual(math.pow(-0.9, INF), 0.)
        self.assertEqual(math.pow(-1.1, INF), INF)
        self.assertEqual(math.pow(-1.9, INF), INF)

# pow(x, y) should work for x negative, y an integer
        self.ftest('(-2.)**3.', math.pow(-2.0, 3.0), -8.0)
        self.ftest('(-2.)**2.', math.pow(-2.0, 2.0), 4.0)
        self.ftest('(-2.)**1.', math.pow(-2.0, 1.0), -2.0)
        self.ftest('(-2.)**0.', math.pow(-2.0, 0.0), 1.0)
        self.ftest('(-2.)**-0.', math.pow(-2.0, -0.0), 1.0)
        self.ftest('(-2.)**-1.', math.pow(-2.0, -1.0), -0.5)
        self.ftest('(-2.)**-2.', math.pow(-2.0, -2.0), 0.25)
        self.ftest('(-2.)**-3.', math.pow(-2.0, -3.0), -0.125)
        self.assertRaises(ValueError, math.pow, -2.0, -0.5)
        self.assertRaises(ValueError, math.pow, -2.0, 0.5)

# the following tests have been commented out since they don't
        # really belong here:  the implementation of ** for floats is
        # independent of the implementation of math.pow
        #self.assertEqual(1**NAN, 1)
        #self.assertEqual(1**INF, 1)
        #self.assertEqual(1**NINF, 1)
        #self.assertEqual(1**0, 1)
        #self.assertEqual(1.**NAN, 1)
        #self.assertEqual(1.**INF, 1)
        #self.assertEqual(1.**NINF, 1)
        #self.assertEqual(1.**0, 1)

def testRadians(self):
        self.assertRaises(TypeError, math.radians)
        self.ftest('radians(180)', math.radians(180), math.pi)
        self.ftest('radians(90)', math.radians(90), math.pi/2)
        self.ftest('radians(-45)', math.radians(-45), -math.pi/4)

def testSin(self):
        self.assertRaises(TypeError, math.sin)
        self.ftest('sin(0)', math.sin(0), 0)
        self.ftest('sin(pi/2)', math.sin(math.pi/2), 1)
        self.ftest('sin(-pi/2)', math.sin(-math.pi/2), -1)
        try:
            self.assertTrue(math.isnan(math.sin(INF)))
            self.assertTrue(math.isnan(math.sin(NINF)))
        except ValueError:
            self.assertRaises(ValueError, math.sin, INF)
            self.assertRaises(ValueError, math.sin, NINF)
        self.assertTrue(math.isnan(math.sin(NAN)))

def testSinh(self):
        self.assertRaises(TypeError, math.sinh)
        self.ftest('sinh(0)', math.sinh(0), 0)
        self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1)
        self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0)
        self.assertEqual(math.sinh(INF), INF)
        self.assertEqual(math.sinh(NINF), NINF)
        self.assertTrue(math.isnan(math.sinh(NAN)))

def testSqrt(self):
        self.assertRaises(TypeError, math.sqrt)
        self.ftest('sqrt(0)', math.sqrt(0), 0)
        self.ftest('sqrt(1)', math.sqrt(1), 1)
        self.ftest('sqrt(4)', math.sqrt(4), 2)
        self.assertEqual(math.sqrt(INF), INF)
        self.assertRaises(ValueError, math.sqrt, NINF)
        self.assertTrue(math.isnan(math.sqrt(NAN)))

def testTan(self):
        self.assertRaises(TypeError, math.tan)
        self.ftest('tan(0)', math.tan(0), 0)
        self.ftest('tan(pi/4)', math.tan(math.pi/4), 1)
        self.ftest('tan(-pi/4)', math.tan(-math.pi/4), -1)
        try:
            self.assertTrue(math.isnan(math.tan(INF)))
            self.assertTrue(math.isnan(math.tan(NINF)))
        except:
            self.assertRaises(ValueError, math.tan, INF)
            self.assertRaises(ValueError, math.tan, NINF)
        self.assertTrue(math.isnan(math.tan(NAN)))

def testTanh(self):
        self.assertRaises(TypeError, math.tanh)
        self.ftest('tanh(0)', math.tanh(0), 0)
        self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0)
        self.ftest('tanh(inf)', math.tanh(INF), 1)
        self.ftest('tanh(-inf)', math.tanh(NINF), -1)
        self.assertTrue(math.isnan(math.tanh(NAN)))

@requires_IEEE_754
    @unittest.skipIf(sysconfig.get_config_var('TANH_PRESERVES_ZERO_SIGN') == 0,
                     "system tanh() function doesn't copy the sign")
    def testTanhSign(self):
        # check that tanh(-0.) == -0. on IEEE 754 systems
        self.assertEqual(math.tanh(-0.), -0.)
        self.assertEqual(math.copysign(1., math.tanh(-0.)),
                         math.copysign(1., -0.))

def test_trunc(self):
        self.assertEqual(math.trunc(1), 1)
        self.assertEqual(math.trunc(-1), -1)
        self.assertEqual(type(math.trunc(1)), int)
        self.assertEqual(type(math.trunc(1.5)), int)
        self.assertEqual(math.trunc(1.5), 1)
        self.assertEqual(math.trunc(-1.5), -1)
        self.assertEqual(math.trunc(1.999999), 1)
        self.assertEqual(math.trunc(-1.999999), -1)
        self.assertEqual(math.trunc(-0.999999), -0)
        self.assertEqual(math.trunc(-100.999), -100)

class TestTrunc(object):
            def __trunc__(self):
                return 23

class TestNoTrunc(object):
            pass

self.assertEqual(math.trunc(TestTrunc()), 23)

self.assertRaises(TypeError, math.trunc)
        self.assertRaises(TypeError, math.trunc, 1, 2)
        self.assertRaises(TypeError, math.trunc, TestNoTrunc())

def testIsfinite(self):
        self.assertTrue(math.isfinite(0.0))
        self.assertTrue(math.isfinite(-0.0))
        self.assertTrue(math.isfinite(1.0))
        self.assertTrue(math.isfinite(-1.0))
        self.assertFalse(math.isfinite(float("nan")))
        self.assertFalse(math.isfinite(float("inf")))
        self.assertFalse(math.isfinite(float("-inf")))

def testIsnan(self):
        self.assertTrue(math.isnan(float("nan")))
        self.assertTrue(math.isnan(float("inf")* 0.))
        self.assertFalse(math.isnan(float("inf")))
        self.assertFalse(math.isnan(0.))
        self.assertFalse(math.isnan(1.))

def testIsinf(self):
        self.assertTrue(math.isinf(float("inf")))
        self.assertTrue(math.isinf(float("-inf")))
        self.assertTrue(math.isinf(1E400))
        self.assertTrue(math.isinf(-1E400))
        self.assertFalse(math.isinf(float("nan")))
        self.assertFalse(math.isinf(0.))
        self.assertFalse(math.isinf(1.))

# RED_FLAG 16-Oct-2000 Tim
    # While 2.0 is more consistent about exceptions than previous releases, it
    # still fails this part of the test on some platforms.  For now, we only
    # *run* test_exceptions() in verbose mode, so that this isn't normally
    # tested.
    @unittest.skipUnless(verbose, 'requires verbose mode')
    def test_exceptions(self):
        try:
            x = math.exp(-1000000000)
        except:
            # mathmodule.c is failing to weed out underflows from libm, or
            # we've got an fp format with huge dynamic range
            self.fail("underflowing exp() should not have raised "
                        "an exception")
        if x != 0:
            self.fail("underflowing exp() should have returned 0")

# If this fails, probably using a strict IEEE-754 conforming libm, and x
        # is +Inf afterwards.  But Python wants overflows detected by default.
        try:
            x = math.exp(1000000000)
        except OverflowError:
            pass
        else:
            self.fail("overflowing exp() didn't trigger OverflowError")

# If this fails, it could be a puzzle.  One odd possibility is that
        # mathmodule.c's macros are getting confused while comparing
        # Inf (HUGE_VAL) to a NaN, and artificially setting errno to ERANGE
        # as a result (and so raising OverflowError instead).
        try:
            x = math.sqrt(-1.0)
        except ValueError:
            pass
        else:
            self.fail("sqrt(-1) didn't raise ValueError")

@requires_IEEE_754
    def test_testfile(self):
        for id, fn, ar, ai, er, ei, flags in parse_testfile(test_file):
            # Skip if either the input or result is complex, or if
            # flags is nonempty
            if ai != 0. or ei != 0. or flags:
                continue
            if fn in ['rect', 'polar']:
                # no real versions of rect, polar
                continue
            func = getattr(math, fn)
            try:
                result = func(ar)
            except ValueError as exc:
                message = (("Unexpected ValueError: %s\n        " +
                           "in test %s:%s(%r)\n") % (exc.args[0], id, fn, ar))
                self.fail(message)
            except OverflowError:
                message = ("Unexpected OverflowError in " +
                           "test %s:%s(%r)\n" % (id, fn, ar))
                self.fail(message)
            self.ftest("%s:%s(%r)" % (id, fn, ar), result, er)

@requires_IEEE_754
    def test_mtestfile(self):
        fail_fmt = "{}:{}({!r}): expected {!r}, got {!r}"

failures = []
        for id, fn, arg, expected, flags in parse_mtestfile(math_testcases):
            func = getattr(math, fn)

if 'invalid' in flags or 'divide-by-zero' in flags:
                expected = 'ValueError'
            elif 'overflow' in flags:
                expected = 'OverflowError'

try:
                got = func(arg)
            except ValueError:
                got = 'ValueError'
            except OverflowError:
                got = 'OverflowError'

accuracy_failure = None
            if isinstance(got, float) and isinstance(expected, float):
                if math.isnan(expected) and math.isnan(got):
                    continue
                if not math.isnan(expected) and not math.isnan(got):
                    if fn == 'lgamma':
                        # we use a weaker accuracy test for lgamma;
                        # lgamma only achieves an absolute error of
                        # a few multiples of the machine accuracy, in
                        # general.
                        accuracy_failure = acc_check(expected, got,
                                                  rel_err = 5e-15,
                                                  abs_err = 5e-15)
                    elif fn == 'erfc':
                        # erfc has less-than-ideal accuracy for large
                        # arguments (x ~ 25 or so), mainly due to the
                        # error involved in computing exp(-x*x).
                        #
                        # XXX Would be better to weaken this test only
                        # for large x, instead of for all x.
                        accuracy_failure = ulps_check(expected, got, 2000)

else:
                        accuracy_failure = ulps_check(expected, got, 20)
                    if accuracy_failure is None:
                        continue

if isinstance(got, str) and isinstance(expected, str):
                if got == expected:
                    continue

fail_msg = fail_fmt.format(id, fn, arg, expected, got)
            if accuracy_failure is not None:
                fail_msg += ' ({})'.format(accuracy_failure)
            failures.append(fail_msg)

if failures:
            self.fail('Failures in test_mtestfile:\n  ' +
                      '\n  '.join(failures))

def test_main():
    from doctest import DocFileSuite
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(MathTests))
    suite.addTest(DocFileSuite("ieee754.txt"))
    run_unittest(suite)

if __name__ == '__main__':
    test_main()