multiCMD 1.48__tar.gz → 1.49__tar.gz

{multicmd-1.48 → multicmd-1.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multiCMD
-Version: 1.48
+Version: 1.49
 Summary: Run commands simultaneously
 Home-page: https://github.com/yufei-pan/multiCMD
 Author: Yufei Pan
@@ -268,9 +268,12 @@ Run the test suite with [pytest](https://pytest.org):
 
 ```bash
 pip install pytest
-pytest
+pytest                 # full suite under tests/
+pytest -m "not slow"   # skip intentional sleep-heavy cases
 ```
 
+`test_expand_ranges_perf.py` is a manual performance microbenchmark and is not collected by pytest.
+
 ## License
 
 GPLv3+ — see the package metadata. Authored by Yufei Pan (<pan@zopyr.us>).

{multicmd-1.48 → multicmd-1.49}/README.md

@@ -242,9 +242,12 @@ Run the test suite with [pytest](https://pytest.org):
 
 ```bash
 pip install pytest
-pytest
+pytest                 # full suite under tests/
+pytest -m "not slow"   # skip intentional sleep-heavy cases
 ```
 
+`test_expand_ranges_perf.py` is a manual performance microbenchmark and is not collected by pytest.
+
 ## License
 
 GPLv3+ — see the package metadata. Authored by Yufei Pan (<pan@zopyr.us>).

{multicmd-1.48 → multicmd-1.49}/multiCMD.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multiCMD
-Version: 1.48
+Version: 1.49
 Summary: Run commands simultaneously
 Home-page: https://github.com/yufei-pan/multiCMD
 Author: Yufei Pan
@@ -268,9 +268,12 @@ Run the test suite with [pytest](https://pytest.org):
 
 ```bash
 pip install pytest
-pytest
+pytest                 # full suite under tests/
+pytest -m "not slow"   # skip intentional sleep-heavy cases
 ```
 
+`test_expand_ranges_perf.py` is a manual performance microbenchmark and is not collected by pytest.
+
 ## License
 
 GPLv3+ — see the package metadata. Authored by Yufei Pan (<pan@zopyr.us>).

multicmd-1.49/multiCMD.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+multiCMD.py
+setup.py
+multiCMD.egg-info/PKG-INFO
+multiCMD.egg-info/SOURCES.txt
+multiCMD.egg-info/dependency_links.txt
+multiCMD.egg-info/entry_points.txt
+multiCMD.egg-info/requires.txt
+multiCMD.egg-info/top_level.txt
+tests/test_async_executor.py
+tests/test_cli.py
+tests/test_expand_ranges.py
+tests/test_helpers.py
+tests/test_ping.py
+tests/test_regressions.py
+tests/test_run_command.py
+tests/test_run_commands.py
+tests/test_sudo.py
+tests/test_task.py

{multicmd-1.48 → multicmd-1.49}/multiCMD.py

@@ -22,9 +22,9 @@ import time
 from pprint import pformat
 
 #%% global vars
-version = '1.48'
+version = '1.49'
 __version__ = version
-COMMIT_DATE = '2026-06-04'
+COMMIT_DATE = '2026-08-10'
 __running_threads = set()
 __variables = {}
 
@@ -503,6 +503,7 @@ def __run_command(task,sem, timeout=60, quiet=False,dry_run=False,with_stdErr=Fa
 			outLength = len(task.stdout) + len(task.stderr)
 			time.sleep(0)
 			sleep_time = 1.0e-7 # 100 nanoseconds
+			inactivity_timeout = False
 			while proc.poll() is None:  # while the process is still running
 				if task.stop:
 					proc.send_signal(signal.SIGINT)
@@ -515,6 +516,7 @@ def __run_command(task,sem, timeout=60, quiet=False,dry_run=False,with_stdErr=Fa
 						outLength = len(task.stdout) + len(task.stderr)
 					elif time.time() - start_time > timeout:
 						task.stderr.append('Timeout!')
+						inactivity_timeout = True
 						proc.send_signal(signal.SIGINT)
 						time.sleep(0.01)
 						proc.terminate()
@@ -548,11 +550,11 @@ def __run_command(task,sem, timeout=60, quiet=False,dry_run=False,with_stdErr=Fa
 						stream.close()
 				except Exception:
 					pass
-			if task.returncode is None:
-				# process been killed via timeout or sigkill
-				if task.stderr and task.stderr[-1].strip().startswith('Timeout!'):
-					task.returncode = 124
-				elif task.stderr and task.stderr[-1].strip().startswith('Ctrl C detected, Emergency Stop!'):
+			if inactivity_timeout:
+				task.returncode = 124
+			elif task.returncode is None:
+				# process been killed via sigkill or similar without a normal exit code
+				if task.stderr and task.stderr[-1].strip().startswith('Ctrl C detected, Emergency Stop!'):
 					task.returncode = 137
 				else:
 					task.returncode = -1

multicmd-1.49/tests/test_async_executor.py

@@ -0,0 +1,52 @@
+import time
+
+import pytest
+
+import multiCMD
+from multiCMD import AsyncExecutor, run_commands
+
+
+@pytest.mark.slow
+def test_executor_run_wait_results_codes():
+	ex = AsyncExecutor(max_threads=2, timeout=0, quiet=True)
+	ex.run_command(["echo", "a"])
+	ex.run_commands([["echo", "b"], ["false"]])
+	assert len(ex) == 3
+	assert bool(ex)
+	ex.wait(timeout=2)
+	assert ex.get_return_codes() == [0, 0, 1]
+	assert ex.get_results() == [["a"], ["b"], []]
+
+
+@pytest.mark.slow
+def test_executor_join_prints_errors(capsys):
+	ex = AsyncExecutor(max_threads=1, quiet=True)
+	ex.run_command(["false"])
+	ex.join(timeout=2, print_error=True)
+	captured = capsys.readouterr()
+	assert "failed with return code" in captured.out
+
+
+@pytest.mark.slow
+def test_executor_stop_and_cleanup():
+	ex = AsyncExecutor(max_threads=1, quiet=True)
+	ex.run_command(["sleep", "5"])
+	time.sleep(0.1)
+	ex.stop(timeout=3)
+	# stop signals task.stop; process should end
+	assert all(not t.is_alive() for t in ex.tasks)
+	ex.cleanup(timeout=1)
+	assert list(ex) == []
+
+
+@pytest.mark.slow
+def test_join_threads_module_helper():
+	tasks = run_commands(
+		[["sleep", "0.3"]],
+		wait_for_return=False,
+		return_object=True,
+		quiet=True,
+	)
+	assert tasks[0].returncode is None
+	multiCMD.join_threads(timeout=2)
+	assert tasks[0].returncode == 0

multicmd-1.49/tests/test_cli.py

@@ -0,0 +1,45 @@
+from conftest import run_cli
+import multiCMD
+
+
+def test_version_flag():
+	proc = run_cli(["-V"])
+	assert proc.returncode == 0
+	assert multiCMD.version in (proc.stdout + proc.stderr)
+
+
+def test_help_flag():
+	proc = run_cli(["-h"])
+	assert proc.returncode == 0
+	assert "max_threads" in proc.stdout
+
+
+def test_two_echoes():
+	proc = run_cli(["echo hello", "echo world"])
+	assert proc.returncode == 0
+	combined = proc.stdout + proc.stderr
+	assert "hello" in combined
+	assert "world" in combined
+
+
+def test_parse_flag_expands():
+	proc = run_cli(["-p", "echo [1-2]"])
+	assert proc.returncode == 0
+	combined = proc.stdout + proc.stderr
+	assert "[1-2]" not in combined
+	assert "Running command: echo 1" in combined
+	assert "Running command: echo 2" in combined
+
+
+def test_max_threads_and_timeout_smoke():
+	proc = run_cli(["-q", "-m", "2", "-t", "5", "echo a", "echo b"], timeout=20)
+	assert proc.returncode == 0
+
+
+def test_sudo_flag_without_sudo_binary_does_not_crash(monkeypatch):
+	# Force child env: PATH without sudo by invoking python -c wrapper is heavy;
+	# instead assert current host behavior: --sudo with missing sudo should not
+	# abort with traceback. If sudo exists, command still succeeds for echo.
+	proc = run_cli(["-q", "--sudo", "echo ok"], timeout=20)
+	assert proc.returncode == 0
+	assert "Traceback" not in (proc.stdout + proc.stderr)

multicmd-1.49/tests/test_expand_ranges.py

@@ -0,0 +1,48 @@
+import multiCMD
+from multiCMD import _expand_ranges, _expand_ranges_fast
+
+
+def test_alias_is_fast_implementation():
+	assert _expand_ranges is _expand_ranges_fast
+
+
+def test_numeric_alpha_and_comma():
+	assert _expand_ranges("file[1-3].txt") == ["file1.txt", "file2.txt", "file3.txt"]
+	assert _expand_ranges("file[a-c].txt") == ["filea.txt", "fileb.txt", "filec.txt"]
+	assert _expand_ranges("file[1-2,a-b].txt") == [
+		"file1.txt", "file2.txt", "filea.txt", "fileb.txt"
+	]
+	assert _expand_ranges("file[1-3,5].txt") == [
+		"file1.txt", "file2.txt", "file3.txt", "file5.txt"
+	]
+
+
+def test_zero_padding_shorter_endpoint_rule():
+	assert _expand_ranges("file[01-03].txt") == [
+		"file01.txt", "file02.txt", "file03.txt"
+	]
+	assert _expand_ranges("[0-10]") == [str(i) for i in range(11)]
+	assert _expand_ranges("[01-10]") == [f"{i:02d}" for i in range(1, 11)]
+
+
+def test_hex_style_alpha_range():
+	assert _expand_ranges("v[a-f]") == [f"v{c}" for c in "abcdef"]
+
+
+def test_multi_bracket_cartesian():
+	assert _expand_ranges("[1-2]-[a-b]") == ["1-a", "1-b", "2-a", "2-b"]
+
+
+def test_variable_assignment_and_reference():
+	multiCMD.__variables.clear()
+	assert _expand_ranges("[n:3]host[1-n]") == ["host1", "host2", "host3"]
+
+
+def test_brace_expression_eval():
+	multiCMD.__variables.clear()
+	assert _expand_ranges("host[{2+3}]") == ["host5"]
+
+
+def test_passthrough_without_brackets():
+	assert _expand_ranges("plainhost") == ["plainhost"]
+	assert _expand_ranges("") == [""]

multicmd-1.49/tests/test_helpers.py

@@ -0,0 +1,76 @@
+import builtins
+import select
+import sys
+
+from multiCMD import (
+	_genrate_progress_bar,
+	format_bytes,
+	get_terminal_size,
+	input_with_timeout_and_countdown,
+	int_to_color,
+	parseTable,
+	pretty_format_table,
+	print_progress_bar,
+	slugify,
+)
+
+
+def test_pretty_format_table_basic_and_remove_empty():
+	data = [["a", ""], ["b", ""]]
+	header = ["h1", "h2"]
+	out = pretty_format_table(data, header=header, remove_empty_columns=True)
+	assert out == "h1\n--\na \nb \n"
+
+
+def test_parse_table():
+	text = "col1  col2\nfoo   bar\n"
+	table = parseTable(text)
+	assert table == [["col1", "col2"], ["foo", "bar"]]
+
+
+def test_slugify_ascii_and_unicode():
+	assert slugify("Hello World!") == "hello-world"
+	assert slugify("café", allow_unicode=True) == "café"  # runtime: preserves unicode
+	assert slugify("café", allow_unicode=False) == "cafe"
+
+
+def test_format_bytes_roundtrip():
+	assert format_bytes(1024, use_1024_bytes=True, to_str=True) == "1.00 Ki"
+	assert format_bytes("1 KiB", to_int=True) == 1024
+
+
+def test_int_to_color_deterministic_and_in_range():
+	assert int_to_color(0x123456) == (36, 103, 171)
+	assert int_to_color(0) == (160, 160, 160)
+	assert int_to_color(0xFFFFFF) == (220, 220, 220)
+
+
+def test_progress_bar_helpers(capsys, monkeypatch):
+	expected_bar = (
+		"P██████████████████████████████████▁__________________________________|50.0% S"
+	)
+	assert _genrate_progress_bar(5, 10, prefix="P", suffix="S", columns=80) == expected_bar
+
+	monkeypatch.setattr(
+		"multiCMD.get_terminal_size", lambda: (80, 24)
+	)
+	print_progress_bar(5, 10, prefix="Progress:", suffix="Complete")
+	captured = capsys.readouterr()
+	assert captured.out == (
+		"\rProgress: |████████████████████████▄_________________________|50.0% | Complete"
+	)
+
+
+def test_get_terminal_size_tuple():
+	cols, rows = get_terminal_size()
+	assert cols > 0 and rows > 0
+
+
+def test_input_with_timeout_and_countdown(monkeypatch):
+	monkeypatch.setattr(builtins, "input", lambda prompt="": "user input")
+	monkeypatch.setattr(
+		select, "select", lambda r, w, x, timeout=None: ([sys.stdin], [], [])
+	)
+	assert input_with_timeout_and_countdown(5) == "user input"
+	monkeypatch.setattr(select, "select", lambda r, w, x, timeout=None: ([], [], []))
+	assert input_with_timeout_and_countdown(1) is None

multicmd-1.49/tests/test_ping.py

@@ -0,0 +1,31 @@
+import shutil
+
+import pytest
+
+from conftest import loopback_ping_works
+from multiCMD import ping
+
+pytestmark = [
+	pytest.mark.ping,
+	pytest.mark.skipif(shutil.which("ping") is None, reason="ping not installed"),
+	pytest.mark.skipif(not loopback_ping_works(), reason="loopback ping failed"),
+]
+
+
+def test_ping_single_true_false():
+	assert ping("127.0.0.1", timeout=2, quiet=True) is True
+
+
+def test_ping_list_true_false():
+	assert ping(["127.0.0.1", "127.0.0.1"], timeout=2, quiet=True) == [True, True]
+
+
+def test_ping_raw_return_codes():
+	rcs = ping(
+		["127.0.0.1"],
+		timeout=2,
+		quiet=True,
+		return_true_false=False,
+		return_code_only=True,
+	)
+	assert rcs == [0]

multicmd-1.49/tests/test_regressions.py

@@ -0,0 +1,68 @@
+import time
+
+import pytest
+
+import multiCMD
+from multiCMD import int_to_color, run_command
+
+
+def test_regression_sudo_none_path_no_typeerror():
+	"""use_sudo with SUDO_PATH=None must not prepend None into Popen argv."""
+	multiCMD.SUDO_PATH = None
+	out = run_command(["echo", "ok"], quiet=True, use_sudo=True)
+	assert out == ["ok"]
+
+
+@pytest.mark.slow
+def test_regression_stdin_eof_no_hang():
+	"""Commands that read stdin must see EOF (DEVNULL), not hang until timeout."""
+	t0 = time.time()
+	task = run_command(["cat"], quiet=True, return_object=True, timeout=2)
+	elapsed = time.time() - t0
+	assert elapsed < 1.5
+	assert task.returncode == 0
+	assert task.stdout == []
+
+
+def test_regression_int_to_color_no_recursion():
+	# Previously could RecursionError / non-deterministic str hashing
+	colors = [int_to_color(i) for i in range(0, 5000, 97)]
+	assert int_to_color(42) == int_to_color(42)
+	for rgb in colors:
+		assert all(0 <= c <= 255 for c in rgb)
+	# Distinct inputs should not all collapse onto the same color.
+	assert len(set(colors)) > 1
+
+
+@pytest.mark.slow
+def test_regression_concurrent_stdout_stderr_no_race():
+	code = (
+		"import sys\n"
+		"for i in range(200):\n"
+		"    print('O', i, flush=True)\n"
+		"    print('E', i, file=sys.stderr, flush=True)\n"
+	)
+	task = run_command(["python3", "-c", code], quiet=True, return_object=True)
+	assert task.returncode == 0
+	assert len(task.stdout) == 200
+	assert len(task.stderr) == 200
+
+
+@pytest.mark.slow
+def test_regression_inactivity_timeout_not_total_runtime():
+	"""A chatty process lasting longer than timeout must not be killed for wall time."""
+	code = (
+		"import time\n"
+		"for _ in range(6):\n"
+		"    print('tick', flush=True)\n"
+		"    time.sleep(0.25)\n"
+	)
+	task = run_command(
+		["python3", "-c", code],
+		timeout=0.5,
+		quiet=True,
+		return_object=True,
+	)
+	assert task.returncode == 0
+	assert not any(line.strip().startswith("Timeout!") for line in task.stderr)
+	assert len(task.stdout) == 6

multicmd-1.49/tests/test_run_command.py

@@ -0,0 +1,97 @@
+import time
+
+import pytest
+
+from multiCMD import run_command
+
+
+def test_echo_stdout_list():
+	assert run_command(["echo", "hello"], quiet=True) == ["hello"]
+
+
+def test_string_command_form():
+	assert run_command("echo hello", quiet=True) == ["hello"]
+
+
+def test_dry_run_empty():
+	assert run_command(["echo", "hello"], dry_run=True, quiet=True) == []
+
+
+def test_return_code_only_success_and_failure():
+	assert run_command(["echo", "hello"], return_code_only=True, quiet=True) == 0
+	assert run_command(["false"], return_code_only=True, quiet=True) == 1
+
+
+def test_return_object():
+	task = run_command(["echo", "hello"], return_object=True, quiet=True)
+	assert task.returncode == 0
+	assert task.stdout == ["hello"]
+	assert task.stderr == []
+
+
+def test_with_stderr_merged():
+	# python writes to stderr
+	out = run_command(
+		["python3", "-c", "import sys; sys.stderr.write('e\\n'); print('o')"],
+		quiet=True,
+		with_stdErr=True,
+	)
+	assert "o" in out
+	assert "e" in out
+
+
+@pytest.mark.slow
+def test_timeout_silent_command():
+	result = run_command(["sleep", "2"], timeout=0.3, quiet=True, with_stdErr=False)
+	assert "Timeout!" not in result
+	result = run_command(["sleep", "2"], timeout=0.3, quiet=True, with_stdErr=True)
+	assert "Timeout!" in "\n".join(result)
+	task = run_command(
+		["sleep", "2"], timeout=0.3, quiet=True, return_object=True
+	)
+	assert task.returncode == 124
+	assert task.stderr and task.stderr[-1].strip().startswith("Timeout!")
+
+
+@pytest.mark.slow
+def test_timeout_returncode_preserved_after_sigint_handler_stderr():
+	task = run_command(
+		[
+			"python3",
+			"-c",
+			"import signal, sys, time\n"
+			"def handler(sig, frame):\n"
+			"    sys.stderr.write('handled\\n')\n"
+			"    sys.stderr.flush()\n"
+			"    sys.exit(0)\n"
+			"signal.signal(signal.SIGINT, handler)\n"
+			"time.sleep(10)\n",
+		],
+		timeout=0.3,
+		quiet=True,
+		return_object=True,
+	)
+	assert task.returncode == 124
+	assert "Timeout!" in task.stderr
+	assert "handled" in task.stderr
+	assert task.stderr[-1].strip() == "handled"
+
+
+@pytest.mark.slow
+def test_wait_for_return_false():
+	task = run_command(
+		["sleep", "0.4"],
+		wait_for_return=False,
+		quiet=True,
+		return_object=True,
+	)
+	assert task.returncode is None
+	deadline = time.time() + 2
+	while task.returncode is None and time.time() < deadline:
+		time.sleep(0.05)
+	assert task.returncode == 0
+
+
+def test_raise_error_on_failure():
+	with pytest.raises(Exception, match="Commands failed"):
+		run_command(["false"], quiet=True, raise_error=True)

multicmd-1.49/tests/test_run_commands.py

@@ -0,0 +1,119 @@
+import threading
+import time
+
+import pytest
+
+from multiCMD import run_commands
+
+
+def test_batch_stdout():
+	assert run_commands(
+		[["echo", "hello"], ["echo", "world"]], quiet=True
+	) == [["hello"], ["world"]]
+
+
+def test_dry_run_and_return_codes():
+	cmds = [["echo", "hello"], ["echo", "world"]]
+	assert run_commands(cmds, dry_run=True, quiet=True) == [[], []]
+	assert run_commands(cmds, return_code_only=True, quiet=True) == [0, 0]
+
+
+def test_return_objects_preserve_order():
+	tasks = run_commands(
+		[["echo", "hello"], ["false"], ["echo", "world"]],
+		return_object=True,
+		quiet=True,
+	)
+	assert [t.returncode for t in tasks] == [0, 1, 0]
+	assert tasks[0].stdout == ["hello"]
+	assert tasks[2].stdout == ["world"]
+
+
+def test_parse_expands_commands():
+	result = run_commands([["echo", "[0-10]"]], quiet=True, parse=True)
+	assert result == [[str(i)] for i in range(11)]
+
+
+@pytest.mark.slow
+def test_timeout_mixed_batch():
+	result = run_commands(
+		[["sleep", "2"], ["echo", "done"]],
+		timeout=0.3,
+		quiet=True,
+		with_stdErr=True,
+		max_threads=2,
+	)
+	assert "Timeout!" in "\n".join(result[0])
+	assert result[1] == ["done"]
+
+
+@pytest.mark.slow
+def test_max_threads_scheduling():
+	# Port of legacy test_run_commands_max_threads with slightly tighter sleeps.
+	# With max_threads=2, only 2 of the 3 sleeps can run concurrently, so the
+	# 3rd is queued behind the first 2 and won't start (let alone finish)
+	# until one of them completes around t=0.6s.
+	cmds = [["sleep", "0.6"], ["sleep", "0.6"], ["sleep", "0.6"]]
+	tasks = run_commands(
+		cmds,
+		wait_for_return=False,
+		timeout=0,
+		quiet=True,
+		return_object=True,
+		max_threads=2,
+	)
+	time.sleep(0.2)
+	alive = sum(1 for t in tasks if t.returncode is None)
+	assert alive == 3
+
+	# By ~0.8s, exactly 2 of the 3 sleeps have had time to finish (the ones
+	# that started immediately); the 3rd was blocked until ~0.6s and is
+	# still running. If max_threads were not enforced (e.g. unbounded),
+	# all 3 would already be finished by this point.
+	time.sleep(0.6)
+	finished = sum(1 for t in tasks if t.returncode is not None)
+	assert finished == 2
+
+	deadline = time.time() + 3
+	while any(t.returncode is None for t in tasks) and time.time() < deadline:
+		time.sleep(0.05)
+	assert [t.returncode for t in tasks] == [0, 0, 0]
+
+
+@pytest.mark.slow
+def test_max_threads_scheduling_wall_time():
+	# Direct wall-time invariant: with max_threads=2, three 0.6s sleeps must
+	# take noticeably longer than a single 0.6s batch (2 batches of work),
+	# whereas with an unbounded/8-thread pool they'd all run concurrently
+	# and finish in ~0.6s.
+	cmds = [["sleep", "0.6"], ["sleep", "0.6"], ["sleep", "0.6"]]
+	start = time.time()
+	run_commands(
+		cmds,
+		wait_for_return=True,
+		timeout=0,
+		quiet=True,
+		max_threads=2,
+	)
+	elapsed = time.time() - start
+	assert elapsed >= 1.1
+
+
+@pytest.mark.slow
+def test_shared_semaphore_bounds_concurrency():
+	sem = threading.Semaphore(1)
+	# With sem=1, two 0.3s sleeps cannot overlap even if max_threads=2
+	t0 = time.time()
+	run_commands(
+		[["sleep", "0.3"], ["sleep", "0.3"]],
+		quiet=True,
+		max_threads=2,
+		sem=sem,
+	)
+	elapsed = time.time() - t0
+	assert elapsed >= 0.55
+
+
+def test_raise_error_batch():
+	with pytest.raises(Exception, match="Commands failed"):
+		run_commands([["true"], ["false"]], quiet=True, raise_error=True)

multicmd-1.49/tests/test_sudo.py

@@ -0,0 +1,45 @@
+import os
+
+import pytest
+
+import multiCMD
+from conftest import has_sudo_binary
+from multiCMD import run_command, set_sudo
+
+
+def test_set_sudo_false():
+	multiCMD.USE_SUDO = True
+	set_sudo(False)
+	assert multiCMD.USE_SUDO is False
+
+
+def test_set_sudo_true_when_root():
+	if os.geteuid() != 0:
+		pytest.skip("requires root to exercise root-disables-sudo path")
+	set_sudo(True)
+	assert multiCMD.USE_SUDO is False
+
+
+def test_set_sudo_true_without_sudo_binary(capsys):
+	multiCMD.SUDO_PATH = None
+	if os.geteuid() == 0:
+		pytest.skip("root path short-circuits before SUDO_PATH check")
+	set_sudo(True)
+	assert multiCMD.USE_SUDO is False
+	err = capsys.readouterr().err
+	assert "sudo not found" in err
+
+
+@pytest.mark.sudo
+def test_set_sudo_true_non_root_with_binary():
+	if os.geteuid() == 0 or not has_sudo_binary():
+		pytest.skip("needs non-root and sudo in PATH")
+	set_sudo(True)
+	assert multiCMD.USE_SUDO is True
+
+
+def test_use_sudo_none_path_does_not_crash():
+	multiCMD.SUDO_PATH = None
+	# Must not raise TypeError from Popen([None, ...])
+	result = run_command(["echo", "ok"], quiet=True, use_sudo=True)
+	assert result == ["ok"]

multicmd-1.49/tests/test_task.py

@@ -0,0 +1,22 @@
+from multiCMD import Task, run_command
+
+
+def test_task_defaults_and_iter():
+	t = Task(["echo", "x"])
+	assert t.returncode is None
+	assert t.stdout == []
+	assert t.stderr == []
+	assert t.stop is False
+	assert dict(t) == {
+		"command": ["echo", "x"],
+		"returncode": None,
+		"stdout": [],
+		"stderr": [],
+	}
+
+
+def test_task_repr_str_and_alive():
+	t = run_command(["echo", "hi"], return_object=True, quiet=True)
+	assert "hi" in str(t)
+	assert "Task(" in repr(t)
+	assert t.is_alive() is False

multicmd-1.48/multiCMD.egg-info/SOURCES.txt

@@ -1,9 +0,0 @@
-README.md
-multiCMD.py
-setup.py
-multiCMD.egg-info/PKG-INFO
-multiCMD.egg-info/SOURCES.txt
-multiCMD.egg-info/dependency_links.txt
-multiCMD.egg-info/entry_points.txt
-multiCMD.egg-info/requires.txt
-multiCMD.egg-info/top_level.txt