python.z-run

#!/dev/null


::// python / test / ...


++<< python / test / all
	"${ZRUN}" ':: python / test / noop'
	"${ZRUN}" ':: python / test / prolog'
	"${ZRUN}" ':: python / test / exit'
	"${ZRUN}" ':: python / test / log' 2> /dev/null
	"${ZRUN}" ':: python / test / panic' 2> /dev/null || true
	"${ZRUN}" ':: python / test / zrun_spawn'
	"${ZRUN}" ':: python / test / zrun_exec'
	"${ZRUN}" ':: python / test / zspawn'
	"${ZRUN}" ':: python / test / zexec'
	"${ZRUN}" ':: python / test / spawn'
	"${ZRUN}" ':: python / test / exec'
	"${ZRUN}" ':: python / test / redirects' 2> /dev/null
	"${ZRUN}" ':: python / test / pipeline'
	"${ZRUN}" ':: python / test / wait'
	"${ZRUN}" ':: python / test / communicate'
	"${ZRUN}" ':: python / test / pipes'
	"${ZRUN}" ':: python / test / paths / join'
	"${ZRUN}" ':: python / test / paths / split'
	"${ZRUN}" ':: python / test / stat'
	"${ZRUN}" ':: python / test / walk' > /dev/null
	"${ZRUN}" ':: python / test / touch'
	"${ZRUN}" ':: python / test / environment' > /dev/null
	"${ZRUN}" ':: python / test / sleep'
	"${ZRUN}" ':: python / test / files'
	"${ZRUN}" ':: python / test / random'
	"${ZRUN}" ':: python / test / hash'
	"${ZRUN}" ':: python / test / arguments'
	"${ZRUN}" ':: python / test / quoting / shell'
	"${ZRUN}" ':: python / test / quoting / python'
!!

<< python / test / noop
	#! <python3+>
!!

<< python / test / prolog
	#! <python3+>
	Z.expect_no_arguments ()
!!

<< python / test / exit
	#! <python3+>
	Z.expect_no_arguments ()
	Z.exit (0)
!!

<< python / test / log
	#! <python3+>
	Z.expect_no_arguments ()
	Z.log_debug_enabled = True
	Z.log_error (0xd517385b, "this is an error message")
	Z.log_warning (0xb4614c33, "this is a warning message")
	Z.log_notice (0x7049cb1d, "this is a notice message")
	Z.log_debug (0xd8baf265, "this is a debug message")
!!

<< python / test / panic
	#! <python3+>
	Z.expect_no_arguments ()
	Z.panic (0x943040e7, "panic")
!!

<< python / test / zrun_spawn
	#! <python3+>
	Z.expect_no_arguments ()
	Z.zrun_spawn ("--version", stdout = False)
	Z.zrun_spawn (command = "execute-scriptlet", scriptlet = ":: true")
	Z.zrun_spawn_capture ("--version", lines = True)
	Z.zrun_spawn_capture (command = "execute-scriptlet", scriptlet = ":: true", lines = True)
!!

<< python / test / zrun_exec
	#! <python3+>
	Z.expect_no_arguments ()
	Z.zrun_exec ("--version", stdout = False)
!!

<< python / test / zspawn
	#! <python3+>
	Z.expect_no_arguments ()
	Z.zspawn (":: true")
	Z.zspawn (":: false", enforce = False)
	Z.zspawn_capture (":: true", lines = True)
	Z.zspawn_capture (":: false", enforce = False, lines = True)
!!

<< python / test / zexec
	#! <python3+>
	Z.expect_no_arguments ()
	Z.zexec (":: true")
!!

<< python / test / spawn
	#! <python3+>
	Z.expect_no_arguments ()
	Z.spawn ("true")
	Z.spawn ("false", enforce = False)
	Z.spawn_capture ("true", lines = True)
	Z.spawn_capture ("false", enforce = False, lines = True)
!!

<< python / test / exec
	#! <python3+>
	Z.expect_no_arguments ()
	Z.exec ("true")
!!

<< python / test / redirects
	#! <python3+>
	Z.expect_no_arguments ()
	Z.log_cut ()
	Z.spawn ("true", stdin = Z.fd_open_null (), fd_close = True)
	Z.spawn ("true", stdout = Z.fd_open_null (), fd_close = True)
	Z.spawn ("true", stderr = Z.fd_open_null (), fd_close = True)
	Z.spawn ("true", stdin = Z.fd_open_null (), stdout = Z.fd_open_null (), stderr = Z.fd_open_null (), fd_close = True)
	Z.spawn ("cat", stdin = Z.fd_open_for_read ("/etc/hosts"), stdout = Z.fd_open_null (), fd_close = True)
	Z.log_cut ()
	Z.spawn ("lsof", "-p", "%d" % Z.pid, stdin = Z.fd_open_null (), stderr = Z.fd_open_null (), stdout = Z.fd_clone (Z.stderr), fd_close = True)
	Z.log_cut ()
	Z.spawn ("lsof", "-c", "lsof", stdin = Z.fd_open_null (), stderr = Z.fd_open_null (), stdout = Z.fd_clone (Z.stderr), fd_close = True)
	Z.log_cut ()
	Z.spawn ("lsof", "-c", "lsof", stdin = Z.fd_open_null (), stderr = Z.fd_open_null (), stdout = Z.fd_clone (Z.stderr), fd_close = True)
	Z.log_cut ()
!!

<< python / test / pipeline
	#! <python3+>
	Z.expect_no_arguments ()
	Z.pipeline ([
			Z.cmd ("true"),
			Z.cmd ("sleep", "0.1s"),
			Z.cmd ("cat"),
			Z.cmd ("sleep", "0.2s"),
			Z.cmd ("true"),
		])
!!

<< python / test / wait
	#! <python3+>
	Z.expect_no_arguments ()
	_pid = Z.spawn ("true", wait = False)
	assert 0 == Z.process_wait (_pid, enforce = False)
	_pid = Z.spawn ("false", wait = False)
	assert 1 == Z.process_wait (_pid, enforce = False)
	_pid = Z.spawn ("sleep", "6s", wait = False)
	Z.process_terminate (_pid, wait = False)
	assert -Z.py.signal.SIGTERM == Z.process_wait (_pid, enforce = False)
	_pid = Z.spawn ("sleep", "6s", wait = False)
	Z.process_kill (_pid, wait = False)
	assert -Z.py.signal.SIGKILL == Z.process_wait (_pid, enforce = False)
!!

<< python / test / communicate
	#! <python3+>
	Z.expect_no_arguments ()
	_output = Z.spawn ("echo", "abc", stdout_data = True)
	assert _output == "abc\n"
	_output = Z.spawn ("echo", "abc", stdout_data = str)
	assert _output == "abc\n"
	_output = Z.spawn ("echo", "abc", stdout_data = bytes)
	assert _output == b"abc\n"
	_output = Z.spawn ("cat", stdin_data = "abc\n", stdout_data = str)
	assert _output == "abc\n"
	_output = Z.spawn_capture ("echo", "abc")
	assert _output == "abc\n"
	_output = Z.spawn_capture ("echo", "{}", json = True)
	assert _output == {}
!!

<< python / test / pipes
	#! <python3+>
	Z.expect_no_arguments ()
	_input, _output = Z.fd_open_pipes ()
	Z.fd_close (_input)
	Z.fd_close (_output)
!!

<< python / test / paths / join
	#! <python3+>
	Z.expect_no_arguments ()
	assert Z.path ("/etc") == "/etc", "[c86740bc]"
	assert Z.path ("//etc/.") == "/etc", "[1caa1de9]"
	assert Z.path (("/etc", "hosts")) == "/etc/hosts", "[b1c36167]"
	assert Z.path (("/etc/hosts", "/proc/self")) == "/proc/self", "[e126cddb]"
	assert Z.path ("/proc/self", canonical = True) != "/proc/self", "[0909bbcb7]"
!!

<< python / test / paths / split
	#! <python3+>
	assert "/folder" == Z.path_dirname ("/folder/file")
	assert "/folder/file" == Z.path_dirname ("/folder/file/")
	assert "file" == Z.path_basename ("/folder/file")
	assert "" == Z.path_basename ("/folder/file/")
	assert "a/b/c" == Z.path_normalize ("./a/././/./x/../b/c//")
	assert "/" == Z.path_normalize ("/")
	assert "a" == Z.path_normalize ("a/")
	assert "/a" == Z.path_normalize ("/a")
	assert "/a" == Z.path_normalize ("/a/")
	assert None == Z.path_extension (".a")
	assert "a" == Z.path_extension ("x.a")
	assert "a" == Z.path_extension ("x.y.a")
	assert ".a" == Z.path_without_extension (".a")
	assert "x" == Z.path_without_extension ("x.a")
	assert "x.y" == Z.path_without_extension ("x.y.a")
	assert True == Z.path_matches ("/x/y/abc/cde/fgh", "*/a*c/*")
	assert True == Z.path_matches ("/x/y/abc/cde/fgh", "*/a*e/*")
	assert False == Z.path_matches ("/x/y/abc/cde/fgh", "a*e")
	assert "/folder" == Z.path_dirname (Z.path_temporary_for ("/folder/file.ext"))
	assert Z.environment.TMPDIR == Z.path_dirname (Z.path_temporary_in (None, "file.ext"))
!!

<< python / test / stat
	#! <python3+>
	Z.expect_no_arguments ()
	Z.exists ("/etc", enforce = 0x2ebc156a)
	Z.not_exists ("/__none__", enforce = 0x6412700c)
	Z.is_folder ("/etc", enforce = 0x6f67d170)
	Z.is_file ("/etc/hosts", enforce = 0xf67ac126)
	Z.is_file_or_folder ("/etc", enforce = 0xea1ecf05)
	Z.is_file_or_folder ("/etc/hosts", enforce = 0xbf9c1575)
	Z.is_symlink ("/proc/self", enforce = 0x492a6caf)
	Z.is_folder ("/proc/self", enforce = 0x6746e58d)
	Z.is_socket ("/dev/log", enforce = 0x708c3426)
	Z.is_dev_block ("/dev/sda", enforce = 0x7ac9ef0f)
	Z.is_dev_char ("/dev/null", enforce = 0xa8623aa9)
	Z.is_special ("/dev/sda", enforce = 0x8ea394a4)
	Z.is_special ("/dev/null", enforce = 0x3d458181)
	Z.is_special ("/dev/log", enforce = 0xb3b9fb84)
	Z.exists ("/dev/log", enforce = 0xc83ed2ae)
	Z.is_file_not_empty ("/etc/hosts", enforce = 0xec23876b)
	Z.is_file_empty ("/proc/self/environ", enforce = 0x80a8c78c)
	Z.is_newer_than ("/proc/self/environ", "/proc", strict = True, enforce = 0xa603aaba)
	Z.is_newer_than ("/proc/self/environ", "/proc", strict = False, enforce = 0xeda4edca)
	Z.is_older_than ("/proc", "/proc/self/environ", strict = True, enforce = 0x5e3556b9)
	Z.is_older_than ("/proc", "/proc/self/environ", strict = False, enforce = 0x8813f51a)
	Z.is_newer_than ("/proc", "/proc", strict = False, enforce = 0xa762ec5c)
	Z.is_older_than ("/proc", "/proc", strict = False, enforce = 0x305faabd)
!!

<< python / test / walk
	#! <python3+>
	Z.expect_no_arguments ()
	for _entry in Z.find (".") :
		print (_entry.depth, _entry.path)
		if _entry.is_folder :
			_entry.skip ()
!!

<< python / test / environment
	#! <python3+>
	Z.expect_no_arguments ()
	for _name in sorted (Z.environment.__iter__ ()) :
		print ("%s == %s" % (_name, Z.environment[_name]))
	print (Z.environment.PATH)
	print (Z.environment_or_none.NEW)
	Z.environment.PATH = "/dev/null/1"
	Z.environment.NEW = "/dev/null/2"
	print (os.environ["PATH"])
	print (os.environ["NEW"])
!!

<< python / test / sleep
	#! <python3+>
	Z.expect_no_arguments ()
	Z.sleep (0.1)
!!

<< python / test / touch
	#! <python3+>
	Z.expect_no_arguments ()
	Z.touch ("/tmp/z-run-python-tests--touch")
!!

<< python / test / files
	#! <python3+>
	Z.expect_no_arguments ()
	_token = Z.random_token (128)
	Z.file_write ("/tmp/z-run-python-tests--files", '{"a":"%s"}' % _token)
	_output = Z.file_read ("/tmp/z-run-python-tests--files")
	assert _output == ('{"a":"%s"}' % _token).encode ("utf-8")
	_output = Z.file_read ("/tmp/z-run-python-tests--files", json = True)
	assert _output == {"a":_token}
	_token = Z.random_token (128)
	Z.file_write ("/tmp/z-run-python-tests--files", {"a":_token}, json = True)
	_output = Z.file_read ("/tmp/z-run-python-tests--files", json = True)
	assert _output == {"a":_token}
!!

<< python / test / random
	#! <python3+>
	Z.expect_no_arguments ()
	assert isinstance (Z.random_bytes (0), bytes)
	assert isinstance (Z.random_token (0), str)
	assert isinstance (Z.random_integer (0), int)
	assert isinstance (Z.random_float (0, 1), float)
	assert isinstance (Z.random_range (0, 1), int)
	assert isinstance (Z.random_sample ([], 0), list)
	assert isinstance (Z.random_shuffle ([]), list)
	for _index in range (1000) :
		assert len (Z.random_bytes (4)) == 4
		assert len (Z.random_token (4)) == 4 * 2
		assert Z.random_token (2) >= "0000"
		assert Z.random_token (2) <= "ffff"
		assert Z.random_integer (8) >= 0
		assert Z.random_integer (8) <= 256
		assert Z.random_float (0, 1) >= 0
		assert Z.random_float (0, 1) <= 1
		assert Z.random_range (0, 256) >= 0
		assert Z.random_range (0, 256) <= 256
		assert Z.random_range (0, 256, 5) % 5 == 0
		assert Z.random_select ([0, 1, 2]) in [0, 1, 2]
		assert len (Z.random_sample ([0, 1, 2, 3], 2, repeats = False)) == 2
		assert len (Z.random_sample ([0, 1, 2, 3], 8, repeats = True)) == 8
		assert len (Z.random_shuffle ([0, 1, 2, 3])) == 4
!!

<< python / test / hash
	#! <python3+>
	Z.expect_no_arguments ()
	assert Z.data_md5 ("") == "d41d8cd98f00b204e9800998ecf8427e"
	assert Z.data_sha1 ("") == "da39a3ee5e6b4b0d3255bfef95601890afd80709"
	assert Z.data_sha2_224 ("") == "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"
	assert Z.data_sha2_256 ("") == "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
	assert Z.data_sha2_384 ("") == "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"
	assert Z.data_sha2_512 ("") == "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"
	assert Z.data_sha3_224 ("") == "6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7"
	assert Z.data_sha3_256 ("") == "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"
	assert Z.data_sha3_384 ("") == "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004"
	assert Z.data_sha3_512 ("") == "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26"
	assert Z.data_blake2b ("") == "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce"
	assert Z.data_blake2s ("") == "69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9"
!!

<< python / test / quoting / shell
	#! <python3+>
	
	assert Z.shell_quote ("") == "''"
	assert Z.shell_quote ("'") == '\'\'"\'"\'\''
	assert Z.shell_quote ("''") == '\'\'"\'"\'\'"\'"\'\''
	assert Z.shell_quote ("a") == "a"
	assert Z.shell_quote ("a b") == "'a b'"
	assert Z.shell_quote ("*") == "'*'"
	
	assert Z.shell_unquote ("''") == ""
	assert Z.shell_unquote ('\'\'"\'"\'\'') == "'"
	assert Z.shell_unquote ('\'\'"\'"\'\'"\'"\'\'') == "''"
	assert Z.shell_unquote ("a") == "a"
	assert Z.shell_unquote ("'a b'") == "a b"
	assert Z.shell_unquote ("'*'") == "*"
!!

<< python / test / quoting / python
	#! <python3+>
	
	assert Z.python_quote ("") == "''"
	assert Z.python_quote ("'") == '"\'"'
	assert Z.python_quote ("''") == '"\'\'"'
	assert Z.python_quote ("a") == "'a'"
	assert Z.python_quote ("a b") == "'a b'"
	assert Z.python_quote ("*") == "'*'"
!!

<< python / test / raise / internal
	#! <python3+>
	Z.expect_no_arguments ()
	def x () : y ()
	def y () : z ()
	def z () : Z.random_token (-1)
	x ()
!!

<< python / test / raise / external
	#! <python3+>
	Z.expect_no_arguments ()
	def x () : y ()
	def y () : z ()
	def z () : raise Exception ()
	x ()
!!

<< python / test / raise / assert
	#! <python3+>
	Z.expect_no_arguments ()
	def x () : y ()
	def y () : z ()
	def z () : assert False
	x ()
!!

<< python / test / sudo
	#! <python3+>
	Z.expect_no_arguments ()
	Z.sudo_prepare ("root")
	Z.spawn ("whoami", sudo = True)
!!

<< python / test / arguments
	#! <python3+>
	Z.expect_no_arguments ()
	Z.arguments = ["--"]
	assert Z.extract_arguments_flag (enforce = False) == False
	Z.arguments = []
	assert Z.extract_arguments_flag (enforce = False) == None
	Z.arguments = ["abc"]
	assert Z.extract_arguments_flag (enforce = False) == False
	Z.arguments = ["--lulu"]
	assert Z.extract_arguments_flag (enforce = False) == "lulu"
	assert Z.arguments == []
	Z.arguments = ["--lulu"]
	assert Z.extract_arguments_flag (expected = ["lulu"], enforce = False) == "lulu"
	assert Z.arguments == []
	Z.arguments = ["--lala"]
	assert Z.extract_arguments_flag (expected = ["lulu"], enforce = False) == None
	assert Z.arguments == ["--lala"]
!!

<< python / benchmark / noop
	test "${#}" -eq 0
	exec -- hyperfine \
			--warmup 20 \
			--runs 200 \
			--shell '' \
			-n plain:python3 "python3 -E -s -S -u -O -O -- ${ZRUN_WORKSPACE}/python-noop.z-scriptlet" \
			-n scriptlet:python3+ "${ZRUN_EXECUTABLE} --scriptlet -- ${ZRUN_WORKSPACE}/python-noop.z-scriptlet" \
	#
!!