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

# test for xml.dom.minidom

import pickle
from test.support import run_unittest, findfile
import unittest

import xml.dom.minidom

from xml.dom.minidom import parse, Node, Document, parseString
from xml.dom.minidom import getDOMImplementation

tstfile = findfile("test.xml", subdir="xmltestdata")

# The tests of DocumentType importing use these helpers to construct
# the documents to work with, since not all DOM builders actually
# create the DocumentType nodes.
def create_doc_without_doctype(doctype=None):
    return getDOMImplementation().createDocument(None, "doc", doctype)

def create_nonempty_doctype():
    doctype = getDOMImplementation().createDocumentType("doc", None, None)
    doctype.entities._seq = []
    doctype.notations._seq = []
    notation = xml.dom.minidom.Notation("my-notation", None,
                                        "http://xml.python.org/notations/my")
    doctype.notations._seq.append(notation)
    entity = xml.dom.minidom.Entity("my-entity", None,
                                    "http://xml.python.org/entities/my",
                                    "my-notation")
    entity.version = "1.0"
    entity.encoding = "utf-8"
    entity.actualEncoding = "us-ascii"
    doctype.entities._seq.append(entity)
    return doctype

def create_doc_with_doctype():
    doctype = create_nonempty_doctype()
    doc = create_doc_without_doctype(doctype)
    doctype.entities.item(0).ownerDocument = doc
    doctype.notations.item(0).ownerDocument = doc
    return doc

class MinidomTest(unittest.TestCase):
    def confirm(self, test, testname = "Test"):
        self.assertTrue(test, testname)

def checkWholeText(self, node, s):
        t = node.wholeText
        self.confirm(t == s, "looking for %r, found %r" % (s, t))

def testParseFromFile(self):
        with open(tstfile) as file:
            dom = parse(file)
            dom.unlink()
            self.confirm(isinstance(dom, Document))

def testGetElementsByTagName(self):
        dom = parse(tstfile)
        self.confirm(dom.getElementsByTagName("LI") == \
                dom.documentElement.getElementsByTagName("LI"))
        dom.unlink()

def testInsertBefore(self):
 dom = parseString("<doc><foo/></doc>")
 root = dom.documentElement
 elem = root.childNodes[0]
 nelem = dom.createElement("element")
 root.insertBefore(nelem, elem)
 self.confirm(len(root.childNodes) == 2
 and root.childNodes.length == 2
 and root.childNodes[0] is nelem
 and root.childNodes.item(0) is nelem
 and root.childNodes[1] is elem
 and root.childNodes.item(1) is elem
 and root.firstChild is nelem
 and root.lastChild is elem
 and root.toxml() == "<doc><element/><foo/></doc>"
 , "testInsertBefore -- node properly placed in tree")
 nelem = dom.createElement("element")
 root.insertBefore(nelem, None)
 self.confirm(len(root.childNodes) == 3
 and root.childNodes.length == 3
 and root.childNodes[1] is elem
 and root.childNodes.item(1) is elem
 and root.childNodes[2] is nelem
 and root.childNodes.item(2) is nelem
 and root.lastChild is nelem
 and nelem.previousSibling is elem
 and root.toxml() == "<doc><element/><foo/><element/></doc>"
 , "testInsertBefore -- node properly placed in tree")
 nelem2 = dom.createElement("bar")
 root.insertBefore(nelem2, nelem)
 self.confirm(len(root.childNodes) == 4
 and root.childNodes.length == 4
 and root.childNodes[2] is nelem2
 and root.childNodes.item(2) is nelem2
 and root.childNodes[3] is nelem
 and root.childNodes.item(3) is nelem
 and nelem2.nextSibling is nelem
 and nelem.previousSibling is nelem2
 and root.toxml() ==
 "<doc><element/><foo/><bar/><element/></doc>"
 , "testInsertBefore -- node properly placed in tree")
 dom.unlink()

def _create_fragment_test_nodes(self):
 dom = parseString("<doc/>")
 orig = dom.createTextNode("original")
 c1 = dom.createTextNode("foo")
 c2 = dom.createTextNode("bar")
 c3 = dom.createTextNode("bat")
 dom.documentElement.appendChild(orig)
 frag = dom.createDocumentFragment()
 frag.appendChild(c1)
 frag.appendChild(c2)
 frag.appendChild(c3)
 return dom, orig, c1, c2, c3, frag

def testInsertBeforeFragment(self):
 dom, orig, c1, c2, c3, frag = self._create_fragment_test_nodes()
 dom.documentElement.insertBefore(frag, None)
 self.confirm(tuple(dom.documentElement.childNodes) ==
 (orig, c1, c2, c3),
 "insertBefore(<fragment>, None)")
 frag.unlink()
 dom.unlink()

dom, orig, c1, c2, c3, frag = self._create_fragment_test_nodes()
 dom.documentElement.insertBefore(frag, orig)
 self.confirm(tuple(dom.documentElement.childNodes) ==
 (c1, c2, c3, orig),
 "insertBefore(<fragment>, orig)")
 frag.unlink()
 dom.unlink()

def testAppendChild(self):
        dom = parse(tstfile)
        dom.documentElement.appendChild(dom.createComment("Hello"))
        self.confirm(dom.documentElement.childNodes[-1].nodeName == "#comment")
        self.confirm(dom.documentElement.childNodes[-1].data == "Hello")
        dom.unlink()

def testAppendChildFragment(self):
 dom, orig, c1, c2, c3, frag = self._create_fragment_test_nodes()
 dom.documentElement.appendChild(frag)
 self.confirm(tuple(dom.documentElement.childNodes) ==
 (orig, c1, c2, c3),
 "appendChild(<fragment>)")
 frag.unlink()
 dom.unlink()

def testReplaceChildFragment(self):
 dom, orig, c1, c2, c3, frag = self._create_fragment_test_nodes()
 dom.documentElement.replaceChild(frag, orig)
 orig.unlink()
 self.confirm(tuple(dom.documentElement.childNodes) == (c1, c2, c3),
 "replaceChild(<fragment>)")
 frag.unlink()
 dom.unlink()

def testLegalChildren(self):
        dom = Document()
        elem = dom.createElement('element')
        text = dom.createTextNode('text')
        self.assertRaises(xml.dom.HierarchyRequestErr, dom.appendChild, text)

dom.appendChild(elem)
        self.assertRaises(xml.dom.HierarchyRequestErr, dom.insertBefore, text,
                          elem)
        self.assertRaises(xml.dom.HierarchyRequestErr, dom.replaceChild, text,
                          elem)

nodemap = elem.attributes
        self.assertRaises(xml.dom.HierarchyRequestErr, nodemap.setNamedItem,
                          text)
        self.assertRaises(xml.dom.HierarchyRequestErr, nodemap.setNamedItemNS,
                          text)

elem.appendChild(text)
        dom.unlink()

def testNamedNodeMapSetItem(self):
        dom = Document()
        elem = dom.createElement('element')
        attrs = elem.attributes
        attrs["foo"] = "bar"
        a = attrs.item(0)
        self.confirm(a.ownerDocument is dom,
                "NamedNodeMap.__setitem__() sets ownerDocument")
        self.confirm(a.ownerElement is elem,
                "NamedNodeMap.__setitem__() sets ownerElement")
        self.confirm(a.value == "bar",
                "NamedNodeMap.__setitem__() sets value")
        self.confirm(a.nodeValue == "bar",
                "NamedNodeMap.__setitem__() sets nodeValue")
        elem.unlink()
        dom.unlink()

def testNonZero(self):
        dom = parse(tstfile)
        self.confirm(dom)# should not be zero
        dom.appendChild(dom.createComment("foo"))
        self.confirm(not dom.childNodes[-1].childNodes)
        dom.unlink()

def testUnlink(self):
        dom = parse(tstfile)
        self.assertTrue(dom.childNodes)
        dom.unlink()
        self.assertFalse(dom.childNodes)

def testContext(self):
        with parse(tstfile) as dom:
            self.assertTrue(dom.childNodes)
        self.assertFalse(dom.childNodes)

def testElement(self):
        dom = Document()
        dom.appendChild(dom.createElement("abc"))
        self.confirm(dom.documentElement)
        dom.unlink()

def testAAA(self):
 dom = parseString("<abc/>")
 el = dom.documentElement
 el.setAttribute("spam", "jam2")
 self.confirm(el.toxml() == '<abc spam="jam2"/>', "testAAA")
 a = el.getAttributeNode("spam")
 self.confirm(a.ownerDocument is dom,
 "setAttribute() sets ownerDocument")
 self.confirm(a.ownerElement is dom.documentElement,
 "setAttribute() sets ownerElement")
 dom.unlink()

def testAAB(self):
 dom = parseString("<abc/>")
 el = dom.documentElement
 el.setAttribute("spam", "jam")
 el.setAttribute("spam", "jam2")
 self.confirm(el.toxml() == '<abc spam="jam2"/>', "testAAB")
 dom.unlink()

def testAddAttr(self):
        dom = Document()
        child = dom.appendChild(dom.createElement("abc"))

child.setAttribute("def", "ghi")
        self.confirm(child.getAttribute("def") == "ghi")
        self.confirm(child.attributes["def"].value == "ghi")

child.setAttribute("jkl", "mno")
        self.confirm(child.getAttribute("jkl") == "mno")
        self.confirm(child.attributes["jkl"].value == "mno")

self.confirm(len(child.attributes) == 2)

child.setAttribute("def", "newval")
        self.confirm(child.getAttribute("def") == "newval")
        self.confirm(child.attributes["def"].value == "newval")

self.confirm(len(child.attributes) == 2)
        dom.unlink()

def testDeleteAttr(self):
        dom = Document()
        child = dom.appendChild(dom.createElement("abc"))

self.confirm(len(child.attributes) == 0)
        child.setAttribute("def", "ghi")
        self.confirm(len(child.attributes) == 1)
        del child.attributes["def"]
        self.confirm(len(child.attributes) == 0)
        dom.unlink()

def testRemoveAttr(self):
        dom = Document()
        child = dom.appendChild(dom.createElement("abc"))

child.setAttribute("def", "ghi")
        self.confirm(len(child.attributes) == 1)
        self.assertRaises(xml.dom.NotFoundErr, child.removeAttribute, "foo")
        child.removeAttribute("def")
        self.confirm(len(child.attributes) == 0)
        dom.unlink()

def testRemoveAttrNS(self):
        dom = Document()
        child = dom.appendChild(
                dom.createElementNS("http://www.python.org", "python:abc"))
        child.setAttributeNS("http://www.w3.org", "xmlns:python",
                                                "http://www.python.org")
        child.setAttributeNS("http://www.python.org", "python:abcattr", "foo")
        self.assertRaises(xml.dom.NotFoundErr, child.removeAttributeNS,
            "foo", "http://www.python.org")
        self.confirm(len(child.attributes) == 2)
        child.removeAttributeNS("http://www.python.org", "abcattr")
        self.confirm(len(child.attributes) == 1)
        dom.unlink()

def testRemoveAttributeNode(self):
        dom = Document()
        child = dom.appendChild(dom.createElement("foo"))
        child.setAttribute("spam", "jam")
        self.confirm(len(child.attributes) == 1)
        node = child.getAttributeNode("spam")
        self.assertRaises(xml.dom.NotFoundErr, child.removeAttributeNode,
            None)
        child.removeAttributeNode(node)
        self.confirm(len(child.attributes) == 0
                and child.getAttributeNode("spam") is None)
        dom2 = Document()
        child2 = dom2.appendChild(dom2.createElement("foo"))
        node2 = child2.getAttributeNode("spam")
        self.assertRaises(xml.dom.NotFoundErr, child2.removeAttributeNode,
            node2)
        dom.unlink()

def testHasAttribute(self):
        dom = Document()
        child = dom.appendChild(dom.createElement("foo"))
        child.setAttribute("spam", "jam")
        self.confirm(child.hasAttribute("spam"))

def testChangeAttr(self):
 dom = parseString("<abc/>")
 el = dom.documentElement
 el.setAttribute("spam", "jam")
 self.confirm(len(el.attributes) == 1)
 el.setAttribute("spam", "bam")
 # Set this attribute to be an ID and make sure that doesn't change
 # when changing the value:
 el.setIdAttribute("spam")
 self.confirm(len(el.attributes) == 1
 and el.attributes["spam"].value == "bam"
 and el.attributes["spam"].nodeValue == "bam"
 and el.getAttribute("spam") == "bam"
 and el.getAttributeNode("spam").isId)
 el.attributes["spam"] = "ham"
 self.confirm(len(el.attributes) == 1
 and el.attributes["spam"].value == "ham"
 and el.attributes["spam"].nodeValue == "ham"
 and el.getAttribute("spam") == "ham"
 and el.attributes["spam"].isId)
 el.setAttribute("spam2", "bam")
 self.confirm(len(el.attributes) == 2
 and el.attributes["spam"].value == "ham"
 and el.attributes["spam"].nodeValue == "ham"
 and el.getAttribute("spam") == "ham"
 and el.attributes["spam2"].value == "bam"
 and el.attributes["spam2"].nodeValue == "bam"
 and el.getAttribute("spam2") == "bam")
 el.attributes["spam2"] = "bam2"
 self.confirm(len(el.attributes) == 2
 and el.attributes["spam"].value == "ham"
 and el.attributes["spam"].nodeValue == "ham"
 and el.getAttribute("spam") == "ham"
 and el.attributes["spam2"].value == "bam2"
 and el.attributes["spam2"].nodeValue == "bam2"
 and el.getAttribute("spam2") == "bam2")
 dom.unlink()

def testGetAttribute(self):
        dom = Document()
        child = dom.appendChild(
            dom.createElementNS("http://www.python.org", "python:abc"))
        self.assertEqual(child.getAttribute('missing'), '')

def testGetAttributeNS(self):
        dom = Document()
        child = dom.appendChild(
                dom.createElementNS("http://www.python.org", "python:abc"))
        child.setAttributeNS("http://www.w3.org", "xmlns:python",
                                                "http://www.python.org")
        self.assertEqual(child.getAttributeNS("http://www.w3.org", "python"),
            'http://www.python.org')
        self.assertEqual(child.getAttributeNS("http://www.w3.org", "other"),
            '')
        child2 = child.appendChild(dom.createElement('abc'))
        self.assertEqual(child2.getAttributeNS("http://www.python.org", "missing"),
                         '')

def testGetElementsByTagNameNS(self):
 d="""<foo xmlns:minidom='http://pyxml.sf.net/minidom'>
 <minidom:myelem/>
 </foo>"""
 dom = parseString(d)
 elems = dom.getElementsByTagNameNS("http://pyxml.sf.net/minidom",
 "myelem")
 self.confirm(len(elems) == 1
 and elems[0].namespaceURI == "http://pyxml.sf.net/minidom"
 and elems[0].localName == "myelem"
 and elems[0].prefix == "minidom"
 and elems[0].tagName == "minidom:myelem"
 and elems[0].nodeName == "minidom:myelem")
 dom.unlink()

def get_empty_nodelist_from_elements_by_tagName_ns_helper(self, doc, nsuri,
                                                              lname):
        nodelist = doc.getElementsByTagNameNS(nsuri, lname)
        self.confirm(len(nodelist) == 0)

def testGetEmptyNodeListFromElementsByTagNameNS(self):
 doc = parseString('<doc/>')
 self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
 doc, 'http://xml.python.org/namespaces/a', 'localname')
 self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
 doc, '*', 'splat')
 self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
 doc, 'http://xml.python.org/namespaces/a', '*')

doc = parseString('<doc xmlns="http://xml.python.org/splat"><e/></doc>')
 self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
 doc, "http://xml.python.org/splat", "not-there")
 self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
 doc, "*", "not-there")
 self.get_empty_nodelist_from_elements_by_tagName_ns_helper(
 doc, "http://somewhere.else.net/not-there", "e")

def testElementReprAndStr(self):
        dom = Document()
        el = dom.appendChild(dom.createElement("abc"))
        string1 = repr(el)
        string2 = str(el)
        self.confirm(string1 == string2)
        dom.unlink()

def testElementReprAndStrUnicode(self):
        dom = Document()
        el = dom.appendChild(dom.createElement("abc"))
        string1 = repr(el)
        string2 = str(el)
        self.confirm(string1 == string2)
        dom.unlink()

def testElementReprAndStrUnicodeNS(self):
        dom = Document()
        el = dom.appendChild(
            dom.createElementNS("http://www.slashdot.org", "slash:abc"))
        string1 = repr(el)
        string2 = str(el)
        self.confirm(string1 == string2)
        self.confirm("slash:abc" in string1)
        dom.unlink()

def testAttributeRepr(self):
        dom = Document()
        el = dom.appendChild(dom.createElement("abc"))
        node = el.setAttribute("abc", "def")
        self.confirm(str(node) == repr(node))
        dom.unlink()

def testWriteXML(self):
 str = '<?xml version="1.0" ?><a b="c"/>'
 dom = parseString(str)
 domstr = dom.toxml()
 dom.unlink()
 self.confirm(str == domstr)

def testAltNewline(self):
 str = '<?xml version="1.0" ?>\n<a b="c"/>\n'
 dom = parseString(str)
 domstr = dom.toprettyxml(newl="\r\n")
 dom.unlink()
 self.confirm(domstr == str.replace("\n", "\r\n"))

def test_toprettyxml_with_text_nodes(self):
 # see issue #4147, text nodes are not indented
 decl = '<?xml version="1.0" ?>\n'
 self.assertEqual(parseString('A').toprettyxml(),
 decl + 'A\n')
 self.assertEqual(parseString('<C>AA</C>').toprettyxml(),
 decl + '<C>\n\tA\n\tA\n</C>\n')
 self.assertEqual(parseString('<C>AA</C>').toprettyxml(),
 decl + '<C>\n\tA\n\tA\n</C>\n')
 self.assertEqual(parseString('<C>AA</C>').toprettyxml(),
 decl + '<C>\n\tA\n\tA\n</C>\n')
 self.assertEqual(parseString('<C>AAA</C>').toprettyxml(),
 decl + '<C>\n\tA\n\tA\n\tA\n</C>\n')

def test_toprettyxml_with_adjacent_text_nodes(self):
 # see issue #4147, adjacent text nodes are indented normally
 dom = Document()
 elem = dom.createElement('elem')
 elem.appendChild(dom.createTextNode('TEXT'))
 elem.appendChild(dom.createTextNode('TEXT'))
 dom.appendChild(elem)
 decl = '<?xml version="1.0" ?>\n'
 self.assertEqual(dom.toprettyxml(),
 decl + '<elem>\n\tTEXT\n\tTEXT\n</elem>\n')

def test_toprettyxml_preserves_content_of_text_node(self):
 # see issue #4147
 for str in ('A', '<A>C</A>'):
 dom = parseString(str)
 dom2 = parseString(dom.toprettyxml())
 self.assertEqual(
 dom.getElementsByTagName('B')[0].childNodes[0].toxml(),
 dom2.getElementsByTagName('B')[0].childNodes[0].toxml())

def testProcessingInstruction(self):
 dom = parseString('<e><?mypi \t\n data \t\n ?></e>')
 pi = dom.documentElement.firstChild
 self.confirm(pi.target == "mypi"
 and pi.data == "data \t\n "
 and pi.nodeName == "mypi"
 and pi.nodeType == Node.PROCESSING_INSTRUCTION_NODE
 and pi.attributes is None
 and not pi.hasChildNodes()
 and len(pi.childNodes) == 0
 and pi.firstChild is None
 and pi.lastChild is None
 and pi.localName is None
 and pi.namespaceURI == xml.dom.EMPTY_NAMESPACE)

def testTooManyDocumentElements(self):
 doc = parseString("<doc/>")
 elem = doc.createElement("extra")
 # Should raise an exception when adding an extra document element.
 self.assertRaises(xml.dom.HierarchyRequestErr, doc.appendChild, elem)
 elem.unlink()
 doc.unlink()

def testRemoveNamedItem(self):
 doc = parseString("<doc a=''/>")
 e = doc.documentElement
 attrs = e.attributes
 a1 = e.getAttributeNode("a")
 a2 = attrs.removeNamedItem("a")
 self.confirm(a1.isSameNode(a2))
 self.assertRaises(xml.dom.NotFoundErr, attrs.removeNamedItem, "a")

def testRemoveNamedItemNS(self):
 doc = parseString("<doc xmlns:a='http://xml.python.org/' a:b=''/>")
 e = doc.documentElement
 attrs = e.attributes
 a1 = e.getAttributeNodeNS("http://xml.python.org/", "b")
 a2 = attrs.removeNamedItemNS("http://xml.python.org/", "b")
 self.confirm(a1.isSameNode(a2))
 self.assertRaises(xml.dom.NotFoundErr, attrs.removeNamedItemNS,
 "http://xml.python.org/", "b")

def testHasChildNodes(self):
 dom = parseString("<doc><foo/></doc>")
 doc = dom.documentElement
 self.assertTrue(doc.hasChildNodes())
 dom2 = parseString("<doc/>")
 doc2 = dom2.documentElement
 self.assertFalse(doc2.hasChildNodes())

def _testCloneElementCopiesAttributes(self, e1, e2, test):
        attrs1 = e1.attributes
        attrs2 = e2.attributes
        keys1 = list(attrs1.keys())
        keys2 = list(attrs2.keys())
        keys1.sort()
        keys2.sort()
        self.confirm(keys1 == keys2, "clone of element has same attribute keys")
        for i in range(len(keys1)):
            a1 = attrs1.item(i)
            a2 = attrs2.item(i)
            self.confirm(a1 is not a2
                    and a1.value == a2.value
                    and a1.nodeValue == a2.nodeValue
                    and a1.namespaceURI == a2.namespaceURI
                    and a1.localName == a2.localName
                    , "clone of attribute node has proper attribute values")
            self.confirm(a2.ownerElement is e2,
                    "clone of attribute node correctly owned")

def _setupCloneElement(self, deep):
 dom = parseString("<doc attr='value'><foo/></doc>")
 root = dom.documentElement
 clone = root.cloneNode(deep)
 self._testCloneElementCopiesAttributes(
 root, clone, "testCloneElement" + (deep and "Deep" or "Shallow"))
 # mutilate the original so shared data is detected
 root.tagName = root.nodeName = "MODIFIED"
 root.setAttribute("attr", "NEW VALUE")
 root.setAttribute("added", "VALUE")
 return dom, clone

def testCloneElementShallow(self):
 dom, clone = self._setupCloneElement(0)
 self.confirm(len(clone.childNodes) == 0
 and clone.childNodes.length == 0
 and clone.parentNode is None
 and clone.toxml() == '<doc attr="value"/>'
 , "testCloneElementShallow")
 dom.unlink()

def testCloneElementDeep(self):
 dom, clone = self._setupCloneElement(1)
 self.confirm(len(clone.childNodes) == 1
 and clone.childNodes.length == 1
 and clone.parentNode is None
 and clone.toxml() == '<doc attr="value"><foo/></doc>'
 , "testCloneElementDeep")
 dom.unlink()

def testCloneDocumentShallow(self):
 doc = parseString("<?xml version='1.0'?>\n"
 ""
 "<!DOCTYPE doc [\n"
 "<!NOTATION notation SYSTEM 'http://xml.python.org/'>\n"
 "]>\n"
 "<doc attr='value'/>")
 doc2 = doc.cloneNode(0)
 self.confirm(doc2 is None,
 "testCloneDocumentShallow:"
 " shallow cloning of documents makes no sense!")

def testCloneDocumentDeep(self):
 doc = parseString("<?xml version='1.0'?>\n"
 ""
 "<!DOCTYPE doc [\n"
 "<!NOTATION notation SYSTEM 'http://xml.python.org/'>\n"
 "]>\n"
 "<doc attr='value'/>")
 doc2 = doc.cloneNode(1)
 self.confirm(not (doc.isSameNode(doc2) or doc2.isSameNode(doc)),
 "testCloneDocumentDeep: document objects not distinct")
 self.confirm(len(doc.childNodes) == len(doc2.childNodes),
 "testCloneDocumentDeep: wrong number of Document children")
 self.confirm(doc2.documentElement.nodeType == Node.ELEMENT_NODE,
 "testCloneDocumentDeep: documentElement not an ELEMENT_NODE")
 self.confirm(doc2.documentElement.ownerDocument.isSameNode(doc2),
 "testCloneDocumentDeep: documentElement owner is not new document")
 self.confirm(not doc.documentElement.isSameNode(doc2.documentElement),
 "testCloneDocumentDeep: documentElement should not be shared")
 if doc.doctype is not None:
 # check the doctype iff the original DOM maintained it
 self.confirm(doc2.doctype.nodeType == Node.DOCUMENT_TYPE_NODE,
 "testCloneDocumentDeep: doctype not a DOCUMENT_TYPE_NODE")
 self.confirm(doc2.doctype.ownerDocument.isSameNode(doc2))
 self.confirm(not doc.doctype.isSameNode(doc2.doctype))

def testCloneDocumentTypeDeepOk(self):
        doctype = create_nonempty_doctype()
        clone = doctype.cloneNode(1)
        self.confirm(clone is not None
                and clone.nodeName == doctype.nodeName
                and clone.name == doctype.name
                and clone.publicId == doctype.publicId
                and clone.systemId == doctype.systemId
                and len(clone.entities) == len(doctype.entities)
                and clone.entities.item(len(clone.entities)) is None
                and len(clone.notations) == len(doctype.notations)
                and clone.notations.item(len(clone.notations)) is None
                and len(clone.childNodes) == 0)
        for i in range(len(doctype.entities)):
            se = doctype.entities.item(i)
            ce = clone.entities.item(i)
            self.confirm((not se.isSameNode(ce))
                    and (not ce.isSameNode(se))
                    and ce.nodeName == se.nodeName
                    and ce.notationName == se.notationName
                    and ce.publicId == se.publicId
                    and ce.systemId == se.systemId
                    and ce.encoding == se.encoding
                    and ce.actualEncoding == se.actualEncoding
                    and ce.version == se.version)
        for i in range(len(doctype.notations)):
            sn = doctype.notations.item(i)
            cn = clone.notations.item(i)
            self.confirm((not sn.isSameNode(cn))
                    and (not cn.isSameNode(sn))
                    and cn.nodeName == sn.nodeName
                    and cn.publicId == sn.publicId
                    and cn.systemId == sn.systemId)

def testCloneDocumentTypeDeepNotOk(self):
        doc = create_doc_with_doctype()
        clone = doc.doctype.cloneNode(1)
        self.confirm(clone is None, "testCloneDocumentTypeDeepNotOk")

def testCloneDocumentTypeShallowOk(self):
        doctype = create_nonempty_doctype()
        clone = doctype.cloneNode(0)
        self.confirm(clone is not None
                and clone.nodeName == doctype.nodeName
                and clone.name == doctype.name
                and clone.publicId == doctype.publicId
                and clone.systemId == doctype.systemId
                and len(clone.entities) == 0
                and clone.entities.item(0) is None
                and len(clone.notations) == 0
                and clone.notations.item(0) is None
                and len(clone.childNodes) == 0)

def testCloneDocumentTypeShallowNotOk(self):
        doc = create_doc_with_doctype()
        clone = doc.doctype.cloneNode(0)
        self.confirm(clone is None, "testCloneDocumentTypeShallowNotOk")

def check_import_document(self, deep, testName):
 doc1 = parseString("<doc/>")
 doc2 = parseString("<doc/>")
 self.assertRaises(xml.dom.NotSupportedErr, doc1.importNode, doc2, deep)

def testImportDocumentShallow(self):
        self.check_import_document(0, "testImportDocumentShallow")

def testImportDocumentDeep(self):
        self.check_import_document(1, "testImportDocumentDeep")

def testImportDocumentTypeShallow(self):
        src = create_doc_with_doctype()
        target = create_doc_without_doctype()
        self.assertRaises(xml.dom.NotSupportedErr, target.importNode,
                          src.doctype, 0)

def testImportDocumentTypeDeep(self):
        src = create_doc_with_doctype()
        target = create_doc_without_doctype()
        self.assertRaises(xml.dom.NotSupportedErr, target.importNode,
                          src.doctype, 1)

# Testing attribute clones uses a helper, and should always be deep,
 # even if the argument to cloneNode is false.
 def check_clone_attribute(self, deep, testName):
 doc = parseString("<doc attr='value'/>")
 attr = doc.documentElement.getAttributeNode("attr")
 self.assertNotEqual(attr, None)
 clone = attr.cloneNode(deep)
 self.confirm(not clone.isSameNode(attr))
 self.confirm(not attr.isSameNode(clone))
 self.confirm(clone.ownerElement is None,
 testName + ": ownerElement should be None")
 self.confirm(clone.ownerDocument.isSameNode(attr.ownerDocument),
 testName + ": ownerDocument does not match")
 self.confirm(clone.specified,
 testName + ": cloned attribute must have specified == True")

def testCloneAttributeShallow(self):
        self.check_clone_attribute(0, "testCloneAttributeShallow")

def testCloneAttributeDeep(self):
        self.check_clone_attribute(1, "testCloneAttributeDeep")

def check_clone_pi(self, deep, testName):
 doc = parseString("<?target data?><doc/>")
 pi = doc.firstChild
 self.assertEqual(pi.nodeType, Node.PROCESSING_INSTRUCTION_NODE)
 clone = pi.cloneNode(deep)
 self.confirm(clone.target == pi.target
 and clone.data == pi.data)

def testClonePIShallow(self):
        self.check_clone_pi(0, "testClonePIShallow")

def testClonePIDeep(self):
        self.check_clone_pi(1, "testClonePIDeep")

def testNormalize(self):
 doc = parseString("<doc/>")
 root = doc.documentElement
 root.appendChild(doc.createTextNode("first"))
 root.appendChild(doc.createTextNode("second"))
 self.confirm(len(root.childNodes) == 2
 and root.childNodes.length == 2,
 "testNormalize -- preparation")
 doc.normalize()
 self.confirm(len(root.childNodes) == 1
 and root.childNodes.length == 1
 and root.firstChild is root.lastChild
 and root.firstChild.data == "firstsecond"
 , "testNormalize -- result")
 doc.unlink()

doc = parseString("<doc/>")
 root = doc.documentElement
 root.appendChild(doc.createTextNode(""))
 doc.normalize()
 self.confirm(len(root.childNodes) == 0
 and root.childNodes.length == 0,
 "testNormalize -- single empty node removed")
 doc.unlink()

def testNormalizeCombineAndNextSibling(self):
 doc = parseString("<doc/>")
 root = doc.documentElement
 root.appendChild(doc.createTextNode("first"))
 root.appendChild(doc.createTextNode("second"))
 root.appendChild(doc.createElement("i"))
 self.confirm(len(root.childNodes) == 3
 and root.childNodes.length == 3,
 "testNormalizeCombineAndNextSibling -- preparation")
 doc.normalize()
 self.confirm(len(root.childNodes) == 2
 and root.childNodes.length == 2
 and root.firstChild.data == "firstsecond"
 and root.firstChild is not root.lastChild
 and root.firstChild.nextSibling is root.lastChild
 and root.firstChild.previousSibling is None
 and root.lastChild.previousSibling is root.firstChild
 and root.lastChild.nextSibling is None
 , "testNormalizeCombinedAndNextSibling -- result")
 doc.unlink()

def testNormalizeDeleteWithPrevSibling(self):
 doc = parseString("<doc/>")
 root = doc.documentElement
 root.appendChild(doc.createTextNode("first"))
 root.appendChild(doc.createTextNode(""))
 self.confirm(len(root.childNodes) == 2
 and root.childNodes.length == 2,
 "testNormalizeDeleteWithPrevSibling -- preparation")
 doc.normalize()
 self.confirm(len(root.childNodes) == 1
 and root.childNodes.length == 1
 and root.firstChild.data == "first"
 and root.firstChild is root.lastChild
 and root.firstChild.nextSibling is None
 and root.firstChild.previousSibling is None
 , "testNormalizeDeleteWithPrevSibling -- result")
 doc.unlink()

def testNormalizeDeleteWithNextSibling(self):
 doc = parseString("<doc/>")
 root = doc.documentElement
 root.appendChild(doc.createTextNode(""))
 root.appendChild(doc.createTextNode("second"))
 self.confirm(len(root.childNodes) == 2
 and root.childNodes.length == 2,
 "testNormalizeDeleteWithNextSibling -- preparation")
 doc.normalize()
 self.confirm(len(root.childNodes) == 1
 and root.childNodes.length == 1
 and root.firstChild.data == "second"
 and root.firstChild is root.lastChild
 and root.firstChild.nextSibling is None
 and root.firstChild.previousSibling is None
 , "testNormalizeDeleteWithNextSibling -- result")
 doc.unlink()

def testNormalizeDeleteWithTwoNonTextSiblings(self):
 doc = parseString("<doc/>")
 root = doc.documentElement
 root.appendChild(doc.createElement("i"))
 root.appendChild(doc.createTextNode(""))
 root.appendChild(doc.createElement("i"))
 self.confirm(len(root.childNodes) == 3
 and root.childNodes.length == 3,
 "testNormalizeDeleteWithTwoSiblings -- preparation")
 doc.normalize()
 self.confirm(len(root.childNodes) == 2
 and root.childNodes.length == 2
 and root.firstChild is not root.lastChild
 and root.firstChild.nextSibling is root.lastChild
 and root.firstChild.previousSibling is None
 and root.lastChild.previousSibling is root.firstChild
 and root.lastChild.nextSibling is None
 , "testNormalizeDeleteWithTwoSiblings -- result")
 doc.unlink()

def testNormalizeDeleteAndCombine(self):
 doc = parseString("<doc/>")
 root = doc.documentElement
 root.appendChild(doc.createTextNode(""))
 root.appendChild(doc.createTextNode("second"))
 root.appendChild(doc.createTextNode(""))
 root.appendChild(doc.createTextNode("fourth"))
 root.appendChild(doc.createTextNode(""))
 self.confirm(len(root.childNodes) == 5
 and root.childNodes.length == 5,
 "testNormalizeDeleteAndCombine -- preparation")
 doc.normalize()
 self.confirm(len(root.childNodes) == 1
 and root.childNodes.length == 1
 and root.firstChild is root.lastChild
 and root.firstChild.data == "secondfourth"
 and root.firstChild.previousSibling is None
 and root.firstChild.nextSibling is None
 , "testNormalizeDeleteAndCombine -- result")
 doc.unlink()

def testNormalizeRecursion(self):
 doc = parseString("<doc>"
 "<o>"
 ""
 "t"
 #
 #x
 "</o>"
 "<o>"
 "<o>"
 "t2"
 #x2
 "</o>"
 "t3"
 #x3
 "</o>"
 #
 "</doc>")
 root = doc.documentElement
 root.childNodes[0].appendChild(doc.createTextNode(""))
 root.childNodes[0].appendChild(doc.createTextNode("x"))
 root.childNodes[1].childNodes[0].appendChild(doc.createTextNode("x2"))
 root.childNodes[1].appendChild(doc.createTextNode("x3"))
 root.appendChild(doc.createTextNode(""))
 self.confirm(len(root.childNodes) == 3
 and root.childNodes.length == 3
 and len(root.childNodes[0].childNodes) == 4
 and root.childNodes[0].childNodes.length == 4
 and len(root.childNodes[1].childNodes) == 3
 and root.childNodes[1].childNodes.length == 3
 and len(root.childNodes[1].childNodes[0].childNodes) == 2
 and root.childNodes[1].childNodes[0].childNodes.length == 2
 , "testNormalize2 -- preparation")
 doc.normalize()
 self.confirm(len(root.childNodes) == 2
 and root.childNodes.length == 2
 and len(root.childNodes[0].childNodes) == 2
 and root.childNodes[0].childNodes.length == 2
 and len(root.childNodes[1].childNodes) == 2
 and root.childNodes[1].childNodes.length == 2
 and len(root.childNodes[1].childNodes[0].childNodes) == 1
 and root.childNodes[1].childNodes[0].childNodes.length == 1
 , "testNormalize2 -- childNodes lengths")
 self.confirm(root.childNodes[0].childNodes[1].data == "tx"
 and root.childNodes[1].childNodes[0].childNodes[0].data == "t2x2"
 and root.childNodes[1].childNodes[1].data == "t3x3"
 , "testNormalize2 -- joined text fields")
 self.confirm(root.childNodes[0].childNodes[1].nextSibling is None
 and root.childNodes[0].childNodes[1].previousSibling
 is root.childNodes[0].childNodes[0]
 and root.childNodes[0].childNodes[0].previousSibling is None
 and root.childNodes[0].childNodes[0].nextSibling
 is root.childNodes[0].childNodes[1]
 and root.childNodes[1].childNodes[1].nextSibling is None
 and root.childNodes[1].childNodes[1].previousSibling
 is root.childNodes[1].childNodes[0]
 and root.childNodes[1].childNodes[0].previousSibling is None
 and root.childNodes[1].childNodes[0].nextSibling
 is root.childNodes[1].childNodes[1]
 , "testNormalize2 -- sibling pointers")
 doc.unlink()

def testBug0777884(self):
 doc = parseString("<o>text</o>")
 text = doc.documentElement.childNodes[0]
 self.assertEqual(text.nodeType, Node.TEXT_NODE)
 # Should run quietly, doing nothing.
 text.normalize()
 doc.unlink()

def testBug1433694(self):
 doc = parseString("<o>t</o>")
 node = doc.documentElement
 node.childNodes[1].nodeValue = ""
 node.normalize()
 self.confirm(node.childNodes[-1].nextSibling is None,
 "Final child's .nextSibling should be None")

def testSiblings(self):
 doc = parseString("<doc><?pi?>text?<elm/></doc>")
 root = doc.documentElement
 (pi, text, elm) = root.childNodes

self.confirm(pi.nextSibling is text and
                pi.previousSibling is None and
                text.nextSibling is elm and
                text.previousSibling is pi and
                elm.nextSibling is None and
                elm.previousSibling is text, "testSiblings")

doc.unlink()

def testParents(self):
 doc = parseString(
 "<doc><elm1><elm2/><elm2><elm3/></elm2></elm1></doc>")
 root = doc.documentElement
 elm1 = root.childNodes[0]
 (elm2a, elm2b) = elm1.childNodes
 elm3 = elm2b.childNodes[0]

self.confirm(root.parentNode is doc and
                elm1.parentNode is root and
                elm2a.parentNode is elm1 and
                elm2b.parentNode is elm1 and
                elm3.parentNode is elm2b, "testParents")
        doc.unlink()

def testNodeListItem(self):
 doc = parseString("<doc><e/><e/></doc>")
 children = doc.childNodes
 docelem = children[0]
 self.confirm(children[0] is children.item(0)
 and children.item(1) is None
 and docelem.childNodes.item(0) is docelem.childNodes[0]
 and docelem.childNodes.item(1) is docelem.childNodes[1]
 and docelem.childNodes.item(0).childNodes.item(0) is None,
 "test NodeList.item()")
 doc.unlink()

def testEncodings(self):
 doc = parseString('<foo>&#x20ac;</foo>')
 self.assertEqual(doc.toxml(),
 '<?xml version="1.0" ?><foo>\u20ac</foo>')
 self.assertEqual(doc.toxml('utf-8'),
 b'<?xml version="1.0" encoding="utf-8"?><foo>\xe2\x82\xac</foo>')
 self.assertEqual(doc.toxml('iso-8859-15'),
 b'<?xml version="1.0" encoding="iso-8859-15"?><foo>\xa4</foo>')
 self.assertEqual(doc.toxml('us-ascii'),
 b'<?xml version="1.0" encoding="us-ascii"?><foo>&#8364;</foo>')
 self.assertEqual(doc.toxml('utf-16'),
 '<?xml version="1.0" encoding="utf-16"?>'
 '<foo>\u20ac</foo>'.encode('utf-16'))

# Verify that character decoding errors raise exceptions instead
 # of crashing
 self.assertRaises(UnicodeDecodeError, parseString,
 b'<fran\xe7ais>Comment \xe7a va ? Tr\xe8s bien ?</fran\xe7ais>')

doc.unlink()

class UserDataHandler:
        called = 0
        def handle(self, operation, key, data, src, dst):
            dst.setUserData(key, data + 1, self)
            src.setUserData(key, None, None)
            self.called = 1

def testUserData(self):
        dom = Document()
        n = dom.createElement('e')
        self.confirm(n.getUserData("foo") is None)
        n.setUserData("foo", None, None)
        self.confirm(n.getUserData("foo") is None)
        n.setUserData("foo", 12, 12)
        n.setUserData("bar", 13, 13)
        self.confirm(n.getUserData("foo") == 12)
        self.confirm(n.getUserData("bar") == 13)
        n.setUserData("foo", None, None)
        self.confirm(n.getUserData("foo") is None)
        self.confirm(n.getUserData("bar") == 13)

handler = self.UserDataHandler()
        n.setUserData("bar", 12, handler)
        c = n.cloneNode(1)
        self.confirm(handler.called
                and n.getUserData("bar") is None
                and c.getUserData("bar") == 13)
        n.unlink()
        c.unlink()
        dom.unlink()

def checkRenameNodeSharedConstraints(self, doc, node):
 # Make sure illegal NS usage is detected:
 self.assertRaises(xml.dom.NamespaceErr, doc.renameNode, node,
 "http://xml.python.org/ns", "xmlns:foo")
 doc2 = parseString("<doc/>")
 self.assertRaises(xml.dom.WrongDocumentErr, doc2.renameNode, node,
 xml.dom.EMPTY_NAMESPACE, "foo")

def testRenameAttribute(self):
 doc = parseString("<doc a='v'/>")
 elem = doc.documentElement
 attrmap = elem.attributes
 attr = elem.attributes['a']

# Simple renaming
        attr = doc.renameNode(attr, xml.dom.EMPTY_NAMESPACE, "b")
        self.confirm(attr.name == "b"
                and attr.nodeName == "b"
                and attr.localName is None
                and attr.namespaceURI == xml.dom.EMPTY_NAMESPACE
                and attr.prefix is None
                and attr.value == "v"
                and elem.getAttributeNode("a") is None
                and elem.getAttributeNode("b").isSameNode(attr)
                and attrmap["b"].isSameNode(attr)
                and attr.ownerDocument.isSameNode(doc)
                and attr.ownerElement.isSameNode(elem))

# Rename to have a namespace, no prefix
        attr = doc.renameNode(attr, "http://xml.python.org/ns", "c")
        self.confirm(attr.name == "c"
                and attr.nodeName == "c"
                and attr.localName == "c"
                and attr.namespaceURI == "http://xml.python.org/ns"
                and attr.prefix is None
                and attr.value == "v"
                and elem.getAttributeNode("a") is None
                and elem.getAttributeNode("b") is None
                and elem.getAttributeNode("c").isSameNode(attr)
                and elem.getAttributeNodeNS(
                    "http://xml.python.org/ns", "c").isSameNode(attr)
                and attrmap["c"].isSameNode(attr)
                and attrmap[("http://xml.python.org/ns", "c")].isSameNode(attr))

# Rename to have a namespace, with prefix
        attr = doc.renameNode(attr, "http://xml.python.org/ns2", "p:d")
        self.confirm(attr.name == "p:d"
                and attr.nodeName == "p:d"
                and attr.localName == "d"
                and attr.namespaceURI == "http://xml.python.org/ns2"
                and attr.prefix == "p"
                and attr.value == "v"
                and elem.getAttributeNode("a") is None
                and elem.getAttributeNode("b") is None
                and elem.getAttributeNode("c") is None
                and elem.getAttributeNodeNS(
                    "http://xml.python.org/ns", "c") is None
                and elem.getAttributeNode("p:d").isSameNode(attr)
                and elem.getAttributeNodeNS(
                    "http://xml.python.org/ns2", "d").isSameNode(attr)
                and attrmap["p:d"].isSameNode(attr)
                and attrmap[("http://xml.python.org/ns2", "d")].isSameNode(attr))

# Rename back to a simple non-NS node
        attr = doc.renameNode(attr, xml.dom.EMPTY_NAMESPACE, "e")
        self.confirm(attr.name == "e"
                and attr.nodeName == "e"
                and attr.localName is None
                and attr.namespaceURI == xml.dom.EMPTY_NAMESPACE
                and attr.prefix is None
                and attr.value == "v"
                and elem.getAttributeNode("a") is None
                and elem.getAttributeNode("b") is None
                and elem.getAttributeNode("c") is None
                and elem.getAttributeNode("p:d") is None
                and elem.getAttributeNodeNS(
                    "http://xml.python.org/ns", "c") is None
                and elem.getAttributeNode("e").isSameNode(attr)
                and attrmap["e"].isSameNode(attr))

self.assertRaises(xml.dom.NamespaceErr, doc.renameNode, attr,
                          "http://xml.python.org/ns", "xmlns")
        self.checkRenameNodeSharedConstraints(doc, attr)
        doc.unlink()

def testRenameElement(self):
 doc = parseString("<doc/>")
 elem = doc.documentElement

# Simple renaming
        elem = doc.renameNode(elem, xml.dom.EMPTY_NAMESPACE, "a")
        self.confirm(elem.tagName == "a"
                and elem.nodeName == "a"
                and elem.localName is None
                and elem.namespaceURI == xml.dom.EMPTY_NAMESPACE
                and elem.prefix is None
                and elem.ownerDocument.isSameNode(doc))

# Rename to have a namespace, no prefix
        elem = doc.renameNode(elem, "http://xml.python.org/ns", "b")
        self.confirm(elem.tagName == "b"
                and elem.nodeName == "b"
                and elem.localName == "b"
                and elem.namespaceURI == "http://xml.python.org/ns"
                and elem.prefix is None
                and elem.ownerDocument.isSameNode(doc))

# Rename to have a namespace, with prefix
        elem = doc.renameNode(elem, "http://xml.python.org/ns2", "p:c")
        self.confirm(elem.tagName == "p:c"
                and elem.nodeName == "p:c"
                and elem.localName == "c"
                and elem.namespaceURI == "http://xml.python.org/ns2"
                and elem.prefix == "p"
                and elem.ownerDocument.isSameNode(doc))

# Rename back to a simple non-NS node
        elem = doc.renameNode(elem, xml.dom.EMPTY_NAMESPACE, "d")
        self.confirm(elem.tagName == "d"
                and elem.nodeName == "d"
                and elem.localName is None
                and elem.namespaceURI == xml.dom.EMPTY_NAMESPACE
                and elem.prefix is None
                and elem.ownerDocument.isSameNode(doc))

self.checkRenameNodeSharedConstraints(doc, elem)
        doc.unlink()

def testRenameOther(self):
        # We have to create a comment node explicitly since not all DOM
        # builders used with minidom add comments to the DOM.
        doc = xml.dom.minidom.getDOMImplementation().createDocument(
            xml.dom.EMPTY_NAMESPACE, "e", None)
        node = doc.createComment("comment")
        self.assertRaises(xml.dom.NotSupportedErr, doc.renameNode, node,
                          xml.dom.EMPTY_NAMESPACE, "foo")
        doc.unlink()

def testWholeText(self):
 doc = parseString("<doc>a</doc>")
 elem = doc.documentElement
 text = elem.childNodes[0]
 self.assertEqual(text.nodeType, Node.TEXT_NODE)

self.checkWholeText(text, "a")
        elem.appendChild(doc.createTextNode("b"))
        self.checkWholeText(text, "ab")
        elem.insertBefore(doc.createCDATASection("c"), text)
        self.checkWholeText(text, "cab")

# make sure we don't cross other nodes
        splitter = doc.createComment("comment")
        elem.appendChild(splitter)
        text2 = doc.createTextNode("d")
        elem.appendChild(text2)
        self.checkWholeText(text, "cab")
        self.checkWholeText(text2, "d")

x = doc.createElement("x")
        elem.replaceChild(x, splitter)
        splitter = x
        self.checkWholeText(text, "cab")
        self.checkWholeText(text2, "d")

x = doc.createProcessingInstruction("y", "z")
        elem.replaceChild(x, splitter)
        splitter = x
        self.checkWholeText(text, "cab")
        self.checkWholeText(text2, "d")

elem.removeChild(splitter)
        self.checkWholeText(text, "cabd")
        self.checkWholeText(text2, "cabd")

def testPatch1094164(self):
 doc = parseString("<doc><e/></doc>")
 elem = doc.documentElement
 e = elem.firstChild
 self.confirm(e.parentNode is elem, "Before replaceChild()")
 # Check that replacing a child with itself leaves the tree unchanged
 elem.replaceChild(e, e)
 self.confirm(e.parentNode is elem, "After replaceChild()")

def testReplaceWholeText(self):
 def setup():
 doc = parseString("<doc>a<e/>d</doc>")
 elem = doc.documentElement
 text1 = elem.firstChild
 text2 = elem.lastChild
 splitter = text1.nextSibling
 elem.insertBefore(doc.createTextNode("b"), splitter)
 elem.insertBefore(doc.createCDATASection("c"), text1)
 return doc, elem, text1, splitter, text2

doc, elem, text1, splitter, text2 = setup()
        text = text1.replaceWholeText("new content")
        self.checkWholeText(text, "new content")
        self.checkWholeText(text2, "d")
        self.confirm(len(elem.childNodes) == 3)

doc, elem, text1, splitter, text2 = setup()
        text = text2.replaceWholeText("new content")
        self.checkWholeText(text, "new content")
        self.checkWholeText(text1, "cab")
        self.confirm(len(elem.childNodes) == 5)

doc, elem, text1, splitter, text2 = setup()
        text = text1.replaceWholeText("")
        self.checkWholeText(text2, "d")
        self.confirm(text is None
                and len(elem.childNodes) == 2)

def testSchemaType(self):
 doc = parseString(
 "<!DOCTYPE doc [\n"
 " <!ENTITY e1 SYSTEM 'http://xml.python.org/e1'>\n"
 " <!ENTITY e2 SYSTEM 'http://xml.python.org/e2'>\n"
 " <!ATTLIST doc id ID #IMPLIED \n"
 " ref IDREF #IMPLIED \n"
 " refs IDREFS #IMPLIED \n"
 " enum (a|b) #IMPLIED \n"
 " ent ENTITY #IMPLIED \n"
 " ents ENTITIES #IMPLIED \n"
 " nm NMTOKEN #IMPLIED \n"
 " nms NMTOKENS #IMPLIED \n"
 " text CDATA #IMPLIED \n"
 " >\n"
 "]><doc id='name' notid='name' text='splat!' enum='b'"
 " ref='name' refs='name name' ent='e1' ents='e1 e2'"
 " nm='123' nms='123 abc' />")
 elem = doc.documentElement
 # We don't want to rely on any specific loader at this point, so
 # just make sure we can get to all the names, and that the
 # DTD-based namespace is right. The names can vary by loader
 # since each supports a different level of DTD information.
 t = elem.schemaType
 self.confirm(t.name is None
 and t.namespace == xml.dom.EMPTY_NAMESPACE)
 names = "id notid text enum ref refs ent ents nm nms".split()
 for name in names:
 a = elem.getAttributeNode(name)
 t = a.schemaType
 self.confirm(hasattr(t, "name")
 and t.namespace == xml.dom.EMPTY_NAMESPACE)

def testSetIdAttribute(self):
 doc = parseString("<doc a1='v' a2='w'/>")
 e = doc.documentElement
 a1 = e.getAttributeNode("a1")
 a2 = e.getAttributeNode("a2")
 self.confirm(doc.getElementById("v") is None
 and not a1.isId
 and not a2.isId)
 e.setIdAttribute("a1")
 self.confirm(e.isSameNode(doc.getElementById("v"))
 and a1.isId
 and not a2.isId)
 e.setIdAttribute("a2")
 self.confirm(e.isSameNode(doc.getElementById("v"))
 and e.isSameNode(doc.getElementById("w"))
 and a1.isId
 and a2.isId)
 # replace the a1 node; the new node should *not* be an ID
 a3 = doc.createAttribute("a1")
 a3.value = "v"
 e.setAttributeNode(a3)
 self.confirm(doc.getElementById("v") is None
 and e.isSameNode(doc.getElementById("w"))
 and not a1.isId
 and a2.isId
 and not a3.isId)
 # renaming an attribute should not affect its ID-ness:
 doc.renameNode(a2, xml.dom.EMPTY_NAMESPACE, "an")
 self.confirm(e.isSameNode(doc.getElementById("w"))
 and a2.isId)

def testSetIdAttributeNS(self):
 NS1 = "http://xml.python.org/ns1"
 NS2 = "http://xml.python.org/ns2"
 doc = parseString("<doc"
 " xmlns:ns1='" + NS1 + "'"
 " xmlns:ns2='" + NS2 + "'"
 " ns1:a1='v' ns2:a2='w'/>")
 e = doc.documentElement
 a1 = e.getAttributeNodeNS(NS1, "a1")
 a2 = e.getAttributeNodeNS(NS2, "a2")
 self.confirm(doc.getElementById("v") is None
 and not a1.isId
 and not a2.isId)
 e.setIdAttributeNS(NS1, "a1")
 self.confirm(e.isSameNode(doc.getElementById("v"))
 and a1.isId
 and not a2.isId)
 e.setIdAttributeNS(NS2, "a2")
 self.confirm(e.isSameNode(doc.getElementById("v"))
 and e.isSameNode(doc.getElementById("w"))
 and a1.isId
 and a2.isId)
 # replace the a1 node; the new node should *not* be an ID
 a3 = doc.createAttributeNS(NS1, "a1")
 a3.value = "v"
 e.setAttributeNode(a3)
 self.confirm(e.isSameNode(doc.getElementById("w")))
 self.confirm(not a1.isId)
 self.confirm(a2.isId)
 self.confirm(not a3.isId)
 self.confirm(doc.getElementById("v") is None)
 # renaming an attribute should not affect its ID-ness:
 doc.renameNode(a2, xml.dom.EMPTY_NAMESPACE, "an")
 self.confirm(e.isSameNode(doc.getElementById("w"))
 and a2.isId)

def testSetIdAttributeNode(self):
 NS1 = "http://xml.python.org/ns1"
 NS2 = "http://xml.python.org/ns2"
 doc = parseString("<doc"
 " xmlns:ns1='" + NS1 + "'"
 " xmlns:ns2='" + NS2 + "'"
 " ns1:a1='v' ns2:a2='w'/>")
 e = doc.documentElement
 a1 = e.getAttributeNodeNS(NS1, "a1")
 a2 = e.getAttributeNodeNS(NS2, "a2")
 self.confirm(doc.getElementById("v") is None
 and not a1.isId
 and not a2.isId)
 e.setIdAttributeNode(a1)
 self.confirm(e.isSameNode(doc.getElementById("v"))
 and a1.isId
 and not a2.isId)
 e.setIdAttributeNode(a2)
 self.confirm(e.isSameNode(doc.getElementById("v"))
 and e.isSameNode(doc.getElementById("w"))
 and a1.isId
 and a2.isId)
 # replace the a1 node; the new node should *not* be an ID
 a3 = doc.createAttributeNS(NS1, "a1")
 a3.value = "v"
 e.setAttributeNode(a3)
 self.confirm(e.isSameNode(doc.getElementById("w")))
 self.confirm(not a1.isId)
 self.confirm(a2.isId)
 self.confirm(not a3.isId)
 self.confirm(doc.getElementById("v") is None)
 # renaming an attribute should not affect its ID-ness:
 doc.renameNode(a2, xml.dom.EMPTY_NAMESPACE, "an")
 self.confirm(e.isSameNode(doc.getElementById("w"))
 and a2.isId)

def testPickledDocument(self):
 doc = parseString("<?xml version='1.0' encoding='us-ascii'?>\n"
 "<!DOCTYPE doc PUBLIC 'http://xml.python.org/public'"
 " 'http://xml.python.org/system' [\n"
 " <!ELEMENT e EMPTY>\n"
 " <!ENTITY ent SYSTEM 'http://xml.python.org/entity'>\n"
 "]><doc attr='value'> text\n"
 "<?pi sample?>  <e/> </doc>")
 s = pickle.dumps(doc)
 doc2 = pickle.loads(s)
 stack = [(doc, doc2)]
 while stack:
 n1, n2 = stack.pop()
 self.confirm(n1.nodeType == n2.nodeType
 and len(n1.childNodes) == len(n2.childNodes)
 and n1.nodeName == n2.nodeName
 and not n1.isSameNode(n2)
 and not n2.isSameNode(n1))
 if n1.nodeType == Node.DOCUMENT_TYPE_NODE:
 len(n1.entities)
 len(n2.entities)
 len(n1.notations)
 len(n2.notations)
 self.confirm(len(n1.entities) == len(n2.entities)
 and len(n1.notations) == len(n2.notations))
 for i in range(len(n1.notations)):
 # XXX this loop body doesn't seem to be executed?
 no1 = n1.notations.item(i)
 no2 = n1.notations.item(i)
 self.confirm(no1.name == no2.name
 and no1.publicId == no2.publicId
 and no1.systemId == no2.systemId)
 stack.append((no1, no2))
 for i in range(len(n1.entities)):
 e1 = n1.entities.item(i)
 e2 = n2.entities.item(i)
 self.confirm(e1.notationName == e2.notationName
 and e1.publicId == e2.publicId
 and e1.systemId == e2.systemId)
 stack.append((e1, e2))
 if n1.nodeType != Node.DOCUMENT_NODE:
 self.confirm(n1.ownerDocument.isSameNode(doc)
 and n2.ownerDocument.isSameNode(doc2))
 for i in range(len(n1.childNodes)):
 stack.append((n1.childNodes[i], n2.childNodes[i]))

def testSerializeCommentNodeWithDoubleHyphen(self):
        doc = create_doc_without_doctype()
        doc.appendChild(doc.createComment("foo--bar"))
        self.assertRaises(ValueError, doc.toxml)

def testEmptyXMLNSValue(self):
 doc = parseString("<element xmlns=''>\n"
 "<foo/>\n</element>")
 doc2 = parseString(doc.toxml())
 self.confirm(doc2.namespaceURI == xml.dom.EMPTY_NAMESPACE)

def testDocRemoveChild(self):
        doc = parse(tstfile)
        title_tag = doc.documentElement.getElementsByTagName("TITLE")[0]
        self.assertRaises( xml.dom.NotFoundErr, doc.removeChild, title_tag)
        num_children_before = len(doc.childNodes)
        doc.removeChild(doc.childNodes[0])
        num_children_after = len(doc.childNodes)
        self.assertTrue(num_children_after == num_children_before - 1)

def test_main():
    run_unittest(MinidomTest)

if __name__ == "__main__":
    test_main()