New upstream version 2.11upstream/2.11upstream

101 files changed, 1675 insertions, 359 deletions

diff --git a/test/t/Makefile.am b/test/t/Makefile.am
index 0ce46b12..801841fb 100644
--- a/test/t/Makefile.am
+++ b/test/t/Makefile.am
@@ -45,6 +45,7 @@ EXTRA_DIST = \
 	test_bind.py \
 	test_bison.py \
 	test_bk.py \
+	test_bmake.py \
 	test_brctl.py \
 	test_btdownloadcurses_py.py \
 	test_btdownloadgui_py.py \
@@ -132,6 +133,7 @@ EXTRA_DIST = \
 	test_dot.py \
 	test_dpkg.py \
 	test_dpkg_deb.py \
+	test_dpkg_query.py \
 	test_dpkg_reconfigure.py \
 	test_dpkg_source.py \
 	test_dropdb.py \
@@ -249,6 +251,7 @@ EXTRA_DIST = \
 	test_invoke_rc_d.py \
 	test_ionice.py \
 	test_ip.py \
+	test_ipcalc.py \
 	test_iperf.py \
 	test_ipmitool.py \
 	test_ipsec.py \
@@ -456,6 +459,7 @@ EXTRA_DIST = \
 	test_povray.py \
 	test_pr.py \
 	test_prelink.py \
+	test_printenv.py \
 	test_protoc.py \
 	test_psql.py \
 	test_ptx.py \
@@ -523,9 +527,11 @@ EXTRA_DIST = \
 	test_sbcl.py \
 	test_sbcl_mt.py \
 	test_sbopkg.py \
+	test_scp.py \
 	test_screen.py \
 	test_scrub.py \
 	test_sdptool.py \
+	test_secret_tool.py \
 	test_sed.py \
 	test_seq.py \
 	test_service.py \
@@ -589,11 +595,13 @@ EXTRA_DIST = \
 	test_time.py \
 	test_timeout.py \
 	test_tipc.py \
+	test_totem.py \
 	test_touch.py \
 	test_tox.py \
 	test_tr.py \
 	test_tracepath.py \
 	test_tshark.py \
+	test_tsig_keygen.py \
 	test_tune2fs.py \
 	test_udevadm.py \
 	test_ulimit.py \
@@ -657,6 +665,7 @@ EXTRA_DIST = \
 	test_xdg_settings.py \
 	test_xfreerdp.py \
 	test_xgamma.py \
+	test_xhost.py \
 	test_xm.py \
 	test_xmllint.py \
 	test_xmlwf.py \
diff --git a/test/t/conftest.py b/test/t/conftest.py
index 20942e87..5c1603d5 100644
--- a/test/t/conftest.py
+++ b/test/t/conftest.py
@@ -3,18 +3,18 @@ import os
 import re
 import shlex
 import subprocess
-from typing import Iterable, List, Optional, Tuple, Union
+import time
+from typing import Callable, Iterable, Iterator, List, Optional, Tuple
 
 import pexpect
 import pytest
 
-
 PS1 = "/@"
 MAGIC_MARK = "__MaGiC-maRKz!__"
 
 
 def find_unique_completion_pair(
-    items: Iterable[str]
+    items: Iterable[str],
 ) -> Optional[Tuple[str, str]]:
     result = None
     bestscore = 0
@@ -56,10 +56,22 @@ def find_unique_completion_pair(
 
 
 @pytest.fixture(scope="class")
-def part_full_user(bash: pexpect.spawn) -> Optional[Tuple[str, str]]:
-    res = (
-        assert_bash_exec(bash, "compgen -u", want_output=True).strip().split()
-    )
+def output_sort_uniq(bash: pexpect.spawn) -> Callable[[str], List[str]]:
+    def _output_sort_uniq(command: str) -> List[str]:
+        return sorted(
+            set(  # weed out possible duplicates
+                assert_bash_exec(bash, command, want_output=True).split()
+            )
+        )
+
+    return _output_sort_uniq
+
+
+@pytest.fixture(scope="class")
+def part_full_user(
+    bash: pexpect.spawn, output_sort_uniq: Callable[[str], List[str]]
+) -> Optional[Tuple[str, str]]:
+    res = output_sort_uniq("compgen -u")
     pair = find_unique_completion_pair(res)
     if not pair:
         pytest.skip("No suitable test user found")
@@ -67,10 +79,10 @@ def part_full_user(bash: pexpect.spawn) -> Optional[Tuple[str, str]]:
 
 
 @pytest.fixture(scope="class")
-def part_full_group(bash: pexpect.spawn) -> Optional[Tuple[str, str]]:
-    res = (
-        assert_bash_exec(bash, "compgen -g", want_output=True).strip().split()
-    )
+def part_full_group(
+    bash: pexpect.spawn, output_sort_uniq: Callable[[str], List[str]]
+) -> Optional[Tuple[str, str]]:
+    res = output_sort_uniq("compgen -g")
     pair = find_unique_completion_pair(res)
     if not pair:
         pytest.skip("No suitable test user found")
@@ -78,6 +90,82 @@ def part_full_group(bash: pexpect.spawn) -> Optional[Tuple[str, str]]:
 
 
 @pytest.fixture(scope="class")
+def hosts(bash: pexpect.spawn) -> List[str]:
+    output = assert_bash_exec(bash, "compgen -A hostname", want_output=True)
+    return sorted(set(output.split() + _avahi_hosts(bash)))
+
+
+@pytest.fixture(scope="class")
+def avahi_hosts(bash: pexpect.spawn) -> List[str]:
+    return _avahi_hosts(bash)
+
+
+def _avahi_hosts(bash: pexpect.spawn) -> List[str]:
+    output = assert_bash_exec(
+        bash,
+        "! type avahi-browse &>/dev/null || "
+        "avahi-browse -cpr _workstation._tcp 2>/dev/null "
+        "| command grep ^= | cut -d';' -f7",
+        want_output=None,
+    )
+    return sorted(set(output.split()))
+
+
+@pytest.fixture(scope="class")
+def known_hosts(bash: pexpect.spawn) -> List[str]:
+    output = assert_bash_exec(
+        bash,
+        '_known_hosts_real ""; '
+        r'printf "%s\n" "${COMPREPLY[@]}"; unset COMPREPLY',
+        want_output=True,
+    )
+    return sorted(set(output.split()))
+
+
+@pytest.fixture(scope="class")
+def user_home(bash: pexpect.spawn) -> Tuple[str, str]:
+    user = assert_bash_exec(
+        bash, 'id -un 2>/dev/null || echo "$USER"', want_output=True
+    ).strip()
+    home = assert_bash_exec(bash, 'echo "$HOME"', want_output=True).strip()
+    return (user, home)
+
+
+def partialize(
+    bash: pexpect.spawn, items: Iterable[str]
+) -> Tuple[str, List[str]]:
+    """
+    Get list of items starting with the first char of first of items.
+
+    Disregard items starting with a COMP_WORDBREAKS character
+    (e.g. a colon ~ IPv6 address), they are special cases requiring
+    special tests.
+    """
+    first_char = None
+    comp_wordbreaks = assert_bash_exec(
+        bash,
+        'printf "%s" "$COMP_WORDBREAKS"',
+        want_output=True,
+        want_newline=False,
+    )
+    partial_items = []
+    for item in sorted(items):
+        if first_char is None:
+            if item[0] not in comp_wordbreaks:
+                first_char = item[0]
+                partial_items.append(item)
+        elif item.startswith(first_char):
+            partial_items.append(item)
+        else:
+            break
+    if first_char is None:
+        pytest.skip("Could not generate partial items list from %s" % items)
+        # superfluous/dead code to assist mypy; pytest.skip always raises
+        assert first_char is not None
+    return first_char, partial_items
+
+
+@pytest.fixture(scope="class")
 def bash(request) -> pexpect.spawn:
 
     logfile = None
@@ -135,7 +223,7 @@ def bash(request) -> pexpect.spawn:
         skipif = marker.kwargs.get("skipif")
         if skipif:
             try:
-                assert_bash_exec(bash, skipif)
+                assert_bash_exec(bash, skipif, want_output=None)
             except AssertionError:
                 pass
             else:
@@ -144,7 +232,7 @@ def bash(request) -> pexpect.spawn:
         xfail = marker.kwargs.get("xfail")
         if xfail:
             try:
-                assert_bash_exec(bash, xfail)
+                assert_bash_exec(bash, xfail, want_output=None)
             except AssertionError:
                 pass
             else:
@@ -182,7 +270,7 @@ def bash(request) -> pexpect.spawn:
         logfile.close()
 
 
-def is_testable(bash: pexpect.spawn, cmd: str) -> bool:
+def is_testable(bash: pexpect.spawn, cmd: Optional[str]) -> bool:
     if not cmd:
         pytest.fail("Could not resolve name of command to test")
         return False
@@ -214,8 +302,14 @@ def load_completion_for(bash: pexpect.spawn, cmd: str) -> bool:
 
 
 def assert_bash_exec(
-    bash: pexpect.spawn, cmd: str, want_output: bool = False, want_newline=True
+    bash: pexpect.spawn,
+    cmd: str,
+    want_output: Optional[bool] = False,
+    want_newline=True,
 ) -> str:
+    """
+    :param want_output: if None, don't care if got output or not
+    """
 
     # Send command
     bash.sendline(cmd)
@@ -243,16 +337,17 @@ def assert_bash_exec(
         status,
         output,
     )
-    if output:
-        assert want_output, (
-            'Unexpected output from "%s": exit status=%s, output="%s"'
-            % (cmd, status, output)
-        )
-    else:
-        assert not want_output, (
-            'Expected output from "%s": exit status=%s, output="%s"'
-            % (cmd, status, output)
-        )
+    if want_output is not None:
+        if output:
+            assert want_output, (
+                'Unexpected output from "%s": exit status=%s, output="%s"'
+                % (cmd, status, output)
+            )
+        else:
+            assert not want_output, (
+                'Expected output from "%s": exit status=%s, output="%s"'
+                % (cmd, status, output)
+            )
 
     return output
 
@@ -293,76 +388,52 @@ def diff_env(before: List[str], after: List[str], ignore: str):
     assert not diff, "Environment should not be modified"
 
 
-class CompletionResult:
+class CompletionResult(Iterable[str]):
     """
     Class to hold completion results.
     """
 
-    def __init__(self, output: str, items: Optional[Iterable[str]] = None):
+    def __init__(self, output: Optional[str] = None):
         """
-        When items are specified, they are used as the base for comparisons
-        provided by this class. When not, regular expressions are used instead.
-        This is because it is not always possible to unambiguously split a
-        completion output string into individual items, for example when the
-        items contain whitespace.
-
         :param output: All completion output as-is.
-        :param items: Completions as individual items. Should be specified
-            only in cases where the completions are robustly known to be
-            exactly the specified ones.
         """
-        self.output = output
-        self._items = None if items is None else sorted(items)
+        self.output = output or ""
 
     def endswith(self, suffix: str) -> bool:
         return self.output.endswith(suffix)
 
-    def __eq__(self, expected: Union[str, Iterable[str]]) -> bool:
+    def startswith(self, prefix: str) -> bool:
+        return self.output.startswith(prefix)
+
+    def _items(self) -> List[str]:
+        return [x.strip() for x in self.output.strip().splitlines()]
+
+    def __eq__(self, expected: object) -> bool:
         """
         Returns True if completion contains expected items, and no others.
 
         Defining __eq__ this way is quite ugly, but facilitates concise
         testing code.
         """
-        expiter = [expected] if isinstance(expected, str) else expected
-        if self._items is not None:
-            return self._items == expiter
-        return bool(
-            re.match(
-                r"^\s*" + r"\s+".join(re.escape(x) for x in expiter) + r"\s*$",
-                self.output,
-            )
-        )
+        if isinstance(expected, str):
+            expiter = [expected]  # type: Iterable
+        elif not isinstance(expected, Iterable):
+            return False
+        else:
+            expiter = expected
+        return self._items() == expiter
 
     def __contains__(self, item: str) -> bool:
-        if self._items is not None:
-            return item in self._items
-        return bool(
-            re.search(r"(^|\s)%s(\s|$)" % re.escape(item), self.output)
-        )
+        return item in self._items()
 
-    def __iter__(self) -> Iterable[str]:
-        """
-        Note that iteration over items may not be accurate when items were not
-        specified to the constructor, if individual items in the output contain
-        whitespace. In those cases, it errs on the side of possibly returning
-        more items than there actually are, and intends to never return fewer.
-        """
-        return iter(
-            self._items
-            if self._items is not None
-            else re.split(r" {2,}|\r\n", self.output.strip())
-        )
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._items())
 
     def __len__(self) -> int:
-        """
-        Uses __iter__, see caveat in it. While possibly inaccurate, this is
-        good enough for truthiness checks.
-        """
-        return len(list(iter(self)))
+        return len(self._items())
 
     def __repr__(self) -> str:
-        return "<CompletionResult %s>" % list(self)
+        return "<CompletionResult %s>" % self._items()
 
 
 def assert_complete(
@@ -371,7 +442,7 @@ def assert_complete(
     skipif = kwargs.get("skipif")
     if skipif:
         try:
-            assert_bash_exec(bash, skipif)
+            assert_bash_exec(bash, skipif, want_output=None)
         except AssertionError:
             pass
         else:
@@ -379,7 +450,7 @@ def assert_complete(
     xfail = kwargs.get("xfail")
     if xfail:
         try:
-            assert_bash_exec(bash, xfail)
+            assert_bash_exec(bash, xfail, want_output=None)
         except AssertionError:
             pass
         else:
@@ -393,57 +464,63 @@ def assert_complete(
         # Back up environment and apply new one
         assert_bash_exec(
             bash,
-            " ".join('%s%s="$%s"' % (env_prefix, k, k) for k in env.keys()),
+            " ".join('%s%s="${%s-}"' % (env_prefix, k, k) for k in env.keys()),
         )
         assert_bash_exec(
             bash,
             "export %s" % " ".join("%s=%s" % (k, v) for k, v in env.items()),
         )
-    bash.send(cmd + "\t")
-    bash.expect_exact(cmd)
-    bash.send(MAGIC_MARK)
-    got = bash.expect(
-        [
-            # 0: multiple lines, result in .before
-            r"\r\n" + re.escape(PS1 + cmd) + ".*" + MAGIC_MARK,
-            # 1: no completion
-            r"^" + MAGIC_MARK,
-            # 2: on same line, result in .match
-            r"^([^\r]+)%s$" % MAGIC_MARK,
-            pexpect.EOF,
-            pexpect.TIMEOUT,
-        ]
-    )
-    if got == 0:
-        output = bash.before
-        if output.endswith(MAGIC_MARK):
-            output = bash.before[: -len(MAGIC_MARK)]
-        result = CompletionResult(output)
-    elif got == 2:
-        output = bash.match.group(1)
-        result = CompletionResult(output, [shlex.split(cmd + output)[-1]])
-    else:
-        # TODO: warn about EOF/TIMEOUT?
-        result = CompletionResult("", [])
-    bash.sendintr()
-    bash.expect_exact(PS1)
-    if env:
-        # Restore environment, and clean up backup
-        # TODO: Test with declare -p if a var was set, backup only if yes, and
-        #       similarly restore only backed up vars. Should remove some need
-        #       for ignore_env.
-        assert_bash_exec(
-            bash,
-            "export %s"
-            % " ".join('%s="$%s%s"' % (k, env_prefix, k) for k in env.keys()),
-        )
-        assert_bash_exec(
-            bash,
-            "unset -v %s"
-            % " ".join("%s%s" % (env_prefix, k) for k in env.keys()),
+    try:
+        bash.send(cmd + "\t")
+        # Sleep a bit if requested, to avoid `.*` matching too early
+        time.sleep(kwargs.get("sleep_after_tab", 0))
+        bash.expect_exact(cmd)
+        bash.send(MAGIC_MARK)
+        got = bash.expect(
+            [
+                # 0: multiple lines, result in .before
+                r"\r\n" + re.escape(PS1 + cmd) + ".*" + re.escape(MAGIC_MARK),
+                # 1: no completion
+                r"^" + re.escape(MAGIC_MARK),
+                # 2: on same line, result in .match
+                r"^([^\r]+)%s$" % re.escape(MAGIC_MARK),
+                pexpect.EOF,
+                pexpect.TIMEOUT,
+            ]
         )
-    if cwd:
-        assert_bash_exec(bash, "cd - >/dev/null")
+        if got == 0:
+            output = bash.before
+            if output.endswith(MAGIC_MARK):
+                output = bash.before[: -len(MAGIC_MARK)]
+            result = CompletionResult(output)
+        elif got == 2:
+            output = bash.match.group(1)
+            result = CompletionResult(output)
+        else:
+            # TODO: warn about EOF/TIMEOUT?
+            result = CompletionResult()
+    finally:
+        bash.sendintr()
+        bash.expect_exact(PS1)
+        if env:
+            # Restore environment, and clean up backup
+            # TODO: Test with declare -p if a var was set, backup only if yes, and
+            #       similarly restore only backed up vars. Should remove some need
+            #       for ignore_env.
+            assert_bash_exec(
+                bash,
+                "export %s"
+                % " ".join(
+                    '%s="$%s%s"' % (k, env_prefix, k) for k in env.keys()
+                ),
+            )
+            assert_bash_exec(
+                bash,
+                "unset -v %s"
+                % " ".join("%s%s" % (env_prefix, k) for k in env.keys()),
+            )
+        if cwd:
+            assert_bash_exec(bash, "cd - >/dev/null")
     return result
 
 
@@ -451,7 +528,7 @@ def assert_complete(
 def completion(request, bash: pexpect.spawn) -> CompletionResult:
     marker = request.node.get_closest_marker("complete")
     if not marker:
-        return CompletionResult("", [])
+        return CompletionResult()
     for pre_cmd in marker.kwargs.get("pre_cmds", []):
         assert_bash_exec(bash, pre_cmd)
     cmd = getattr(request.cls, "cmd", None)
@@ -467,9 +544,61 @@ def completion(request, bash: pexpect.spawn) -> CompletionResult:
             ) % ((cmd,) * 2)
     if marker.kwargs.get("require_cmd") and not is_bash_type(bash, cmd):
         pytest.skip("Command not found")
+
+    if "trail" in marker.kwargs:
+        return assert_complete_at_point(
+            bash, cmd=marker.args[0], trail=marker.kwargs["trail"]
+        )
+
     return assert_complete(bash, marker.args[0], **marker.kwargs)
 
 
+def assert_complete_at_point(
+    bash: pexpect.spawn, cmd: str, trail: str
+) -> CompletionResult:
+    # TODO: merge to assert_complete
+    fullcmd = "%s%s%s" % (
+        cmd,
+        trail,
+        "\002" * len(trail),
+    )  # \002 = ^B = cursor left
+    bash.send(fullcmd + "\t")
+    bash.send(MAGIC_MARK)
+    bash.expect_exact(fullcmd.replace("\002", "\b"))
+
+    got = bash.expect_exact(
+        [
+            # 0: multiple lines, result in .before
+            PS1 + fullcmd.replace("\002", "\b"),
+            # 1: no completion
+            MAGIC_MARK,
+            pexpect.EOF,
+            pexpect.TIMEOUT,
+        ]
+    )
+    if got == 0:
+        output = bash.before
+        result = CompletionResult(output)
+
+        # At this point, something weird happens. For most test setups, as
+        # expected (pun intended!), MAGIC_MARK follows as is. But for some
+        # others (e.g. CentOS 6, Ubuntu 14 test containers), we get MAGIC_MARK
+        # one character a time, followed each time by trail and the corresponding
+        # number of \b's. Don't know why, but accept it until/if someone finds out.
+        # Or just be fine with it indefinitely, the visible and practical end
+        # result on a terminal is the same anyway.
+        repeat = "(%s%s)?" % (re.escape(trail), "\b" * len(trail))
+        fullexpected = "".join(
+            "%s%s" % (re.escape(x), repeat) for x in MAGIC_MARK
+        )
+        bash.expect(fullexpected)
+    else:
+        # TODO: warn about EOF/TIMEOUT?
+        result = CompletionResult()
+
+    return result
+
+
 def in_container() -> bool:
     try:
         container = subprocess.check_output(
diff --git a/test/t/test_2to3.py b/test/t/test_2to3.py
index 030fb261..4bce44e6 100644
--- a/test/t/test_2to3.py
+++ b/test/t/test_2to3.py
@@ -6,6 +6,6 @@ class Test2to3:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.complete("2to3 -", require_cmd=True)
+    @pytest.mark.complete("2to3 -", require_cmd=True, require_longopt=True)
     def test_2(self, completion):
         assert completion
diff --git a/test/t/test_7z.py b/test/t/test_7z.py
index c6e73890..d4308d95 100644
--- a/test/t/test_7z.py
+++ b/test/t/test_7z.py
@@ -8,12 +8,11 @@ class Test7z:
 
     @pytest.mark.complete("7z a ar -tzi")
     def test_2(self, completion):
-        assert completion == "-tzip"
+        assert completion == "p"
 
-    @pytest.mark.xfail  # TODO: whitespace split issue
     @pytest.mark.complete(r"7z x -wa\ ", cwd="_filedir")
     def test_3(self, completion):
-        assert completion == r"-wa\ b/"
+        assert completion == "b/"
         assert not completion.endswith(" ")
 
     @pytest.mark.complete("7z x ", cwd="7z")
diff --git a/test/t/test_alias.py b/test/t/test_alias.py
index da9ecc33..cc592a8c 100644
--- a/test/t/test_alias.py
+++ b/test/t/test_alias.py
@@ -15,3 +15,7 @@ class TestAlias:
     def test_2(self, completion):
         assert completion == "foo='bar'"
         assert not completion.endswith(" ")
+
+    @pytest.mark.complete("alias ", trail="foo")
+    def test_alias_at_point(self, completion):
+        assert completion == "bar foo".split()
diff --git a/test/t/test_ant.py b/test/t/test_ant.py
index b14beb94..94acea11 100644
--- a/test/t/test_ant.py
+++ b/test/t/test_ant.py
@@ -1,5 +1,7 @@
 import pytest
 
+from conftest import assert_bash_exec
+
 
 @pytest.mark.bashcomp(ignore_env=r"^\+ANT_ARGS=")
 class TestAnt:
@@ -18,8 +20,15 @@ class TestAnt:
     @pytest.mark.complete(
         "ant ", cwd="ant", env=dict(ANT_ARGS="'-f named-build.xml'")
     )
-    def test_4(self, completion):
-        assert completion == "named-build"
+    def test_4(self, bash, completion):
+        output = assert_bash_exec(bash, "complete -p ant", want_output=True)
+        if "complete-ant-cmd.pl" in output:
+            # Some versions of complete-ant-cmd.pl don't treat ANT_ARGS right;
+            # in those cases we get the correct completion produced by _ant
+            # plus whatever complete-ant-cmd.pl was able to get from build.xml
+            assert "named-build" in completion
+        else:
+            assert completion == "named-build"
 
     @pytest.mark.complete("ant -l ")
     def test_5(self, completion):
diff --git a/test/t/test_apt_cache.py b/test/t/test_apt_cache.py
index a1c29cda..f9329f22 100644
--- a/test/t/test_apt_cache.py
+++ b/test/t/test_apt_cache.py
@@ -5,9 +5,13 @@ import pytest
 class TestAptCache:
     @pytest.mark.complete("apt-cache ")
     def test_1(self, completion):
-        assert completion
+        assert "search" in completion
 
     @pytest.mark.complete("apt-cache showsrc [", require_cmd=True)
     def test_2(self, completion):
         # Doesn't actually fail on grep errors, but takes a long time.
         assert not completion
+
+    @pytest.mark.complete("apt-cache ", trail=" add foo")
+    def test_special_at_point(self, completion):
+        assert not completion
diff --git a/test/t/test_apt_get.py b/test/t/test_apt_get.py
index ccdff6cd..dc8299a9 100644
--- a/test/t/test_apt_get.py
+++ b/test/t/test_apt_get.py
@@ -9,4 +9,8 @@ class TestAptGet:
 
     @pytest.mark.complete("apt-get install ./", cwd="dpkg")
     def test_2(self, completion):
-        assert completion == "./bash-completion-test-subject.deb"
+        assert completion == "bash-completion-test-subject.deb"
+
+    @pytest.mark.complete("apt-get build-dep ")
+    def test_build_dep_dirs(self, completion):
+        assert "dpkg/" in completion
diff --git a/test/t/test_aptitude.py b/test/t/test_aptitude.py
index c59c3580..29569f15 100644
--- a/test/t/test_aptitude.py
+++ b/test/t/test_aptitude.py
@@ -5,3 +5,19 @@ class TestAptitude:
     @pytest.mark.complete("aptitude ")
     def test_1(self, completion):
         assert completion
+
+    @pytest.mark.complete("aptitude -", require_cmd=True)
+    def test_options(self, completion):
+        assert completion
+
+    @pytest.mark.complete("aptitude --", require_cmd=True)
+    def test_long_options(self, completion):
+        assert completion
+
+    @pytest.mark.complete("aptitude -u -")
+    def test_no_i_with_u(self, completion):
+        assert "-i" not in completion
+
+    @pytest.mark.complete("aptitude -i -")
+    def test_no_u_with_i(self, completion):
+        assert "-u" not in completion
diff --git a/test/t/test_arpspoof.py b/test/t/test_arpspoof.py
index c8955f8d..74c09a43 100644
--- a/test/t/test_arpspoof.py
+++ b/test/t/test_arpspoof.py
@@ -2,6 +2,11 @@ import pytest
 
 
 class TestArpspoof:
-    @pytest.mark.complete("arpspoof -", require_cmd=True)
+    @pytest.mark.complete(
+        "arpspoof -",
+        require_cmd=True,
+        # May require privileges even for outputting the usage message
+        skipif="arpspoof 2>&1 | command grep -qF libnet_open_link",
+    )
     def test_1(self, completion):
         assert completion
diff --git a/test/t/test_bmake.py b/test/t/test_bmake.py
new file mode 100644
index 00000000..bc885d31
--- /dev/null
+++ b/test/t/test_bmake.py
@@ -0,0 +1,7 @@
+import pytest
+
+
+class TestBmake:
+    @pytest.mark.complete("bmake -", require_cmd=True)
+    def test_options(self, completion):
+        assert completion
diff --git a/test/t/test_ccache.py b/test/t/test_ccache.py
index 64620ef4..ef55d0d8 100644
--- a/test/t/test_ccache.py
+++ b/test/t/test_ccache.py
@@ -12,15 +12,15 @@ class TestCcache:
 
     @pytest.mark.complete("ccache stt")
     def test_3(self, completion):
-        assert "stty" in completion
+        assert completion == "y" or "stty" in completion
 
     @pytest.mark.complete("ccache --zero-stats stt")
     def test_4(self, completion):
-        assert "stty" in completion
+        assert completion == "y" or "stty" in completion
 
     @pytest.mark.complete("ccache --hel", require_cmd=True)
     def test_5(self, completion):
-        assert "--help" in completion
+        assert completion == "p" or "--help" in completion
 
     @pytest.mark.complete("ccache --zero-stats sh +")
     def test_6(self, completion):
diff --git a/test/t/test_cd.py b/test/t/test_cd.py
index fd532312..5b7789ae 100644
--- a/test/t/test_cd.py
+++ b/test/t/test_cd.py
@@ -9,7 +9,7 @@ class TestCd:
 
     @pytest.mark.complete("cd fo", env=dict(CDPATH="shared/default"))
     def test_2(self, completion):
-        assert completion == "foo.d/"
+        assert completion == "o.d/"
 
     @pytest.mark.complete("cd fo")
     def test_3(self, completion):
@@ -20,3 +20,7 @@ class TestCd:
     )
     def test_4(self, completion):
         assert not completion  # No subdirs nor CDPATH
+
+    @pytest.mark.complete("cd shared/default/", trail="foo")
+    def test_dir_at_point(self, completion):
+        assert completion == ["bar bar.d/", "foo.d/"]
diff --git a/test/t/test_chown.py b/test/t/test_chown.py
index 37221cfa..9643f3eb 100644
--- a/test/t/test_chown.py
+++ b/test/t/test_chown.py
@@ -2,7 +2,7 @@ import getpass
 
 import pytest
 
-from conftest import assert_bash_exec, assert_complete
+from conftest import assert_complete
 
 
 @pytest.mark.bashcomp(
@@ -16,10 +16,8 @@ class TestChown:
         getpass.getuser() != "root", reason="Only root can chown to all users"
     )
     @pytest.mark.complete("chown ")
-    def test_1(self, bash, completion):
-        users = sorted(
-            assert_bash_exec(bash, "compgen -A user", want_output=True).split()
-        )
+    def test_1(self, bash, completion, output_sort_uniq):
+        users = output_sort_uniq("compgen -u")
         assert completion == users
 
     @pytest.mark.complete("chown foo: shared/default/")
@@ -33,37 +31,39 @@ class TestChown:
     def test_4(self, bash, part_full_user):
         part, full = part_full_user
         completion = assert_complete(bash, "chown %s" % part)
-        assert completion == full
+        assert completion == full[len(part) :]
         assert completion.endswith(" ")
 
     def test_5(self, bash, part_full_user, part_full_group):
         _, user = part_full_user
         partgroup, fullgroup = part_full_group
         completion = assert_complete(bash, "chown %s:%s" % (user, partgroup))
-        assert completion == "%s:%s" % (user, fullgroup)
+        assert completion == fullgroup[len(partgroup) :]
         assert completion.output.endswith(" ")
 
     def test_6(self, bash, part_full_group):
         part, full = part_full_group
         completion = assert_complete(bash, "chown dot.user:%s" % part)
-        assert completion == "dot.user:%s" % full
+        assert completion == full[len(part) :]
         assert completion.output.endswith(" ")
 
-    @pytest.mark.xfail  # TODO check escaping, whitespace
-    def test_7(self, bash, part_full_group):
-        """Test preserving special chars in $prefix$partgroup<TAB>."""
-        part, full = part_full_group
-        for prefix in (
+    @pytest.mark.parametrize(
+        "prefix",
+        [
             r"funky\ user:",
             "funky.user:",
             r"funky\.user:",
             r"fu\ nky.user:",
             r"f\ o\ o\.\bar:",
             r"foo\_b\ a\.r\ :",
-        ):
-            completion = assert_complete(bash, "chown %s%s" % (prefix, part))
-            assert completion == "%s%s" % (prefix, full)
-            assert completion.output.endswith(" ")
+        ],
+    )
+    def test_7(self, bash, part_full_group, prefix):
+        """Test preserving special chars in $prefix$partgroup<TAB>."""
+        part, full = part_full_group
+        completion = assert_complete(bash, "chown %s%s" % (prefix, part))
+        assert completion == full[len(part) :]
+        assert completion.output.endswith(" ")
 
     def test_8(self, bash, part_full_user, part_full_group):
         """Test giving up on degenerate cases instead of spewing junk."""
diff --git a/test/t/test_complete.py b/test/t/test_complete.py
index 036f954e..7ff56b41 100644
--- a/test/t/test_complete.py
+++ b/test/t/test_complete.py
@@ -5,3 +5,7 @@ class TestComplete:
     @pytest.mark.complete("complete -")
     def test_1(self, completion):
         assert completion
+
+    @pytest.mark.complete(r"\complete -")
+    def test_2(self, completion):
+        assert completion
diff --git a/test/t/test_cpan2dist.py b/test/t/test_cpan2dist.py
index f456c0ce..1ab5de13 100644
--- a/test/t/test_cpan2dist.py
+++ b/test/t/test_cpan2dist.py
@@ -2,6 +2,8 @@ import pytest
 
 
 class TestCpan2dist:
-    @pytest.mark.complete("cpan2dist -", require_cmd=True)
+    @pytest.mark.complete(
+        "cpan2dist -", require_cmd=True, require_longopt=True
+    )
     def test_1(self, completion):
         assert completion
diff --git a/test/t/test_cpio.py b/test/t/test_cpio.py
index 1b9e37df..0b739663 100644
--- a/test/t/test_cpio.py
+++ b/test/t/test_cpio.py
@@ -1,7 +1,5 @@
 import pytest
 
-from conftest import assert_bash_exec
-
 
 class TestCpio:
     @pytest.mark.complete("cpio --")
@@ -9,10 +7,6 @@ class TestCpio:
         assert completion
 
     @pytest.mark.complete("cpio -R ")
-    def test_2(self, bash, completion):
-        users = sorted(
-            assert_bash_exec(bash, "compgen -A user", want_output=True)
-            .strip()
-            .splitlines()
-        )
-        assert list(completion) == users
+    def test_2(self, bash, completion, output_sort_uniq):
+        users = output_sort_uniq("compgen -u")
+        assert completion == users
diff --git a/test/t/test_cppcheck.py b/test/t/test_cppcheck.py
index da770786..73e64f5e 100644
--- a/test/t/test_cppcheck.py
+++ b/test/t/test_cppcheck.py
@@ -20,12 +20,12 @@ class TestCppcheck:
 
     @pytest.mark.complete("cppcheck --enable=al")
     def test_5(self, completion):
-        assert completion == "--enable=all"
+        assert completion == "l"
 
     @pytest.mark.complete("cppcheck --enable=xx,styl")
     def test_6(self, completion):
-        assert completion == "--enable=xx,style"
+        assert completion == "e"
 
     @pytest.mark.complete("cppcheck --enable=xx,yy,styl")
     def test_7(self, completion):
-        assert completion == "--enable=xx,yy,style"
+        assert completion == "e"
diff --git a/test/t/test_crontab.py b/test/t/test_crontab.py
index 098fd9e0..a476694c 100644
--- a/test/t/test_crontab.py
+++ b/test/t/test_crontab.py
@@ -5,3 +5,12 @@ class TestCrontab:
     @pytest.mark.complete("crontab ")
     def test_1(self, completion):
         assert completion
+
+    @pytest.mark.complete("crontab -l -")
+    def test_only_u_with_l(self, completion):
+        assert completion == "u"
+
+    @pytest.mark.complete("crontab -r -")
+    def test_no_l_with_r(self, completion):
+        assert completion
+        assert "-l" not in completion
diff --git a/test/t/test_curl.py b/test/t/test_curl.py
index ebccca95..63e969f9 100644
--- a/test/t/test_curl.py
+++ b/test/t/test_curl.py
@@ -8,11 +8,11 @@ class TestCurl:
 
     @pytest.mark.complete("curl -o f", cwd="shared/default/foo.d")
     def test_2(self, completion):
-        assert completion == "foo"
+        assert completion == "oo"
 
     @pytest.mark.complete("curl -LRo f", cwd="shared/default/foo.d")
     def test_3(self, completion):
-        assert completion == "foo"
+        assert completion == "oo"
 
     @pytest.mark.complete("curl --o f")
     def test_4(self, completion):
@@ -20,9 +20,9 @@ class TestCurl:
 
     @pytest.mark.complete("curl --data @", cwd="shared/default/foo.d")
     def test_data_atfile(self, completion):
-        assert completion == "@foo"
+        assert completion == "foo"
 
     @pytest.mark.complete("curl --data @foo.", cwd="shared/default")
     def test_data_atfile_dir(self, completion):
-        assert completion == "@foo.d/"
+        assert completion == "d/"
         assert not completion.endswith(" ")
diff --git a/test/t/test_cvs.py b/test/t/test_cvs.py
index ab7fead8..97361e9e 100644
--- a/test/t/test_cvs.py
+++ b/test/t/test_cvs.py
@@ -13,7 +13,7 @@ class TestCvs:
 
     @pytest.mark.complete("cvs diff foo/", cwd="cvs")
     def test_3(self, completion):
-        assert completion == "foo/bar"
+        assert completion == "bar"
 
     @pytest.mark.complete("cvs -", require_cmd=True)
     def test_4(self, completion):
diff --git a/test/t/test_dd.py b/test/t/test_dd.py
index be1829d3..e082faa9 100644
--- a/test/t/test_dd.py
+++ b/test/t/test_dd.py
@@ -14,4 +14,4 @@ class TestDd:
 
     @pytest.mark.complete("dd bs")
     def test_2(self, completion):
-        assert completion == "bs="
+        assert completion == "="
diff --git a/test/t/test_dmypy.py b/test/t/test_dmypy.py
index efaef7ca..4c031ddd 100644
--- a/test/t/test_dmypy.py
+++ b/test/t/test_dmypy.py
@@ -2,11 +2,13 @@ import pytest
 
 
 class TestDmypy:
-    @pytest.mark.complete("dmypy ", require_cmd=True)
+    @pytest.mark.complete(
+        "dmypy ", require_cmd=True, xfail="! dmypy --help &>/dev/null"
+    )
     def test_commands(self, completion):
         assert "help" in completion
         assert not any("," in x for x in completion)
 
-    @pytest.mark.complete("dmypy -", require_cmd=True)
+    @pytest.mark.complete("dmypy -", require_cmd=True, require_longopt=True)
     def test_options(self, completion):
         assert "--help" in completion
diff --git a/test/t/test_dnssec_keygen.py b/test/t/test_dnssec_keygen.py
index d52e3af0..f8bd6fb1 100644
--- a/test/t/test_dnssec_keygen.py
+++ b/test/t/test_dnssec_keygen.py
@@ -13,7 +13,7 @@ class TestDnssecKeygen:
     @pytest.mark.complete("dnssec-keygen -a ")
     def test_2(self, completion):
         assert completion
-        assert "HMAC-MD5" in completion
+        assert any(x in completion for x in ("HMAC-MD5", "RSASHA1", "ED25519"))
         assert "|" not in completion
         assert not any(x.startswith("-") for x in completion)
 
diff --git a/test/t/test_dpkg_deb.py b/test/t/test_dpkg_deb.py
index c1ad8191..9be85eb6 100644
--- a/test/t/test_dpkg_deb.py
+++ b/test/t/test_dpkg_deb.py
@@ -6,3 +6,7 @@ class TestDpkgDeb:
     @pytest.mark.complete("dpkg-deb --c", require_cmd=True)
     def test_1(self, completion):
         assert completion
+
+    @pytest.mark.complete("dpkg-deb --show b", cwd="dpkg")
+    def test_show(self, completion):
+        assert completion == "ash-completion-test-subject.deb"
diff --git a/test/t/test_dpkg_query.py b/test/t/test_dpkg_query.py
new file mode 100644
index 00000000..37c56211
--- /dev/null
+++ b/test/t/test_dpkg_query.py
@@ -0,0 +1,18 @@
+import os.path
+
+import pytest
+
+
+@pytest.mark.bashcomp(cmd="dpkg-query",)
+class TestDpkgQuery:
+    @pytest.mark.complete("dpkg-query --", require_cmd=True)
+    def test_options(self, completion):
+        assert completion
+
+    @pytest.mark.xfail(
+        not os.path.exists("/etc/debian_version"),
+        reason="Likely fails on systems not based on Debian",
+    )
+    @pytest.mark.complete("dpkg-query -W dpk", require_cmd=True)
+    def test_show(self, completion):
+        assert "dpkg" in completion
diff --git a/test/t/test_feh.py b/test/t/test_feh.py
index 51bd77b6..f2d5317b 100644
--- a/test/t/test_feh.py
+++ b/test/t/test_feh.py
@@ -16,11 +16,11 @@ class TestFeh:
 
     @pytest.mark.complete("feh -S pix")
     def test_3(self, completion):
-        assert completion == "pixels"
+        assert completion == "els"
 
     @pytest.mark.complete("feh --zoom ma")
     def test_4(self, completion):
-        assert completion == "max"
+        assert completion == "x"
 
     @pytest.mark.complete("feh -g 640")
     def test_5(self, completion):
diff --git a/test/t/test_find.py b/test/t/test_find.py
index a94e0e0d..9968ade7 100644
--- a/test/t/test_find.py
+++ b/test/t/test_find.py
@@ -14,10 +14,9 @@ class TestFind:
     def test_3(self, completion):
         assert completion
 
-    @pytest.mark.xfail  # TODO: whitespace split issue
     @pytest.mark.complete("find -wholename ", cwd="shared/default")
     def test_4(self, completion):
-        assert completion == ["bar", "bar bar.d/", "foo", "foo foo.d/"]
+        assert completion == ["bar", "bar bar.d/", "foo", "foo.d/"]
 
     @pytest.mark.complete("find -uid ")
     def test_5(self, completion):
@@ -26,3 +25,13 @@ class TestFind:
     @pytest.mark.complete("find -gid ")
     def test_6(self, completion):
         assert not [x for x in completion if not x.isdigit()]
+
+    @pytest.mark.complete("find -exec shared/bin/ar")
+    def test_exec(self, completion):
+        assert completion == "p"
+
+    # sh +: something that produces completions also when command is not
+    #       available, and the chosen completion is not one of find's
+    @pytest.mark.complete("find /some/where -exec sh +")
+    def test_exec_args(self, completion):
+        assert "+o" in completion
diff --git a/test/t/test_finger.py b/test/t/test_finger.py
index 92c983fa..d765fdd7 100644
--- a/test/t/test_finger.py
+++ b/test/t/test_finger.py
@@ -1,16 +1,12 @@
 import pytest
 
-from conftest import assert_bash_exec
+from conftest import assert_complete, partialize
 
 
 class TestFinger:
     @pytest.fixture(scope="class")
-    def users_at(self, bash):
-        return sorted(
-            assert_bash_exec(
-                bash, "compgen -A user -S @", want_output=True
-            ).split()
-        )
+    def users_at(self, bash, output_sort_uniq):
+        return output_sort_uniq("compgen -u -S @")
 
     @pytest.mark.complete("finger ")
     def test_1(self, bash, completion, users_at):
@@ -21,5 +17,17 @@ class TestFinger:
         if not any(x.startswith("r") for x in users_at):
             pytest.skip("No users starting with r")
         assert completion
-        assert all(x.startswith("r") for x in completion)
+        idx = 1 if len(completion) == 1 else 0
+        assert completion == sorted(
+            x[idx:] for x in users_at if x.startswith("r")
+        )
         assert not completion.endswith(" ")
+
+    def test_partial_hostname(self, bash, known_hosts):
+        first_char, partial_hosts = partialize(bash, known_hosts)
+        user = "test"
+        completion = assert_complete(bash, "finger %s@%s" % (user, first_char))
+        if len(completion) == 1:
+            assert completion == partial_hosts[0][1:]
+        else:
+            assert completion == ["%s@%s" % (user, x) for x in partial_hosts]
diff --git a/test/t/test_gcc.py b/test/t/test_gcc.py
index 87f25797..50906db5 100644
--- a/test/t/test_gcc.py
+++ b/test/t/test_gcc.py
@@ -24,7 +24,7 @@ class TestGcc:
 
     @pytest.mark.complete("gcc -fsanitize=add")
     def test_enum_value(self, completion, gcc_with_completion):
-        assert completion == "-fsanitize=address"
+        assert completion == "ress"
 
     @pytest.mark.complete("gcc -fsanitize=")
     def test_enum_value_with_eq(self, completion, gcc_with_completion):
@@ -48,15 +48,12 @@ class TestGcc:
 
     @pytest.mark.complete("gcc --param=lto-max-p")
     def test_param_with_eq(self, completion, gcc_with_completion):
-        # starting with GCC 10.1 param end with =
-        assert (
-            completion == "--param=lto-max-partition"
-            or completion == "--param=lto-max-partition="
-        )
+        # starting with GCC 10.1 param ends with =
+        assert completion in ("artition", "artition=")
 
     @pytest.mark.complete("gcc -march=amd")
     def test_march(self, completion, gcc_with_completion, gcc_x86):
-        assert completion == "-march=amdfam10"
+        assert completion == "fam10"
 
     @pytest.mark.complete("gcc -march=")
     def test_march_native(self, completion, gcc_with_completion):
diff --git a/test/t/test_ip.py b/test/t/test_ip.py
index 20752505..320647f4 100644
--- a/test/t/test_ip.py
+++ b/test/t/test_ip.py
@@ -9,3 +9,7 @@ class TestIp:
     @pytest.mark.complete("ip a ")
     def test_2(self, completion):
         assert completion
+
+    @pytest.mark.complete("ip route replace ")
+    def test_r_r(self, completion):
+        assert completion
diff --git a/test/t/test_ipcalc.py b/test/t/test_ipcalc.py
new file mode 100644
index 00000000..5611674c
--- /dev/null
+++ b/test/t/test_ipcalc.py
@@ -0,0 +1,23 @@
+import pytest
+
+
+class TestIpcalc:
+    @pytest.mark.complete("ipcalc -", require_cmd=True)
+    def test_options(self, completion):
+        assert any(x in completion for x in "--help -h".split())
+
+    @pytest.mark.complete("ipcalc --split -")
+    def test_split_3args_1(self, completion):
+        assert not completion
+
+    @pytest.mark.complete("ipcalc --split 1 -")
+    def test_split_3args_2(self, completion):
+        assert not completion
+
+    @pytest.mark.complete("ipcalc --split 1 2 -")
+    def test_split_3args_3(self, completion):
+        assert not completion
+
+    @pytest.mark.complete("ipcalc --split 1 2 3 -", require_cmd=True)
+    def test_split_3args_4(self, completion):
+        assert any(x in completion for x in "--help -h".split())
diff --git a/test/t/test_irb.py b/test/t/test_irb.py
index 03a83c66..801d3739 100644
--- a/test/t/test_irb.py
+++ b/test/t/test_irb.py
@@ -6,6 +6,6 @@ class TestIrb:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.complete("irb -", require_cmd=True)
+    @pytest.mark.complete("irb -", require_longopt=True)
     def test_options(self, completion):
         assert completion
diff --git a/test/t/test_iscsiadm.py b/test/t/test_iscsiadm.py
index 932ffeb5..885ca0ab 100644
--- a/test/t/test_iscsiadm.py
+++ b/test/t/test_iscsiadm.py
@@ -2,6 +2,6 @@ import pytest
 
 
 class TestIscsiadm:
-    @pytest.mark.complete("iscsiadm --mode")
+    @pytest.mark.complete("iscsiadm --mod")
     def test_1(self, completion):
-        assert completion
+        assert completion == "e" or "--mode" in completion
diff --git a/test/t/test_isort.py b/test/t/test_isort.py
index 9f7a6524..b142d1c4 100644
--- a/test/t/test_isort.py
+++ b/test/t/test_isort.py
@@ -6,6 +6,6 @@ class TestIsort:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.complete("isort -", require_cmd=True)
+    @pytest.mark.complete("isort -", require_cmd=True, require_longopt=True)
     def test_2(self, completion):
         assert completion
diff --git a/test/t/test_jsonschema.py b/test/t/test_jsonschema.py
index 9e3929e6..6027f5d6 100644
--- a/test/t/test_jsonschema.py
+++ b/test/t/test_jsonschema.py
@@ -6,6 +6,8 @@ class TestJsonschema:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.complete("jsonschema -", require_cmd=True)
+    @pytest.mark.complete(
+        "jsonschema -", require_cmd=True, require_longopt=True
+    )
     def test_2(self, completion):
         assert completion
diff --git a/test/t/test_kcov.py b/test/t/test_kcov.py
index 3c7d3dfa..3e377ebe 100644
--- a/test/t/test_kcov.py
+++ b/test/t/test_kcov.py
@@ -8,7 +8,7 @@ class TestKcov:
 
     @pytest.mark.complete("kcov --exclude-patter", require_cmd=True)
     def test_2(self, completion):
-        assert completion == "--exclude-pattern="
+        assert completion == "n="
         assert completion.endswith("=")
 
     @pytest.mark.complete("kcov -l 42,")
diff --git a/test/t/test_ldd.py b/test/t/test_ldd.py
index 70e295a5..7f7201bd 100644
--- a/test/t/test_ldd.py
+++ b/test/t/test_ldd.py
@@ -6,6 +6,8 @@ class TestLdd:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.complete("ldd -", require_cmd=True)
+    @pytest.mark.complete(
+        "ldd -", require_cmd=True, xfail="! ldd --help &>/dev/null"
+    )
     def test_options(self, completion):
         assert completion
diff --git a/test/t/test_less.py b/test/t/test_less.py
index 0b14e21e..70833c34 100644
--- a/test/t/test_less.py
+++ b/test/t/test_less.py
@@ -5,3 +5,7 @@ class TestLess:
     @pytest.mark.complete("less --", require_longopt=True)
     def test_1(self, completion):
         assert completion
+
+    @pytest.mark.complete("less --", require_longopt=True)
+    def test_no_dashdashdash(self, completion):
+        assert all(not x.startswith("---") for x in completion)
diff --git a/test/t/test_lftp.py b/test/t/test_lftp.py
index 765e51e1..f775a4c6 100644
--- a/test/t/test_lftp.py
+++ b/test/t/test_lftp.py
@@ -1,17 +1,15 @@
 import pytest
 
-from conftest import assert_bash_exec
-
 
 @pytest.mark.bashcomp(pre_cmds=("HOME=$PWD/lftp",))
 class TestLftp:
-    @pytest.mark.complete("lftp ")
-    def test_1(self, bash, completion):
-        hosts = assert_bash_exec(
-            bash, "compgen -A hostname", want_output=True
-        ).split()
+    @pytest.mark.complete("lftp ", require_cmd=True)
+    def test_1(self, bash, completion, output_sort_uniq):
+        hosts = output_sort_uniq("compgen -A hostname")
         assert all(x in completion for x in hosts)
-        assert "lftptest" in completion  # defined in lftp/.lftp/bookmarks
+        # defined in lftp/.lftp/bookmarks
+        assert all(x in completion for x in "lftptest spacetest".split())
+        assert "badbookmark" not in completion
 
     @pytest.mark.complete("lftp -", require_cmd=True)
     def test_2(self, completion):
diff --git a/test/t/test_lilo.py b/test/t/test_lilo.py
index 9783f506..2c698212 100644
--- a/test/t/test_lilo.py
+++ b/test/t/test_lilo.py
@@ -5,3 +5,12 @@ class TestLilo:
     @pytest.mark.complete("lilo -")
     def test_1(self, completion):
         assert completion
+
+    @pytest.mark.complete("lilo -C lilo/lilo.conf -D ")
+    def test_labels(self, completion):
+        # Note that 2.4.33 should not be here, it's commented out
+        assert completion == sorted("try tamu PCDOS WinXP oldDOS".split())
+
+    @pytest.mark.complete("lilo -C -D ")
+    def test_labels_incorrect_command(self, completion):
+        assert not completion
diff --git a/test/t/test_ls.py b/test/t/test_ls.py
index 7e2d1f35..8abcb59d 100644
--- a/test/t/test_ls.py
+++ b/test/t/test_ls.py
@@ -36,5 +36,5 @@ class TestLs:
             return
         part, full = part_full
         completion = assert_complete(bash, "ls ~%s" % part)
-        assert completion == "~%s" % full
+        assert completion == full[len(part) :]
         assert completion.endswith(" ")
diff --git a/test/t/test_lspci.py b/test/t/test_lspci.py
index ac18da3f..aba7b5a4 100644
--- a/test/t/test_lspci.py
+++ b/test/t/test_lspci.py
@@ -6,6 +6,8 @@ class TestLspci:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.complete("lspci -A ", require_cmd=True)
+    @pytest.mark.complete(
+        "lspci -A ", require_cmd=True, skipif="! lspci -A help &>/dev/null"
+    )
     def test_2(self, completion):
         assert completion
diff --git a/test/t/test_make.py b/test/t/test_make.py
index e6e043cd..19861b00 100644
--- a/test/t/test_make.py
+++ b/test/t/test_make.py
@@ -2,21 +2,19 @@ import os
 
 import pytest
 
-from conftest import in_container
-
 
 class TestMake:
     @pytest.mark.complete("make -f Ma", cwd="make")
     def test_1(self, completion):
-        assert completion == "Makefile"
+        assert completion == "kefile"
 
-    @pytest.mark.complete("make .", cwd="make")
+    @pytest.mark.complete("make .", cwd="make", require_cmd=True)
     def test_2(self, bash, completion):
         """Hidden targets."""
         assert completion == ".cache/ .test_passes".split()
         os.remove("%s/make/%s" % (bash.cwd, "extra_makefile"))
 
-    @pytest.mark.complete("make .cache/", cwd="make")
+    @pytest.mark.complete("make .cache/", cwd="make", require_cmd=True)
     def test_3(self, bash, completion):
         assert completion == "1 2".split()
         os.remove("%s/make/%s" % (bash.cwd, "extra_makefile"))
@@ -29,22 +27,17 @@ class TestMake:
     def test_5(self, completion):
         assert completion
 
-    @pytest.mark.complete("make ", cwd="make")
+    @pytest.mark.complete("make ", cwd="make", require_cmd=True)
     def test_6(self, bash, completion):
         assert completion == "all clean extra_makefile install sample".split()
         os.remove("%s/make/%s" % (bash.cwd, "extra_makefile"))
 
-    @pytest.mark.xfail(
-        in_container() and os.environ.get("DIST") == "centos6",
-        reason="Fails for some unknown reason on CentOS 6, "
-        "even though the behavior appears to be correct",
-    )
-    @pytest.mark.complete("make .cache/.", cwd="make")
+    @pytest.mark.complete("make .cache/.", cwd="make", require_cmd=True)
     def test_7(self, bash, completion):
         assert completion == ".1 .2".split()
         os.remove("%s/make/%s" % (bash.cwd, "extra_makefile"))
 
-    @pytest.mark.complete("make -C make ")
+    @pytest.mark.complete("make -C make ", require_cmd=True)
     def test_8(self, bash, completion):
         assert completion == "all clean extra_makefile install sample".split()
         os.remove("%s/make/%s" % (bash.cwd, "extra_makefile"))
diff --git a/test/t/test_man.py b/test/t/test_man.py
index ad36d96e..1ff9f84b 100644
--- a/test/t/test_man.py
+++ b/test/t/test_man.py
@@ -1,8 +1,6 @@
-import os
-
 import pytest
 
-from conftest import assert_bash_exec, in_container
+from conftest import assert_bash_exec
 
 
 @pytest.mark.bashcomp(
@@ -36,24 +34,16 @@ class TestMan:
         require_cmd=True,
     )
     def test_1(self, completion):
-        assert completion == "bash-completion-testcase"
+        assert completion == "e"
 
     @pytest.mark.complete("man man1/f", cwd="man", env=dict(MANPATH=manpath))
     def test_2(self, completion):
-        assert completion == "man1/foo.1"
+        assert completion == "oo.1"
 
     @pytest.mark.complete("man man/", cwd="man", env=dict(MANPATH=manpath))
     def test_3(self, completion):
-        assert completion == "man/quux.8"
-
-    @pytest.mark.xfail(
-        in_container() and os.environ.get("DIST") == "centos6",
-        reason="TODO: Fails in CentOS for some reason, unknown "
-        "how to trigger same behavior as tests show (is "
-        "different and correct when tried manually, but here "
-        "at least in CI completes things it should not with "
-        "this MANPATH setting)",
-    )
+        assert completion == "quux.8"
+
     @pytest.mark.complete(
         "man %s" % assumed_present,
         cwd="shared/empty_dir",
@@ -82,7 +72,7 @@ class TestMan:
         env=dict(MANPATH="%s:" % manpath),
     )
     def test_6(self, completion):
-        assert completion == "bash-completion-testcase"
+        assert completion == "e"
 
     @pytest.mark.complete(
         "man %s" % assumed_present,
@@ -100,7 +90,7 @@ class TestMan:
         env=dict(MANPATH=":%s" % manpath),
     )
     def test_8(self, completion):
-        assert completion == "bash-completion-testcase"
+        assert completion == "e"
 
     @pytest.mark.complete(
         "man %s" % assumed_present,
@@ -118,7 +108,7 @@ class TestMan:
         env=dict(MANPATH="%s:../tmp/man" % manpath),
     )
     def test_10(self, bash, colonpath, completion):
-        assert completion == "Bash::Completion"
+        assert completion == "ompletion"
 
     @pytest.mark.complete("man -", require_cmd=True)
     def test_11(self, completion):
diff --git a/test/t/test_mkdir.py b/test/t/test_mkdir.py
index 1b9cb9dc..afc3fd04 100644
--- a/test/t/test_mkdir.py
+++ b/test/t/test_mkdir.py
@@ -6,10 +6,9 @@ class TestMkdir:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.xfail  # TODO: whitespace split issue
     @pytest.mark.complete("mkdir ", cwd="shared/default")
     def test_2(self, completion):
-        assert completion == ["bar bar.d/", "foo", "foo.d/"]
+        assert completion == ["bar", "bar bar.d/", "foo", "foo.d/"]
 
     @pytest.mark.xfail  # TODO: why path in completion, basename in .output?
     @pytest.mark.complete("mkdir shared/default/foo.d/")
diff --git a/test/t/test_modprobe.py b/test/t/test_modprobe.py
index 38d290ae..9201119d 100644
--- a/test/t/test_modprobe.py
+++ b/test/t/test_modprobe.py
@@ -6,7 +6,7 @@ import pytest
 class TestModprobe:
     @pytest.mark.complete("modprobe --al")
     def test_1(self, completion):
-        assert completion == "--all"
+        assert completion == "l"
 
     # "in": intel*, ...
     @pytest.mark.complete(
diff --git a/test/t/test_mount.py b/test/t/test_mount.py
index fbd6dcae..8254fd40 100644
--- a/test/t/test_mount.py
+++ b/test/t/test_mount.py
@@ -12,7 +12,7 @@ class TestMount:
 
     @pytest.mark.complete("mount /dev/sda1 def", cwd="shared")
     def test_3(self, completion):
-        assert completion == "default/"
+        assert completion == "ault/"
         assert not completion.endswith(" ")
 
     @pytest.mark.complete(
diff --git a/test/t/test_mr.py b/test/t/test_mr.py
index 768e1b35..bfad643f 100644
--- a/test/t/test_mr.py
+++ b/test/t/test_mr.py
@@ -19,7 +19,7 @@ class TestMr:
         "mr -c shared/default/foo.d/", xfail="! man -h &>/dev/null"
     )
     def test_3(self, completion):
-        assert completion == "shared/default/foo.d/foo"
+        assert completion == "foo"
 
     @pytest.mark.complete(
         "mr bootstrap shared/default/",
@@ -29,18 +29,21 @@ class TestMr:
     def test_4(self, completion):
         assert completion == ["bar", "bar bar.d/", "foo", "foo.d/"]
 
-    @pytest.mark.xfail  # "clean" doesn't exist before mr 1.20141023
     @pytest.mark.complete(
-        "mr clean -", require_cmd=True, xfail="! man -h &>/dev/null"
+        "mr clean -",
+        require_cmd=True,
+        xfail="! man -h &>/dev/null",
+        # "clean" does not exist before mr 1.20141023
+        skipif="! mr help 2>&1 | command grep -qwF clean",
     )
     def test_5(self, completion):
-        assert completion == "-f"
+        assert completion == "f"
 
     @pytest.mark.complete(
         "mr commit -", require_cmd=True, xfail="! man -h &>/dev/null"
     )
     def test_6(self, completion):
-        assert completion == "-m"
+        assert completion == "m"
 
     @pytest.mark.complete(
         "mr status ", require_cmd=True, xfail="! man -h &>/dev/null"
diff --git a/test/t/test_mypy.py b/test/t/test_mypy.py
index 63fc916c..11628c1d 100644
--- a/test/t/test_mypy.py
+++ b/test/t/test_mypy.py
@@ -6,7 +6,7 @@ class TestMypy:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.complete("mypy --", require_cmd=True)
+    @pytest.mark.complete("mypy --", require_cmd=True, require_longopt=True)
     def test_2(self, completion):
         assert completion
 
diff --git a/test/t/test_nmap.py b/test/t/test_nmap.py
index a4d8a899..9aff8b29 100644
--- a/test/t/test_nmap.py
+++ b/test/t/test_nmap.py
@@ -1,7 +1,47 @@
 import pytest
 
+from conftest import assert_bash_exec
+
 
 class TestNmap:
-    @pytest.mark.complete("nmap --v")
-    def test_1(self, completion):
+    @pytest.fixture(scope="class")
+    def functions(self, request, bash):
+        assert_bash_exec(bash, "_mock_nmap() { cat nmap/nmap-h.txt; }")
+        assert_bash_exec(bash, "complete -F _nmap _mock_nmap")
+
+    @pytest.mark.complete("nmap --v", require_cmd=True)
+    def test_live_options(self, completion):
+        assert completion
+
+    @pytest.mark.complete("nmap ")
+    def test_hosts(self, completion):
         assert completion
+
+    @pytest.mark.complete("_mock_nmap -")
+    def test_mock_options(self, completion, functions):
+        assert completion == sorted(
+            "-iL -iR --exclude --excludefile -sL -sn -Pn -PS -PA -PU -PY -PE "
+            "-PP -PM -PO -n -R --dns-servers --system-dns --traceroute -sS "
+            "-sT -sA -sW -sM -sU -sN -sF -sX --scanflags -sI -sY -sZ -sO -b "
+            "-p --exclude-ports -F -r --top-ports --port-ratio -sV "
+            "--version-intensity --version-light --version-all "
+            "--version-trace -sC --script= --script-args= --script-args-file= "
+            "--script-trace --script-updatedb --script-help= -O "
+            "--osscan-limit --osscan-guess "
+            # TODO: -T known mishandled; should expand -T<0-5> to -T0 ... -T5
+            "-T --min-hostgroup --max-hostgroup --min-parallelism "
+            "--max-parallelism --min-rtt-timeout --max-rtt-timeout "
+            "--initial-rtt-timeout --max-retries --host-timeout --scan-delay "
+            "--max-scan-delay --min-rate --max-rate -f --mtu -D -S -e -g "
+            "--source-port --proxies --data --data-string --data-length "
+            "--ip-options --ttl --spoof-mac --badsum -oN -oX -oS -oG -oA -v "
+            "-d --reason --open --packet-trace --iflist --append-output "
+            "--resume --stylesheet --webxml --no-stylesheet -6 -A --datadir "
+            "--send-eth --send-ip --privileged --unprivileged -V -h"
+            "".strip().split()
+        )
+
+    @pytest.mark.complete("_mock_nmap --script-args-f")
+    def test_mock_nospace(self, completion, functions):
+        assert completion == "ile="
+        assert completion.endswith("=")  # no space appended
diff --git a/test/t/test_openssl.py b/test/t/test_openssl.py
index e3af3530..3eaf6d47 100644
--- a/test/t/test_openssl.py
+++ b/test/t/test_openssl.py
@@ -6,10 +6,11 @@ class TestOpenssl:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.complete("openssl pkey -cipher ")
+    @pytest.mark.complete("openssl pkey -cipher ", require_cmd=True)
     def test_2(self, completion):
         assert completion
 
-    @pytest.mark.complete("openssl dgst -s")
+    @pytest.mark.complete("openssl dgst -s", require_cmd=True)
     def test_3(self, completion):
         assert completion
+        assert any(x.startswith("-sha") for x in completion)
diff --git a/test/t/test_perl.py b/test/t/test_perl.py
index c8baa2f3..049c91ea 100644
--- a/test/t/test_perl.py
+++ b/test/t/test_perl.py
@@ -63,7 +63,7 @@ class TestPerl:
     @pytest.mark.complete("perl -xshared/default/b")
     def test_14(self, completion):
         """-x without space should complete dirs."""
-        assert completion == ["-xshared/default/bar bar.d/"]
+        assert completion == r"ar\ bar.d/"
 
     @pytest.mark.complete("perl -x shared/default/b")
     def test_15(self, completion):
diff --git a/test/t/test_pgrep.py b/test/t/test_pgrep.py
index 9c233311..9a998edb 100644
--- a/test/t/test_pgrep.py
+++ b/test/t/test_pgrep.py
@@ -11,3 +11,25 @@ class TestPgrep:
     @pytest.mark.complete("pgrep -", require_cmd=True)
     def test_2(self, completion):
         assert completion
+
+    @pytest.mark.complete(
+        "pgrep --nslist ",
+        require_cmd=True,
+        skipif=(
+            "! pgrep --help 2>&1 | command grep -qF 'Available namespaces'"
+        ),
+    )
+    def test_nslist(self, completion):
+        assert completion
+        assert not any("," in x for x in completion)
+
+    @pytest.mark.complete(
+        "pgrep --nslist foo,",
+        require_cmd=True,
+        skipif=(
+            "! pgrep --help 2>&1 | command grep -qF 'Available namespaces'"
+        ),
+    )
+    def test_nslist_after_comma(self, completion):
+        assert completion
+        assert not any("," in x for x in completion)
diff --git a/test/t/test_postfix.py b/test/t/test_postfix.py
index 67a898d1..10020b0b 100644
--- a/test/t/test_postfix.py
+++ b/test/t/test_postfix.py
@@ -1,3 +1,5 @@
+import getpass
+
 import pytest
 
 
@@ -6,7 +8,15 @@ class TestPostfix:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.xfail  # see TODO in completion
-    @pytest.mark.complete("postfix -", require_cmd=True)
-    def test_2(self, completion):
+    @pytest.mark.xfail(
+        getpass.getuser() != "root",
+        reason="Likely outputs usage only for root",
+    )
+    @pytest.mark.complete(
+        "postfix -",
+        require_cmd=True,
+        xfail="! type unbuffer &>/dev/null",
+        sleep_after_tab=2,  # postfix is slow to output usage
+    )
+    def test_options(self, completion):
         assert completion
diff --git a/test/t/test_printenv.py b/test/t/test_printenv.py
new file mode 100644
index 00000000..540c4f64
--- /dev/null
+++ b/test/t/test_printenv.py
@@ -0,0 +1,19 @@
+import pytest
+
+
+class TestPrintenv:
+    @pytest.mark.complete("printenv ")
+    def test_empty(self, completion):
+        assert completion
+
+    @pytest.mark.complete("printenv PAT")
+    def test_path(self, completion):
+        assert completion == "H" or "PATH" in completion
+
+    @pytest.mark.complete(
+        "printenv -",
+        require_cmd=True,
+        xfail="! printenv --help 2>&1 | command grep -qF -- ' -'",
+    )
+    def test_options(self, completion):
+        assert completion
diff --git a/test/t/test_protoc.py b/test/t/test_protoc.py
index e890c56a..744b99f4 100644
--- a/test/t/test_protoc.py
+++ b/test/t/test_protoc.py
@@ -9,3 +9,12 @@ class TestProtoc:
     @pytest.mark.complete("protoc -", require_cmd=True)
     def test_2(self, completion):
         assert completion
+        assert any(
+            x.endswith("_out") or x.endswith("_out=") for x in completion
+        )
+
+    @pytest.mark.complete(
+        "protoc --non_existent_plugin_out ", cwd="shared/default"
+    )
+    def test_all_out(self, completion):
+        assert completion == ["bar bar.d/", "foo.d/"]
diff --git a/test/t/test_pydocstyle.py b/test/t/test_pydocstyle.py
index caa87902..1f443208 100644
--- a/test/t/test_pydocstyle.py
+++ b/test/t/test_pydocstyle.py
@@ -6,6 +6,8 @@ class TestPydocstyle:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.complete("pydocstyle -", require_cmd=True)
+    @pytest.mark.complete(
+        "pydocstyle -", require_cmd=True, require_longopt=True
+    )
     def test_2(self, completion):
         assert completion
diff --git a/test/t/test_pylint.py b/test/t/test_pylint.py
index 4b799532..43a4c43f 100644
--- a/test/t/test_pylint.py
+++ b/test/t/test_pylint.py
@@ -2,7 +2,7 @@ import pytest
 
 
 class TestPylint:
-    @pytest.mark.complete("pylint --v", require_cmd=True)
+    @pytest.mark.complete("pylint --v", require_cmd=True, require_longopt=True)
     def test_1(self, completion):
         assert completion
 
diff --git a/test/t/test_pytest.py b/test/t/test_pytest.py
index 69d01820..e70c7a5d 100644
--- a/test/t/test_pytest.py
+++ b/test/t/test_pytest.py
@@ -1,3 +1,5 @@
+import inspect
+
 import pytest
 
 
@@ -9,3 +11,40 @@ class TestPytest:
     @pytest.mark.complete("pytest -")
     def test_2(self, completion):
         assert completion
+
+    @pytest.mark.complete("pytest ../t/test_pytest.py:")
+    def test_classes_and_functions(self, completion):
+        assert completion == ":TestPytest :test_function_canary".split()
+
+    @pytest.mark.complete("pytest ../t/test_pytest.py::TestPytest::")
+    def test_class_methods(self, completion):
+        methods = [
+            x[0]
+            for x in inspect.getmembers(self, predicate=inspect.ismethod)
+            if x[0].startswith("test_")
+        ]
+        assert completion == methods
+
+    @pytest.mark.complete("pytest pytest/test_async.py:")
+    def test_classes_and_async_functions(self, completion):
+        assert completion == ":Testing :test_positive".split()
+
+    @pytest.mark.complete("pytest pytest/test_async.py::Testing::")
+    def test_async_class_methods(self, completion):
+        assert completion == "test_positive"
+
+    def non_test_cananary_method(self):
+        pass
+
+
+def test_function_canary():
+    pass
+
+
+def non_test_canary():
+    pass
+
+
+class NonTestCanaryClass:
+    def test_is_this_function_not(self):
+        pass
diff --git a/test/t/test_python.py b/test/t/test_python.py
index 57802721..5308dcb1 100644
--- a/test/t/test_python.py
+++ b/test/t/test_python.py
@@ -33,3 +33,7 @@ class TestPython:
     @pytest.mark.complete("python -m sy", require_cmd=True)
     def test_8(self, completion):
         assert completion
+
+    @pytest.mark.complete("python -m json.", require_cmd=True)
+    def test_9(self, completion):
+        assert "json.tool" in completion
diff --git a/test/t/test_python3.py b/test/t/test_python3.py
index b968a34e..a4f6d966 100644
--- a/test/t/test_python3.py
+++ b/test/t/test_python3.py
@@ -33,3 +33,7 @@ class TestPython3:
     @pytest.mark.complete("python3 -m sy", require_cmd=True)
     def test_8(self, completion):
         assert completion
+
+    @pytest.mark.complete("python3 -m json.", require_cmd=True)
+    def test_9(self, completion):
+        assert "json.tool" in completion
diff --git a/test/t/test_ri.py b/test/t/test_ri.py
index 9430b667..420b6cbb 100644
--- a/test/t/test_ri.py
+++ b/test/t/test_ri.py
@@ -13,4 +13,4 @@ class TestRi:
 
     @pytest.mark.complete("ri BashCompletio", require_cmd=True)
     def test_3(self, completion):
-        assert completion == "BashCompletion"
+        assert completion == "n"
diff --git a/test/t/test_sbcl.py b/test/t/test_sbcl.py
index cce4cba3..f05741a7 100644
--- a/test/t/test_sbcl.py
+++ b/test/t/test_sbcl.py
@@ -2,7 +2,6 @@ import pytest
 
 
 class TestSbcl:
-    @pytest.mark.xfail  # TODO: whitespace split issue
     @pytest.mark.complete("sbcl shared/default/")
     def test_1(self, completion):
-        assert completion == ["bar", "bar bar.d/", "foo", "foo foo.d/"]
+        assert completion == ["bar", "bar bar.d/", "foo", "foo.d/"]
diff --git a/test/t/test_sbcl_mt.py b/test/t/test_sbcl_mt.py
index d8049f3f..c3965393 100644
--- a/test/t/test_sbcl_mt.py
+++ b/test/t/test_sbcl_mt.py
@@ -3,7 +3,6 @@ import pytest
 
 @pytest.mark.bashcomp(cmd="sbcl-mt")
 class TestSbclMt:
-    @pytest.mark.xfail  # TODO: whitespace split issue
     @pytest.mark.complete("sbcl-mt shared/default/")
     def test_1(self, completion):
-        assert completion == ["bar", "bar bar.d/", "foo", "foo foo.d/"]
+        assert completion == ["bar", "bar bar.d/", "foo", "foo.d/"]
diff --git a/test/t/test_scp.py b/test/t/test_scp.py
new file mode 100644
index 00000000..66b8da22
--- /dev/null
+++ b/test/t/test_scp.py
@@ -0,0 +1,79 @@
+from itertools import chain
+
+import pytest
+
+from conftest import assert_bash_exec
+
+LIVE_HOST = "bash_completion"
+
+
+class TestScp:
+    @pytest.mark.complete("scp -F config ", cwd="scp")
+    def test_basic(self, hosts, completion):
+        expected = sorted(
+            chain(
+                (
+                    "%s:" % x
+                    for x in chain(
+                        hosts,
+                        # From fixtures/scp/config
+                        "gee hut".split(),
+                        # From fixtures/scp/known_hosts
+                        "blah doo ike".split(),
+                    )
+                ),
+                # Local filenames
+                ["config", "known_hosts", r"spaced\ \ conf"],
+            )
+        )
+        assert completion == expected
+
+    @pytest.mark.complete("scp -F 'spaced  conf' ", cwd="scp")
+    def test_basic_spaced_conf(self, hosts, completion):
+        expected = sorted(
+            chain(
+                (
+                    "%s:" % x
+                    for x in chain(
+                        hosts,
+                        # From "fixtures/scp/spaced  conf"
+                        "gee jar".split(),
+                        # From fixtures/scp/known_hosts
+                        "blah doo ike".split(),
+                    )
+                ),
+                # Local filenames
+                ["config", "known_hosts", r"spaced\ \ conf"],
+            )
+        )
+        assert completion == expected
+
+    @pytest.mark.complete("scp -F")
+    def test_capital_f_without_space(self, completion):
+        assert completion
+        assert not any(
+            "option requires an argument -- F" in x for x in completion
+        )
+
+    @pytest.fixture(scope="class")
+    def live_pwd(self, bash):
+        try:
+            return assert_bash_exec(
+                bash,
+                "ssh -o 'Batchmode yes' -o 'ConnectTimeout 1' "
+                "%s pwd 2>/dev/null" % LIVE_HOST,
+                want_output=True,
+            ).strip()
+        except AssertionError:
+            pytest.skip("Live host %s not available" % LIVE_HOST)
+
+    @pytest.mark.complete("scp %s:" % LIVE_HOST, sleep_after_tab=2)
+    def test_live(self, live_pwd, completion):
+        """
+        To support this test, configure a HostName entry for LIVE_HOST
+        in ssh's configs, e.g. ~/.ssh/config or /etc/ssh/ssh_config.
+
+        Connection to it must open sufficiently quickly for the
+        ConnectTimeout and sleep_after_tab settings.
+        """
+        assert completion == "%s:%s/" % (LIVE_HOST, live_pwd)
diff --git a/test/t/test_screen.py b/test/t/test_screen.py
index d9254bda..3e98837f 100644
--- a/test/t/test_screen.py
+++ b/test/t/test_screen.py
@@ -19,17 +19,17 @@ class TestScreen:
     def test_4(self, completion):
         assert completion
 
-    @pytest.mark.complete("screen -T foo cat")
+    @pytest.mark.complete("screen -T foo ca")
     def test_5(self, completion):
-        assert completion
+        assert completion == "t" or "cat" in completion
 
     @pytest.mark.complete("screen //")
     def test_telnet(self, completion):
-        assert completion == "//telnet"
+        assert completion == "telnet"
 
     @pytest.mark.complete("screen cat //")
     def test_not_telnet(self, completion):
-        assert completion != "//telnet"
+        assert completion != "telnet"
 
     @pytest.mark.complete("screen //telnet ", env=dict(HOME="$PWD/shared"))
     def test_telnet_first_arg(self, completion):
diff --git a/test/t/test_secret_tool.py b/test/t/test_secret_tool.py
new file mode 100644
index 00000000..cbfc0cbc
--- /dev/null
+++ b/test/t/test_secret_tool.py
@@ -0,0 +1,12 @@
+import pytest
+
+
+@pytest.mark.bashcomp(cmd="secret-tool",)
+class TestSecretTool:
+    @pytest.mark.complete("secret-tool ", require_cmd=True)
+    def test_modes(self, completion):
+        assert "store" in completion
+
+    @pytest.mark.complete("secret-tool search ")
+    def test_no_complete(self, completion):
+        assert not completion
diff --git a/test/t/test_sftp.py b/test/t/test_sftp.py
index 0c039399..a421a449 100644
--- a/test/t/test_sftp.py
+++ b/test/t/test_sftp.py
@@ -1,11 +1,46 @@
+from itertools import chain
+
 import pytest
 
 
 class TestSftp:
     @pytest.mark.complete("sftp -Fsp", cwd="sftp")
     def test_1(self, completion):
-        assert completion == "-Fspaced  conf"
+        assert completion == r"aced\ \ conf"
 
     @pytest.mark.complete("sftp -", require_cmd=True)
     def test_2(self, completion):
         assert completion
+
+    @pytest.mark.complete("sftp -F config ", cwd="sftp")
+    def test_hosts(self, hosts, completion):
+        expected = sorted(
+            chain(
+                hosts,
+                # From fixtures/sftp/config
+                "gee hut".split(),
+                # From fixtures/sftp/known_hosts
+                "10.10.10.10 doo ike".split(),
+            )
+        )
+        assert completion == expected
+
+    @pytest.mark.complete(r"sftp -F spaced\ \ conf ", cwd="sftp")
+    def test_hosts_spaced_conf(self, hosts, completion):
+        expected = sorted(
+            chain(
+                hosts,
+                # From "fixtures/sftp/spaced  conf"
+                "gee jar".split(),
+                # From fixtures/sftp/known_hosts
+                "10.10.10.10 doo ike".split(),
+            )
+        )
+        assert completion == expected
+
+    @pytest.mark.complete("sftp -F")
+    def test_capital_f_without_space(self, completion):
+        assert completion
+        assert not any(
+            "option requires an argument -- F" in x for x in completion
+        )
diff --git a/test/t/test_slapt_get.py b/test/t/test_slapt_get.py
index 626dde9e..92449711 100644
--- a/test/t/test_slapt_get.py
+++ b/test/t/test_slapt_get.py
@@ -1,8 +1,26 @@
+import os.path
+from tempfile import mkstemp
+
 import pytest
 
+from conftest import assert_complete, is_bash_type
+
 
 @pytest.mark.bashcomp(cmd="slapt-get")
 class TestSlaptGet:
+    @pytest.fixture(scope="class")
+    def slapt_getrc(self, request, bash):
+        fd, fname = mkstemp(prefix="slapt-getrc.", text=True)
+        request.addfinalizer(lambda: os.remove(fname))
+        with os.fdopen(fd, "w") as f:
+            print(
+                "WORKINGDIR=%s/"
+                % os.path.join(bash.cwd, *"slackware var slapt-get".split()),
+                file=f,
+            )
+            print("SOURCE=file:///home/", file=f)
+        return fname
+
     @pytest.mark.complete("slapt-get -", require_cmd=True)
     def test_1(self, completion):
         assert completion
@@ -14,3 +32,13 @@ class TestSlaptGet:
     @pytest.mark.complete("slapt-get -c non-existent-file --install ")
     def test_3(self, completion):
         assert not completion
+
+    def test_install(self, bash, slapt_getrc):
+        if not is_bash_type(bash, "slapt-get"):
+            pytest.skip("slapt-get not found")
+        completion = assert_complete(
+            bash, "slapt-get -c %s --install " % slapt_getrc
+        )
+        assert completion == sorted(
+            "abc-4-i686-1 ran-1.2-noarch-1 qwe-2.1-i486-1".split()
+        )
diff --git a/test/t/test_slapt_src.py b/test/t/test_slapt_src.py
index dd443b04..b55b722d 100644
--- a/test/t/test_slapt_src.py
+++ b/test/t/test_slapt_src.py
@@ -1,16 +1,43 @@
+import os
+from tempfile import mkstemp
+
 import pytest
 
+from conftest import assert_complete, is_bash_type
+
 
 @pytest.mark.bashcomp(cmd="slapt-src")
 class TestSlaptSrc:
+    @pytest.fixture(scope="class")
+    def slapt_srcrc(self, request, bash):
+        fd, fname = mkstemp(prefix="slapt-srcrc.", text=True)
+        request.addfinalizer(lambda: os.remove(fname))
+        with os.fdopen(fd, "w") as f:
+            print(
+                "BUILDDIR=%s/"
+                % os.path.join(
+                    bash.cwd, *"slackware usr src slapt-src".split()
+                ),
+                file=f,
+            )
+        return fname
+
     @pytest.mark.complete("slapt-src -", require_cmd=True)
     def test_1(self, completion):
         assert completion
 
     @pytest.mark.complete("slapt-src --bu", require_cmd=True)
     def test_2(self, completion):
-        assert completion == "--build"
+        assert completion == "ild" or "--build" in completion
 
     @pytest.mark.complete("slapt-src --ins", require_cmd=True)
     def test_3(self, completion):
-        assert completion == "--install"
+        assert completion == "tall" or "--install" in completion
+
+    def test_install(self, bash, slapt_srcrc):
+        if not is_bash_type(bash, "slapt-src"):
+            pytest.skip("slapt-src not found")
+        completion = assert_complete(
+            bash, "slapt-src --config %s --install " % slapt_srcrc
+        )
+        assert completion == "abc:4 qwe:2.1".split()
diff --git a/test/t/test_ssh.py b/test/t/test_ssh.py
index 204b7c7c..8e958195 100644
--- a/test/t/test_ssh.py
+++ b/test/t/test_ssh.py
@@ -1,10 +1,12 @@
 import pytest
 
+from conftest import assert_complete, partialize
+
 
 class TestSsh:
     @pytest.mark.complete("ssh -Fsp", cwd="ssh")
     def test_1(self, completion):
-        assert completion == "-Fspaced  conf"
+        assert completion == r"aced\ \ conf"
 
     @pytest.mark.complete("ssh -F config ls", cwd="ssh")
     def test_2(self, completion):
@@ -32,3 +34,27 @@ class TestSsh:
     @pytest.mark.complete("ssh -", require_cmd=True)
     def test_6(self, completion):
         assert completion
+
+    @pytest.mark.complete("ssh -F")
+    def test_capital_f_without_space(self, completion):
+        assert completion
+        assert not any(
+            "option requires an argument -- F" in x for x in completion
+        )
+
+    @pytest.mark.complete("ssh -F nonexistent ")
+    def test_capital_f_nonexistent(self, completion):
+        assert completion
+
+    def test_partial_hostname(self, bash, known_hosts):
+        first_char, partial_hosts = partialize(bash, known_hosts)
+        completion = assert_complete(bash, "ssh %s" % first_char)
+        if len(completion) == 1:
+            assert completion == partial_hosts[0][1:]
+        else:
+            assert completion == sorted(x for x in partial_hosts)
+
+    @pytest.mark.parametrize("protocol", "4 6 9".split())
+    def test_protocol_option_bundling(self, bash, protocol):
+        completion = assert_complete(bash, "ssh -%sF ssh/" % protocol)
+        assert "config" in completion
diff --git a/test/t/test_ssh_keygen.py b/test/t/test_ssh_keygen.py
index 2d53f5f8..b773ab4f 100644
--- a/test/t/test_ssh_keygen.py
+++ b/test/t/test_ssh_keygen.py
@@ -6,3 +6,54 @@ class TestSshKeygen:
     @pytest.mark.complete("ssh-keygen -", require_cmd=True)
     def test_1(self, completion):
         assert completion
+
+    @pytest.mark.complete("ssh-keygen -s foo_key ssh-copy-id/.ssh/")
+    def test_filedir_pub_at_end_of_s(self, completion):
+        assert completion
+        assert all(x.endswith(".pub") for x in completion)
+
+    @pytest.mark.complete("ssh-keygen -s foo_key -n foo,")
+    def test_usernames_for_n(self, completion):
+        assert completion
+        assert not any("," in x for x in completion)
+        # TODO check that these are usernames
+
+    @pytest.mark.complete("ssh-keygen -s foo_key -h -n foo,")
+    def test_host_for_h_n(self, completion):
+        assert completion
+        assert not any("," in x for x in completion)
+        # TODO check that these are hostnames
+
+    @pytest.mark.complete("ssh-keygen -Y foo -n ")
+    def test_n_with_Y(self, completion):
+        assert not completion
+
+    @pytest.mark.complete("ssh-keygen -r ")
+    def test_r_without_Y(self, completion):
+        assert not completion
+
+    @pytest.mark.complete("ssh-keygen -Y foo -r ")
+    def test_r_with_Y(self, completion):
+        assert "ssh/" in completion
+
+    @pytest.mark.complete("ssh-keygen -t ecdsa -b ")
+    def test_ecdsa_b(self, completion):
+        assert completion
+
+    @pytest.mark.complete("ssh-keygen -t ecdsa-sk -b ")
+    def test_ecdsa_sk_b(self, completion):
+        assert not completion
+
+    @pytest.mark.complete("ssh-keygen -O ")
+    def test_O(self, completion):
+        assert completion
+        assert any(x.endswith("=") for x in completion)
+
+    @pytest.mark.complete("ssh-keygen -O force-command=bas")
+    def test_O_force_command(self, completion):
+        assert completion
+        assert not completion.startswith("force-command=")
+
+    @pytest.mark.complete("ssh-keygen -O unknown=")
+    def test_O_unknown(self, completion):
+        assert not completion
diff --git a/test/t/test_sudo.py b/test/t/test_sudo.py
index ced6662e..a3494664 100644
--- a/test/t/test_sudo.py
+++ b/test/t/test_sudo.py
@@ -10,27 +10,27 @@ class TestSudo:
 
     @pytest.mark.complete("sudo cd fo", cwd="shared/default")
     def test_2(self, completion):
-        assert completion == "foo.d/"
+        assert completion == "o.d/"
         assert not completion.endswith(" ")
 
     @pytest.mark.complete("sudo sh share")
     def test_3(self, completion):
-        assert completion == "shared/"
+        assert completion == "d/"
         assert not completion.endswith(" ")
 
     @pytest.mark.complete("sudo mount /dev/sda1 def", cwd="shared")
     def test_4(self, completion):
-        assert completion == "default/"
+        assert completion == "ault/"
         assert not completion.endswith(" ")
 
     @pytest.mark.complete("sudo -e -u root bar foo", cwd="shared/default")
     def test_5(self, completion):
-        assert completion == ["foo", "foo.d/"]
+        assert completion == "foo foo.d/".split()
 
     def test_6(self, bash, part_full_user):
         part, full = part_full_user
         completion = assert_complete(bash, "sudo chown %s" % part)
-        assert completion == full
+        assert completion == full[len(part) :]
         assert completion.endswith(" ")
 
     def test_7(self, bash, part_full_user, part_full_group):
@@ -39,32 +39,32 @@ class TestSudo:
         completion = assert_complete(
             bash, "sudo chown %s:%s" % (user, partgroup)
         )
-        assert completion == "%s:%s" % (user, fullgroup)
+        assert completion == fullgroup[len(partgroup) :]
         assert completion.endswith(" ")
 
     def test_8(self, bash, part_full_group):
         part, full = part_full_group
         completion = assert_complete(bash, "sudo chown dot.user:%s" % part)
-        assert completion == "dot.user:%s" % full
+        assert completion == full[len(part) :]
         assert completion.endswith(" ")
 
-    @pytest.mark.xfail  # TODO check escaping, whitespace
-    def test_9(self, bash, part_full_group):
-        """Test preserving special chars in $prefix$partgroup<TAB>."""
-        part, full = part_full_group
-        for prefix in (
+    @pytest.mark.parametrize(
+        "prefix",
+        [
             r"funky\ user:",
             "funky.user:",
             r"funky\.user:",
             r"fu\ nky.user:",
             r"f\ o\ o\.\bar:",
             r"foo\_b\ a\.r\ :",
-        ):
-            completion = assert_complete(
-                bash, "sudo chown %s%s" % (prefix, part)
-            )
-            assert completion == "%s%s" % (prefix, full)
-            assert completion.endswith(" ")
+        ],
+    )
+    def test_9(self, bash, part_full_group, prefix):
+        """Test preserving special chars in $prefix$partgroup<TAB>."""
+        part, full = part_full_group
+        completion = assert_complete(bash, "sudo chown %s%s" % (prefix, part))
+        assert completion == full[len(part) :]
+        assert completion.endswith(" ")
 
     def test_10(self, bash, part_full_user, part_full_group):
         """Test giving up on degenerate cases instead of spewing junk."""
diff --git a/test/t/test_tar.py b/test/t/test_tar.py
index 309bcc76..4518d0bd 100644
--- a/test/t/test_tar.py
+++ b/test/t/test_tar.py
@@ -77,28 +77,22 @@ class TestTar:
 
     @pytest.mark.complete("tar --add-fil")
     def test_15(self, completion, gnu_tar):
-        assert completion == "--add-file="
+        assert completion == "e="
         assert not completion.endswith(" ")
 
     @pytest.mark.complete("tar -cf /dev/null --posi")
     def test_16(self, completion, gnu_tar):
-        assert completion == "--posix"
+        assert completion == "x"
         assert completion.endswith(" ")
 
     @pytest.mark.complete("tar --owner=")
-    def test_17(self, bash, completion, gnu_tar):
-        users = sorted(
-            assert_bash_exec(bash, "compgen -A user", want_output=True).split()
-        )
+    def test_17(self, bash, completion, gnu_tar, output_sort_uniq):
+        users = output_sort_uniq("compgen -u")
         assert completion == users
 
     @pytest.mark.complete("tar --group=")
-    def test_18(self, bash, completion, gnu_tar):
-        groups = sorted(
-            assert_bash_exec(
-                bash, "compgen -A group", want_output=True
-            ).split()
-        )
+    def test_18(self, bash, completion, gnu_tar, output_sort_uniq):
+        groups = output_sort_uniq("compgen -g")
         assert completion == groups
 
     # Use -b for this as -b is still not handled by tar's completion
@@ -121,6 +115,6 @@ class TestTar:
     @pytest.mark.complete(r"tar tf escape.tar a/b\'", cwd="tar")
     def test_22(self, bash, completion):
         """Test listing escaped chars in old option."""
-        assert completion == "a/b'c/"
+        assert completion == "c/"
 
     # TODO: "tar tf escape.tar a/b"
diff --git a/test/t/test_totem.py b/test/t/test_totem.py
new file mode 100644
index 00000000..f6fb26fe
--- /dev/null
+++ b/test/t/test_totem.py
@@ -0,0 +1,7 @@
+import pytest
+
+
+class TestTotem:
+    @pytest.mark.complete("totem ")
+    def test_basic(self, completion):
+        assert completion
diff --git a/test/t/test_tshark.py b/test/t/test_tshark.py
index 8ed881ee..f49533e0 100644
--- a/test/t/test_tshark.py
+++ b/test/t/test_tshark.py
@@ -13,9 +13,8 @@ class TestTshark:
 
     @pytest.mark.complete("tshark -O foo,htt", require_cmd=True)
     def test_3(self, completion):
-        # When there's only one completion, it's be the one with "foo," prefix;
-        # when multiple (e.g. http and http2), it's the completion alone.
-        assert completion == "foo,http" or "http" in completion
+        # p: one completion only; http: e.g. http and http2
+        assert completion == "p" or "http" in completion
 
     @pytest.mark.complete("tshark -o tcp", require_cmd=True)
     def test_4(self, completion):
@@ -29,3 +28,7 @@ class TestTshark:
     def test_6(self, completion):
         """Test there are no URLs in completions."""
         assert not any("://" in x for x in completion)
+
+    @pytest.mark.complete("tshark -r ")
+    def test_input_files(self, completion):
+        assert completion
diff --git a/test/t/test_tsig_keygen.py b/test/t/test_tsig_keygen.py
new file mode 100644
index 00000000..8c8a64ac
--- /dev/null
+++ b/test/t/test_tsig_keygen.py
@@ -0,0 +1,12 @@
+import pytest
+
+
+@pytest.mark.bashcomp(cmd="tsig-keygen")
+class TestTsigKeygen:
+    @pytest.mark.complete("tsig-keygen ")
+    def test_basic(self, completion):
+        assert not completion
+
+    @pytest.mark.complete("tsig-keygen -", require_cmd=True)
+    def test_options(self, completion):
+        assert completion
diff --git a/test/t/test_umount.py b/test/t/test_umount.py
index dd4ae0b5..2baf0dac 100644
--- a/test/t/test_umount.py
+++ b/test/t/test_umount.py
@@ -1,7 +1,85 @@
 import pytest
 
+from conftest import assert_bash_exec
+
 
 class TestUmount:
+    @pytest.fixture(scope="class")
+    def dummy_mnt(self, request, bash):
+        """
+        umount completion from fstab can't be tested directly because it
+        (correctly) uses absolute paths. So we create a custom completion which
+        reads from a file in our text fixture instead.
+        """
+        assert_bash_exec(bash, "unset COMPREPLY cur; unset -f _mnt_completion")
+        assert_bash_exec(
+            bash,
+            "_mnt_completion() { "
+            "local cur=$(_get_cword); "
+            "_linux_fstab $(_get_pword) < mount/test-fstab; "
+            "} && complete -F _mnt_completion _mnt",
+        )
+        request.addfinalizer(
+            lambda: assert_bash_exec(
+                bash, "complete -r _mnt; unset -f _mnt_completion"
+            )
+        )
+
     @pytest.mark.complete("umount ")
     def test_1(self, completion):
         assert completion
+
+    @pytest.mark.complete("_mnt /mnt/nice-test-p")
+    def test_mnt_basic(self, completion, dummy_mnt):
+        assert completion == "ath"
+
+    # Note in tests below that return only one result, that the result
+    # is shell unescaped due to how assert_complete handles the
+    # "one result on same line case".
+
+    @pytest.mark.complete(r"_mnt /mnt/nice\ test-p")
+    def test_mnt_space(self, completion, dummy_mnt):
+        assert completion == r"ath"
+
+    @pytest.mark.complete(r"_mnt /mnt/nice\$test-p")
+    def test_mnt_dollar(self, completion, dummy_mnt):
+        assert completion == "ath"
+
+    @pytest.mark.complete(r"_mnt /mnt/nice\ test\\p")
+    def test_mnt_backslash(self, completion, dummy_mnt):
+        assert completion == "ath"
+
+    @pytest.mark.complete(r"_mnt /mnt/nice\ ")
+    def test_mnt_after_space(self, completion, dummy_mnt):
+        assert completion == sorted(
+            (r"/mnt/nice\ test\\path", r"/mnt/nice\ test-path")
+        )
+
+    @pytest.mark.complete(r"_mnt /mnt/nice\$")
+    def test_mnt_at_dollar(self, completion, dummy_mnt):
+        assert completion == "test-path"
+
+    @pytest.mark.complete(r"_mnt /mnt/nice\'")
+    def test_mnt_at_quote(self, completion, dummy_mnt):
+        assert completion == "test-path"
+
+    @pytest.mark.complete("_mnt /mnt/other")
+    def test_mnt_other(self, completion, dummy_mnt):
+        assert completion == r"\'test\ path"
+
+    @pytest.mark.complete("_mnt -L Ubu")
+    def test_mnt_label_space(self, completion, dummy_mnt):
+        assert completion == r"ntu\ Karmic"
+
+    @pytest.mark.complete("_mnt -L Deb")
+    def test_mnt_label_quote(self, completion, dummy_mnt):
+        assert completion == r"ian-it\'s\ awesome"
+
+    def test_linux_fstab_unescape(self, bash):
+        assert_bash_exec(bash, r"var=one\'two\\040three\\")
+        assert_bash_exec(bash, "__linux_fstab_unescape var")
+        output = assert_bash_exec(
+            bash, r'printf "%s\n" "$var"', want_output=True
+        )
+        assert output.strip() == "one'two three\\"
+        assert_bash_exec(bash, "unset var")
diff --git a/test/t/test_upgradepkg.py b/test/t/test_upgradepkg.py
index 4c72a158..87fe8e4c 100644
--- a/test/t/test_upgradepkg.py
+++ b/test/t/test_upgradepkg.py
@@ -32,3 +32,20 @@ class TestUpgradepkg:
             ]
         )
         assert completion == expected
+
+    @pytest.mark.complete("upgradepkg foo%", cwd="slackware/home")
+    def test_after_percent(self, completion):
+        expected = sorted(
+            [
+                "%s/" % x
+                for x in os.listdir("slackware/home")
+                if os.path.isdir("./slackware/home/%s" % x)
+            ]
+            + [
+                x
+                for x in os.listdir("slackware/home")
+                if os.path.isfile("./slackware/home/%s" % x)
+                and fnmatch.fnmatch(x, "*.t[bglx]z")
+            ]
+        )
+        assert completion == ["foo%%%s" % x for x in expected]
diff --git a/test/t/test_userdel.py b/test/t/test_userdel.py
index 718c6629..3405e127 100644
--- a/test/t/test_userdel.py
+++ b/test/t/test_userdel.py
@@ -6,6 +6,6 @@ class TestUserdel:
     def test_1(self, completion):
         assert completion
 
-    @pytest.mark.complete("userdel root")
+    @pytest.mark.complete("userdel roo")
     def test_2(self, completion):
-        assert "root" in completion
+        assert completion == "t" or "root" in completion
diff --git a/test/t/test_valgrind.py b/test/t/test_valgrind.py
index c7c979dd..0553b556 100644
--- a/test/t/test_valgrind.py
+++ b/test/t/test_valgrind.py
@@ -16,13 +16,13 @@ class TestValgrind:
 
     @pytest.mark.complete("valgrind --tool=memche", require_cmd=True)
     def test_3(self, completion):
-        assert "--tool=memcheck" in completion
+        assert completion == "ck" or "--tool=memcheck" in completion
 
     @pytest.mark.complete(
         "valgrind --tool=helgrind --history-l", require_cmd=True
     )
     def test_4(self, completion):
-        assert "--history-level=" in completion
+        assert completion == "evel=" or "--history-level=" in completion
         assert not completion.endswith(" ")
 
     @pytest.mark.complete(r"valgrind --log-file=v\ 0.log ./bin/", cwd="shared")
diff --git a/test/t/test_wol.py b/test/t/test_wol.py
index b7a622ee..bf04f76e 100644
--- a/test/t/test_wol.py
+++ b/test/t/test_wol.py
@@ -5,14 +5,15 @@ import pytest
 class TestWol:
     @pytest.mark.complete("wol ")
     def test_1(self, completion):
-        assert (
-            completion == "00:00:00:00:00:00 11:11:11:11:11:11 "
+        assert all(
+            x in completion
+            for x in "00:00:00:00:00:00 11:11:11:11:11:11 "
             "22:22:22:22:22:22 33:33:33:33:33:33".split()
         )
 
     @pytest.mark.complete("wol 00:")
     def test_2(self, completion):
-        assert completion == "00:00:00:00:00:00"
+        assert any(x.endswith("00:00:00:00:00") for x in completion)
 
     @pytest.mark.complete("wol -", require_cmd=True)
     def test_3(self, completion):
diff --git a/test/t/test_write.py b/test/t/test_write.py
index 8f0886e4..fc4bfa00 100644
--- a/test/t/test_write.py
+++ b/test/t/test_write.py
@@ -2,6 +2,6 @@ import pytest
 
 
 class TestWrite:
-    @pytest.mark.complete("write root")
+    @pytest.mark.complete("write roo")
     def test_1(self, completion):
-        assert "root" in completion
+        assert completion == "t" or "root" in completion
diff --git a/test/t/test_xfreerdp.py b/test/t/test_xfreerdp.py
index a8435d6c..56162714 100644
--- a/test/t/test_xfreerdp.py
+++ b/test/t/test_xfreerdp.py
@@ -5,10 +5,20 @@ from conftest import assert_bash_exec
 
 class TestXfreerdp:
     def _help(self, bash):
-        return assert_bash_exec(bash, "xfreerdp --help || :", want_output=True)
+        return assert_bash_exec(
+            bash, "xfreerdp --help 2>&1 || :", want_output=True
+        )
 
     @pytest.fixture(scope="class")
-    def slash_syntax(self, bash):
+    def help_success(self, bash):
+        output = self._help(bash)
+        # Example from our CentOS 7 container
+        # [04:51:31:663] [238:238] [ERROR][com.freerdp.client.x11] - Failed to get pixmap info
+        if not output or "ERROR" in output.strip().splitlines()[0]:
+            pytest.skip("--help errored")
+
+    @pytest.fixture(scope="class")
+    def slash_syntax(self, bash, help_success):
         if "/help" not in self._help(bash):
             pytest.skip("Not slash syntax")
 
@@ -18,27 +28,31 @@ class TestXfreerdp:
             pytest.skip("Not dash syntax")
 
     @pytest.mark.complete("xfreerdp /", require_cmd=True)
-    def test_1(self, bash, completion, slash_syntax):
+    def test_1(self, bash, completion, help_success, slash_syntax):
         assert completion
 
     @pytest.mark.complete("xfreerdp -", require_cmd=True)
-    def test_2(self, completion):
+    def test_2(self, completion, help_success):
         assert completion
 
     @pytest.mark.complete("xfreerdp +", require_cmd=True)
-    def test_3(self, bash, completion, slash_syntax):
+    def test_3(self, bash, completion, help_success, slash_syntax):
         assert completion
 
-    @pytest.mark.complete("xfreerdp /kbd:", require_cmd=True)
-    def test_4(self, bash, completion, slash_syntax):
+    @pytest.mark.complete(
+        "xfreerdp /kbd:",
+        require_cmd=True,
+        skipif='test -z "$(xfreerdp /kbd-list 2>/dev/null)"',
+    )
+    def test_4(self, bash, completion, help_success, slash_syntax):
         assert completion
 
     @pytest.mark.complete("xfreerdp /help ", require_cmd=True)
-    def test_5(self, completion):
+    def test_5(self, completion, help_success):
         assert not completion
 
     @pytest.mark.complete("xfreerdp -k ", require_cmd=True)
-    def test_6(self, bash, completion, dash_syntax):
+    def test_6(self, bash, completion, help_success, dash_syntax):
         assert completion
 
     @pytest.mark.complete("xfreerdp --help ", require_cmd=True)
diff --git a/test/t/test_xgamma.py b/test/t/test_xgamma.py
index beb684f8..151e2d36 100644
--- a/test/t/test_xgamma.py
+++ b/test/t/test_xgamma.py
@@ -8,5 +8,5 @@ class TestXgamma:
 
     @pytest.mark.complete("xgamma -gam", require_cmd=True)
     def test_2(self, completion):
-        assert completion == "-gamma"
+        assert completion == "ma"
         assert completion.endswith(" ")
diff --git a/test/t/test_xhost.py b/test/t/test_xhost.py
new file mode 100644
index 00000000..bb2df82a
--- /dev/null
+++ b/test/t/test_xhost.py
@@ -0,0 +1,22 @@
+import pytest
+
+from conftest import assert_complete, partialize
+
+
+@pytest.mark.bashcomp(pre_cmds=("HOME=$PWD",))
+class TestXhost:
+    @pytest.mark.parametrize("prefix", ["+", "-", ""])
+    def test_hosts(self, bash, hosts, prefix):
+        completion = assert_complete(bash, "xhost %s" % prefix)
+        assert completion == ["%s%s" % (prefix, x) for x in hosts]
+
+    @pytest.mark.parametrize("prefix", ["+", "-", ""])
+    def test_partial_hosts(self, bash, hosts, prefix):
+        first_char, partial_hosts = partialize(bash, hosts)
+        completion = assert_complete(bash, "xhost %s%s" % (prefix, first_char))
+        if len(completion) == 1:
+            assert completion == partial_hosts[0][1:]
+        else:
+            assert completion == sorted(
+                "%s%s" % (prefix, x) for x in partial_hosts
+            )
diff --git a/test/t/unit/Makefile.am b/test/t/unit/Makefile.am
index b96b326c..3eb652af 100644
--- a/test/t/unit/Makefile.am
+++ b/test/t/unit/Makefile.am
@@ -8,12 +8,15 @@ EXTRA_DIST = \
 	test_unit_get_cword.py \
 	test_unit_init_completion.py \
 	test_unit_ip_addresses.py \
+	test_unit_known_hosts_real.py \
 	test_unit_longopt.py \
 	test_unit_parse_help.py \
 	test_unit_parse_usage.py \
 	test_unit_quote.py \
+	test_unit_quote_readline.py \
 	test_unit_tilde.py \
-	test_unit_variables.py
+	test_unit_variables.py \
+	test_unit_xinetd_services.py
 
 all:
 
diff --git a/test/t/unit/test_unit_count_args.py b/test/t/unit/test_unit_count_args.py
index c0afe736..56bce2cb 100644
--- a/test/t/unit/test_unit_count_args.py
+++ b/test/t/unit/test_unit_count_args.py
@@ -1,6 +1,6 @@
 import pytest
 
-from conftest import assert_bash_exec, TestUnitBase
+from conftest import TestUnitBase, assert_bash_exec
 
 
 @pytest.mark.bashcomp(
@@ -11,7 +11,7 @@ class TestUnitCountArgs(TestUnitBase):
         return self._test_unit("_count_args %s; echo $args", *args, **kwargs)
 
     def test_1(self, bash):
-        assert_bash_exec(bash, "_count_args >/dev/null")
+        assert_bash_exec(bash, "COMP_CWORD= _count_args >/dev/null")
 
     def test_2(self, bash):
         """a b| should set args to 1"""
diff --git a/test/t/unit/test_unit_expand.py b/test/t/unit/test_unit_expand.py
index 7c0a9836..d2a3ebc4 100644
--- a/test/t/unit/test_unit_expand.py
+++ b/test/t/unit/test_unit_expand.py
@@ -3,7 +3,7 @@ import pytest
 from conftest import assert_bash_exec
 
 
-@pytest.mark.bashcomp(cmd=None)
+@pytest.mark.bashcomp(cmd=None, ignore_env=r"^[+-](cur|COMPREPLY)=")
 class TestUnitExpand:
     def test_1(self, bash):
         assert_bash_exec(bash, "_expand >/dev/null")
@@ -11,3 +11,21 @@ class TestUnitExpand:
     def test_2(self, bash):
         """Test environment non-pollution, detected at teardown."""
         assert_bash_exec(bash, "foo() { _expand; }; foo; unset foo")
+
+    def test_user_home_compreply(self, bash, user_home):
+        user, home = user_home
+        output = assert_bash_exec(
+            bash,
+            r'cur="~%s"; _expand; printf "%%s\n" "$COMPREPLY"' % user,
+            want_output=True,
+        )
+        assert output.strip() == home
+
+    def test_user_home_cur(self, bash, user_home):
+        user, home = user_home
+        output = assert_bash_exec(
+            bash,
+            r'cur="~%s/a"; _expand; printf "%%s\n" "$cur"' % user,
+            want_output=True,
+        )
+        assert output.strip() == "%s/a" % home
diff --git a/test/t/unit/test_unit_expand_tilde_by_ref.py b/test/t/unit/test_unit_expand_tilde_by_ref.py
index fbc172df..17bdedfe 100644
--- a/test/t/unit/test_unit_expand_tilde_by_ref.py
+++ b/test/t/unit/test_unit_expand_tilde_by_ref.py
@@ -3,7 +3,7 @@ import pytest
 from conftest import assert_bash_exec
 
 
-@pytest.mark.bashcomp(cmd=None)
+@pytest.mark.bashcomp(cmd=None, ignore_env=r"^[+-]var=")
 class TestUnitExpandTildeByRef:
     def test_1(self, bash):
         assert_bash_exec(bash, "__expand_tilde_by_ref >/dev/null")
@@ -14,3 +14,33 @@ class TestUnitExpandTildeByRef:
             bash,
             '_x() { local aa="~"; __expand_tilde_by_ref aa; }; _x; unset _x',
         )
+
+    @pytest.mark.parametrize("plain_tilde", (True, False))
+    @pytest.mark.parametrize(
+        "suffix_expanded",
+        (
+            ("", True),
+            ("/foo", True),
+            (r"/\$HOME", True),
+            ("/a  b", True),
+            ("/*", True),
+            (";echo hello", False),
+            ("/a;echo hello", True),
+        ),
+    )
+    def test_expand(self, bash, user_home, plain_tilde, suffix_expanded):
+        user, home = user_home
+        suffix, expanded = suffix_expanded
+        if plain_tilde:
+            user = ""
+            if not suffix or not expanded:
+                home = "~"
+        elif not expanded:
+            home = "~%s" % user
+        output = assert_bash_exec(
+            bash,
+            r'var="~%s%s"; __expand_tilde_by_ref var; printf "%%s\n" "$var"'
+            % (user, suffix),
+            want_output=True,
+        )
+        assert output.strip() == "%s%s" % (home, suffix.replace(r"\$", "$"),)
diff --git a/test/t/unit/test_unit_filedir.py b/test/t/unit/test_unit_filedir.py
index 7f14f294..b847efc2 100644
--- a/test/t/unit/test_unit_filedir.py
+++ b/test/t/unit/test_unit_filedir.py
@@ -1,3 +1,9 @@
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
 import pytest
 
 from conftest import assert_bash_exec, assert_complete
@@ -24,102 +30,206 @@ class TestUnitFiledir:
             "complete -F _fd fd",
         )
 
+    @pytest.fixture(scope="class")
+    def non_windows_testdir(self, request, bash):
+        if sys.platform.startswith("win"):
+            pytest.skip("Filenames not allowed on Windows")
+        tempdir = Path(tempfile.mkdtemp(prefix="bash-completion_filedir"))
+        request.addfinalizer(lambda: shutil.rmtree(str(tempdir)))
+        subdir = tempdir / 'a"b'
+        subdir.mkdir()
+        (subdir / "d").touch()
+        subdir = tempdir / "a*b"
+        subdir.mkdir()
+        (subdir / "j").touch()
+        subdir = tempdir / r"a\b"
+        subdir.mkdir()
+        (subdir / "g").touch()
+        return tempdir
+
+    @pytest.fixture(scope="class")
+    def utf8_ctype(self, bash):
+        # TODO: this likely is not the right thing to do. Instead we should
+        # grab the setting from the running shell, possibly eval $(locale)
+        # in a subshell and grab LC_CTYPE from there. That doesn't seem to work
+        # either everywhere though.
+        lc_ctype = os.environ.get("LC_CTYPE", "")
+        if "UTF-8" not in lc_ctype:
+            pytest.skip("Applicable only in LC_CTYPE=UTF-8 setups")
+        return lc_ctype
+
     def test_1(self, bash):
         assert_bash_exec(bash, "_filedir >/dev/null")
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_2(self, bash, functions, funcname):
         completion = assert_complete(bash, "%s ab/" % funcname, cwd="_filedir")
-        assert completion == "ab/e"
+        assert completion == "e"
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_3(self, bash, functions, funcname):
         completion = assert_complete(
             bash, r"%s a\ b/" % funcname, cwd="_filedir"
         )
-        assert completion == "a b/i"
+        assert completion == "i"
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_4(self, bash, functions, funcname):
         completion = assert_complete(
             bash, r"%s a\'b/" % funcname, cwd="_filedir"
         )
-        assert completion == "a'b/c"
+        assert completion == "c"
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_5(self, bash, functions, funcname):
         completion = assert_complete(
             bash, r"%s a\&b/" % funcname, cwd="_filedir"
         )
-        assert completion == "a&b/f"
+        assert completion == "f"
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_6(self, bash, functions, funcname):
         completion = assert_complete(
             bash, r"%s a\$" % funcname, cwd="_filedir"
         )
-        assert completion == "a$b/"
+        assert completion == "b/"
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_7(self, bash, functions, funcname):
         completion = assert_complete(
             bash, r"%s 'ab/" % funcname, cwd="_filedir"
         )
-        assert completion == "ab/e"
+        assert completion == "e'"
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_8(self, bash, functions, funcname):
         completion = assert_complete(
             bash, r"%s 'a b/" % funcname, cwd="_filedir"
         )
-        assert completion == "a b/i"
+        assert completion == "i'"
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_9(self, bash, functions, funcname):
         completion = assert_complete(
             bash, r"%s 'a$b/" % funcname, cwd="_filedir"
         )
-        assert completion == "a$b/h"
+        assert completion == "h'"
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_10(self, bash, functions, funcname):
         completion = assert_complete(
             bash, r"%s 'a&b/" % funcname, cwd="_filedir"
         )
-        assert completion == "a&b/f"
+        assert completion == "f'"
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_11(self, bash, functions, funcname):
         completion = assert_complete(
             bash, r'%s "ab/' % funcname, cwd="_filedir"
         )
-        assert completion == "ab/e"
+        assert completion == 'e"'
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_12(self, bash, functions, funcname):
         completion = assert_complete(
             bash, r'%s "a b/' % funcname, cwd="_filedir"
         )
-        assert completion == "a b/i"
+        assert completion == 'i"'
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_13(self, bash, functions, funcname):
         completion = assert_complete(
             bash, "%s \"a'b/" % funcname, cwd="_filedir"
         )
-        assert completion == "a'b/c"
+        assert completion == 'c"'
 
     @pytest.mark.parametrize("funcname", "f f2".split())
     def test_14(self, bash, functions, funcname):
         completion = assert_complete(
             bash, '%s "a&b/' % funcname, cwd="_filedir"
         )
-        assert completion == "a&b/f"
+        assert completion == 'f"'
 
     @pytest.mark.complete(r"fd a\ ", cwd="_filedir")
     def test_15(self, functions, completion):
-        assert completion == "a b/"
+        assert completion == "b/"
 
     @pytest.mark.complete("g ", cwd="_filedir/ext")
     def test_16(self, functions, completion):
         assert completion == sorted("ee.e1 foo/ gg.e1 ii.E1".split())
+
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_17(self, bash, functions, funcname):
+        completion = assert_complete(
+            bash, r"%s a\$b/" % funcname, cwd="_filedir"
+        )
+        assert completion == "h"
+
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_18(self, bash, functions, funcname):
+        completion = assert_complete(
+            bash, r"%s \[x" % funcname, cwd="_filedir/brackets"
+        )
+        assert completion == r"\]"
+
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_19(self, bash, functions, funcname, non_windows_testdir):
+        completion = assert_complete(
+            bash, '%s a\\"b/' % funcname, cwd=non_windows_testdir
+        )
+        assert completion == "d"
+
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_20(self, bash, functions, funcname, non_windows_testdir):
+        completion = assert_complete(
+            bash, r"%s a\\b/" % funcname, cwd=non_windows_testdir
+        )
+        assert completion == "g"
+
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_21(self, bash, functions, funcname, non_windows_testdir):
+        completion = assert_complete(
+            bash, "%s 'a\"b/" % funcname, cwd=non_windows_testdir
+        )
+        assert completion == "d'"
+
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_22(self, bash, functions, funcname, non_windows_testdir):
+        completion = assert_complete(
+            bash, r"%s '%s/a\b/" % (funcname, non_windows_testdir)
+        )
+        assert completion == "g'"
+
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_23(self, bash, functions, funcname, non_windows_testdir):
+        completion = assert_complete(
+            bash, r'%s "a\"b/' % funcname, cwd=non_windows_testdir
+        )
+        assert completion == 'd"'
+
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_24(self, bash, functions, funcname, non_windows_testdir):
+        completion = assert_complete(
+            bash, r'%s "a\\b/' % funcname, cwd=non_windows_testdir
+        )
+        assert completion == 'g"'
+
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_25(self, bash, functions, funcname):
+        completion = assert_complete(
+            bash, r'%s "a\b/' % funcname, cwd="_filedir"
+        )
+        assert completion == '\b\b\bb/e"'
+
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_26(self, bash, functions, funcname):
+        completion = assert_complete(
+            bash, r'%s "a\$b/' % funcname, cwd="_filedir"
+        )
+        assert completion == 'h"'
+
+    @pytest.mark.xfail(reason="TODO: non-ASCII issues with test suite?")
+    @pytest.mark.parametrize("funcname", "f f2".split())
+    def test_27(self, bash, functions, funcname, utf8_ctype):
+        completion = assert_complete(bash, "%s aé/" % funcname, cwd="_filedir")
+        assert completion == "g"
diff --git a/test/t/unit/test_unit_get_comp_words_by_ref.py b/test/t/unit/test_unit_get_comp_words_by_ref.py
index 1603bad6..b6498fa7 100644
--- a/test/t/unit/test_unit_get_comp_words_by_ref.py
+++ b/test/t/unit/test_unit_get_comp_words_by_ref.py
@@ -1,16 +1,17 @@
 import pytest
 
-from conftest import assert_bash_exec, TestUnitBase
+from conftest import TestUnitBase, assert_bash_exec
 
 
 @pytest.mark.bashcomp(
-    cmd=None, ignore_env=r"^(\+(cur|prev)|[+-]COMP_(WORDS|CWORD|LINE|POINT))="
+    cmd=None,
+    ignore_env=r"^(\+(words|cword|cur|prev)|[+-]COMP_(WORDS|CWORD|LINE|POINT))=",
 )
 class TestUnitGetCompWordsByRef(TestUnitBase):
     def _test(self, bash, *args, **kwargs):
         assert_bash_exec(bash, "unset cur prev")
         output = self._test_unit(
-            "_get_comp_words_by_ref %s cur prev; echo $cur,$prev",
+            "_get_comp_words_by_ref %s cur prev; echo $cur,${prev-}",
             bash,
             *args,
             **kwargs
@@ -18,7 +19,11 @@ class TestUnitGetCompWordsByRef(TestUnitBase):
         return output.strip()
 
     def test_1(self, bash):
-        assert_bash_exec(bash, "_get_comp_words_by_ref cur >/dev/null")
+        assert_bash_exec(
+            bash,
+            "COMP_WORDS=() COMP_CWORD= COMP_POINT= COMP_LINE= "
+            "_get_comp_words_by_ref cur >/dev/null",
+        )
 
     def test_2(self, bash):
         """a b|"""
@@ -165,3 +170,91 @@ class TestUnitGetCompWordsByRef(TestUnitBase):
         """a 'b&c|"""
         output = self._test(bash, '(a "\'b&c")', 1, "a 'b&c", 6)
         assert output == "'b&c,a"
+
+    def test_30(self, bash):
+        """a b| to all vars"""
+        assert_bash_exec(bash, "unset words cword cur prev")
+        output = self._test_unit(
+            "_get_comp_words_by_ref words cword cur prev%s; "
+            'echo "${words[@]}",$cword,$cur,$prev',
+            bash,
+            "(a b)",
+            1,
+            "a b",
+            3,
+        )
+        assert output == "a b,1,b,a"
+
+    def test_31(self, bash):
+        """a b| to alternate vars"""
+        assert_bash_exec(bash, "unset words2 cword2 cur2 prev2")
+        output = self._test_unit(
+            "_get_comp_words_by_ref -w words2 -i cword2 -c cur2 -p prev2%s; "
+            'echo $cur2,$prev2,"${words2[@]}",$cword2',
+            bash,
+            "(a b)",
+            1,
+            "a b",
+            3,
+        )
+        assert output == "b,a,a b,1"
+        assert_bash_exec(bash, "unset words2 cword2 cur2 prev2")
+
+    def test_32(self, bash):
+        """a b : c| with wordbreaks -= :"""
+        assert_bash_exec(bash, "unset words")
+        output = self._test_unit(
+            '_get_comp_words_by_ref -n : words%s; echo "${words[@]}"',
+            bash,
+            "(a b : c)",
+            3,
+            "a b : c",
+            7,
+        )
+        assert output == "a b : c"
+
+    def test_33(self, bash):
+        """a b: c| with wordbreaks -= :"""
+        assert_bash_exec(bash, "unset words")
+        output = self._test_unit(
+            '_get_comp_words_by_ref -n : words%s; echo "${words[@]}"',
+            bash,
+            "(a b : c)",
+            3,
+            "a b: c",
+            6,
+        )
+        assert output == "a b: c"
+
+    def test_34(self, bash):
+        """a b :c| with wordbreaks -= :"""
+        assert_bash_exec(bash, "unset words")
+        output = self._test_unit(
+            '_get_comp_words_by_ref -n : words%s; echo "${words[@]}"',
+            bash,
+            "(a b : c)",
+            3,
+            "a b :c",
+            6,
+        )
+        assert output == "a b :c"
+
+    def test_35(self, bash):
+        r"""a b\ :c| with wordbreaks -= :"""
+        assert_bash_exec(bash, "unset words")
+        output = self._test_unit(
+            '_get_comp_words_by_ref -n : words%s; echo "${words[@]}"',
+            bash,
+            "(a 'b ' : c)",
+            3,
+            r"a b\ :c",
+            7,
+        )
+        assert output == "a b  :c"
+
+    def test_unknown_arg_error(self, bash):
+        with pytest.raises(AssertionError) as ex:
+            _ = assert_bash_exec(
+                bash, "_get_comp_words_by_ref dummy", want_output=True
+            )
+        ex.match("dummy.* unknown argument")
diff --git a/test/t/unit/test_unit_get_cword.py b/test/t/unit/test_unit_get_cword.py
index 3042dd29..0b56d163 100644
--- a/test/t/unit/test_unit_get_cword.py
+++ b/test/t/unit/test_unit_get_cword.py
@@ -1,17 +1,22 @@
+import pexpect
 import pytest
 
-from conftest import assert_bash_exec, TestUnitBase
+from conftest import PS1, TestUnitBase, assert_bash_exec
 
 
 @pytest.mark.bashcomp(
-    cmd=None, ignore_env=r"^[+-]COMP_(WORDS|CWORD|LINE|POINT)="
+    cmd=None, ignore_env=r"^[+-](COMP_(WORDS|CWORD|LINE|POINT)|_scp_path_esc)="
 )
 class TestUnitGetCword(TestUnitBase):
     def _test(self, *args, **kwargs):
         return self._test_unit("_get_cword %s; echo", *args, **kwargs)
 
     def test_1(self, bash):
-        assert_bash_exec(bash, "_get_cword >/dev/null")
+        assert_bash_exec(
+            bash,
+            "COMP_WORDS=() COMP_CWORD= COMP_LINE= COMP_POINT= "
+            "_get_cword >/dev/null",
+        )
 
     def test_2(self, bash):
         """a b| should return b"""
@@ -133,3 +138,17 @@ class TestUnitGetCword(TestUnitBase):
         """a 'b&c| should return 'b&c"""
         output = self._test(bash, '(a "\'b&c")', 1, "a 'b&c", 6)
         assert output == "'b&c"
+
+    @pytest.mark.xfail(reason="TODO: non-ASCII issues with test suite?")
+    def test_24(self, bash):
+        """Index shouldn't drop below 0"""
+        bash.send("scp ääää§ se\t\r\n")
+        got = bash.expect_exact(
+            [
+                "index: substring expression < 0",
+                PS1,
+                pexpect.EOF,
+                pexpect.TIMEOUT,
+            ]
+        )
+        assert got == 1
diff --git a/test/t/unit/test_unit_init_completion.py b/test/t/unit/test_unit_init_completion.py
index 64f3b511..64a5a790 100644
--- a/test/t/unit/test_unit_init_completion.py
+++ b/test/t/unit/test_unit_init_completion.py
@@ -1,6 +1,6 @@
 import pytest
 
-from conftest import assert_bash_exec, TestUnitBase
+from conftest import TestUnitBase, assert_bash_exec, assert_complete
 
 
 @pytest.mark.bashcomp(
@@ -13,12 +13,22 @@ class TestUnitInitCompletion(TestUnitBase):
         """Test environment non-pollution, detected at teardown."""
         assert_bash_exec(
             bash,
-            "foo() { local cur prev words cword; _init_completion; }; "
+            "foo() { "
+            "local cur prev words cword "
+            "COMP_WORDS=() COMP_CWORD=0 COMP_LINE= COMP_POINT=0; "
+            "_init_completion; }; "
             "foo; unset foo",
         )
 
     def test_2(self, bash):
         output = self._test_unit(
-            "_init_completion %s; echo $cur,$prev", bash, "(a)", 0, "a", 0
+            "_init_completion %s; echo $cur,${prev-}", bash, "(a)", 0, "a", 0
         )
         assert output == ","
+
+    @pytest.mark.parametrize("redirect", "> >> 2> < &>".split())
+    def test_redirect(self, bash, redirect):
+        completion = assert_complete(
+            bash, "%s " % redirect, cwd="shared/default"
+        )
+        assert all(x in completion for x in "foo bar".split())
diff --git a/test/t/unit/test_unit_known_hosts_real.py b/test/t/unit/test_unit_known_hosts_real.py
new file mode 100644
index 00000000..ac5205e1
--- /dev/null
+++ b/test/t/unit/test_unit_known_hosts_real.py
@@ -0,0 +1,158 @@
+from itertools import chain
+
+import pytest
+
+from conftest import assert_bash_exec
+
+
+@pytest.mark.bashcomp(
+    cmd=None,
+    ignore_env="^[+-](COMP(REPLY|_KNOWN_HOSTS_WITH_HOSTFILE)|OLDHOME)=",
+)
+class TestUnitKnownHostsReal:
+    @pytest.mark.parametrize(
+        "prefix,colon_flag,hostfile",
+        [("", "", True), ("", "", False), ("user@", "c", True)],
+    )
+    def test_basic(
+        self, bash, hosts, avahi_hosts, prefix, colon_flag, hostfile
+    ):
+        expected = (
+            "%s%s%s" % (prefix, x, ":" if colon_flag else "")
+            for x in chain(
+                hosts if hostfile else avahi_hosts,
+                # fixtures/_known_hosts_real/config
+                "gee hus jar #not-a-comment".split(),
+                # fixtures/_known_hosts_real/known_hosts
+                (
+                    "doo",
+                    "ike",
+                    "jub",
+                    "10.0.0.1",
+                    "kyl",
+                    "100.0.0.2",
+                    "10.10.0.3",
+                    "blah",
+                    "fd00:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:5555",
+                    "fe80::123:0xff:dead:beef%eth0",
+                    "1111:2222:3333:4444:5555:6666:xxxx:abab",
+                    "11xx:2222:3333:4444:5555:6666:xxxx:abab",
+                    "::42",
+                ),
+            )
+        )
+        assert_bash_exec(
+            bash,
+            "unset -v COMP_KNOWN_HOSTS_WITH_HOSTFILE"
+            if hostfile
+            else "COMP_KNOWN_HOSTS_WITH_HOSTFILE=",
+        )
+        output = assert_bash_exec(
+            bash,
+            "_known_hosts_real -a%sF _known_hosts_real/config '%s'; "
+            r'printf "%%s\n" "${COMPREPLY[@]}"; unset COMPREPLY'
+            % (colon_flag, prefix),
+            want_output=True,
+        )
+        assert sorted(set(output.split())) == sorted(expected)
+
+    @pytest.mark.parametrize(
+        "family,result",
+        (
+            ("4", "127.0.0.1 localhost"),
+            ("6", "::1 localhost"),
+            ("46", "localhost"),
+        ),
+    )
+    def test_ip_filtering(self, bash, family, result):
+        assert_bash_exec(
+            bash, "unset -v COMPREPLY COMP_KNOWN_HOSTS_WITH_HOSTFILE"
+        )
+        output = assert_bash_exec(
+            bash,
+            "COMP_KNOWN_HOSTS_WITH_HOSTFILE= "
+            "_known_hosts_real -%sF _known_hosts_real/localhost_config ''; "
+            r'printf "%%s\n" "${COMPREPLY[@]}"' % family,
+            want_output=True,
+        )
+        assert sorted(set(output.strip().split())) == sorted(result.split())
+
+    def test_consecutive_spaces(self, bash, hosts):
+        expected = hosts.copy()
+        # fixtures/_known_hosts_real/spaced  conf
+        expected.extend("gee hus #not-a-comment".split())
+        # fixtures/_known_hosts_real/known_hosts2
+        expected.extend("two two2 two3 two4".split())
+        # fixtures/_known_hosts_/spaced  known_hosts
+        expected.extend("doo ike".split())
+
+        output = assert_bash_exec(
+            bash,
+            "unset -v COMPREPLY COMP_KNOWN_HOSTS_WITH_HOSTFILE; "
+            "_known_hosts_real -aF '_known_hosts_real/spaced  conf' ''; "
+            r'printf "%s\n" "${COMPREPLY[@]}"',
+            want_output=True,
+        )
+        assert sorted(set(output.strip().split())) == sorted(expected)
+
+    def test_files_starting_with_tilde(self, bash, hosts):
+        expected = hosts.copy()
+        # fixtures/_known_hosts_real/known_hosts2
+        expected.extend("two two2 two3 two4".split())
+        # fixtures/_known_hosts_real/known_hosts3
+        expected.append("three")
+        # fixtures/_known_hosts_real/known_hosts4
+        expected.append("four")
+
+        assert_bash_exec(bash, 'OLDHOME="$HOME"; HOME="%s"' % bash.cwd)
+        output = assert_bash_exec(
+            bash,
+            "unset -v COMPREPLY COMP_KNOWN_HOSTS_WITH_HOSTFILE; "
+            "_known_hosts_real -aF _known_hosts_real/config_tilde ''; "
+            r'printf "%s\n" "${COMPREPLY[@]}"',
+            want_output=True,
+        )
+        assert_bash_exec(bash, 'HOME="$OLDHOME"')
+        assert sorted(set(output.strip().split())) == sorted(expected)
+
+    def test_included_configs(self, bash, hosts):
+        expected = hosts.copy()
+        # fixtures/_known_hosts_real/config_include_recursion
+        expected.append("recursion")
+        # fixtures/_known_hosts_real/.ssh/config_relative_path
+        expected.append("relative_path")
+        # fixtures/_known_hosts_real/.ssh/config_asterisk_*
+        expected.extend("asterisk_1 asterisk_2".split())
+        # fixtures/_known_hosts_real/.ssh/config_question_mark
+        expected.append("question_mark")
+
+        assert_bash_exec(
+            bash, 'OLDHOME="$HOME"; HOME="%s/_known_hosts_real"' % bash.cwd
+        )
+        output = assert_bash_exec(
+            bash,
+            "unset -v COMPREPLY COMP_KNOWN_HOSTS_WITH_HOSTFILE; "
+            "_known_hosts_real -aF _known_hosts_real/config_include ''; "
+            r'printf "%s\n" "${COMPREPLY[@]}"',
+            want_output=True,
+        )
+        assert_bash_exec(bash, 'HOME="$OLDHOME"')
+        assert sorted(set(output.strip().split())) == sorted(expected)
+
+    def test_no_globbing(self, bash):
+        assert_bash_exec(
+            bash, 'OLDHOME="$HOME"; HOME="%s/_known_hosts_real"' % bash.cwd
+        )
+        output = assert_bash_exec(
+            bash,
+            "cd _known_hosts_real; "
+            "unset -v COMPREPLY COMP_KNOWN_HOSTS_WITH_HOSTFILE; "
+            "_known_hosts_real -aF config ''; "
+            r'printf "%s\n" "${COMPREPLY[@]}"; '
+            "cd - &>/dev/null",
+            want_output=True,
+        )
+        assert_bash_exec(bash, 'HOME="$OLDHOME"')
+        completion = sorted(set(output.strip().split()))
+        assert "gee" in completion
+        assert "gee-filename-canary" not in completion
diff --git a/test/t/unit/test_unit_longopt.py b/test/t/unit/test_unit_longopt.py
index ac0ac836..c5488e34 100644
--- a/test/t/unit/test_unit_longopt.py
+++ b/test/t/unit/test_unit_longopt.py
@@ -11,6 +11,8 @@ class TestUnitLongopt:
     def functions(self, request, bash):
         assert_bash_exec(bash, "_grephelp() { cat _longopt/grep--help.txt; }")
         assert_bash_exec(bash, "complete -F _longopt _grephelp")
+        assert_bash_exec(bash, "_various() { cat _longopt/various.txt; }")
+        assert_bash_exec(bash, "complete -F _longopt _various")
 
     @pytest.mark.complete("_grephelp --")
     def test_1(self, functions, completion):
@@ -32,3 +34,19 @@ class TestUnitLongopt:
         assert completion
         assert any(x.endswith("=") for x in completion)
         assert any(not x.endswith("=") for x in completion)
+
+    @pytest.mark.complete("_various --")
+    def test_no_dashdashdash(self, functions, completion):
+        assert all(not x.startswith("---") for x in completion)
+
+    @pytest.mark.complete("_various --")
+    def test_no_trailingdash(self, functions, completion):
+        assert all(not x.endswith("-") for x in completion)
+
+    @pytest.mark.complete("_various --")
+    def test_underscore(self, functions, completion):
+        assert "--foo_bar" in completion
+
+    @pytest.mark.complete("_various --")
+    def test_equals(self, functions, completion):
+        assert "--foo=" in completion
diff --git a/test/t/unit/test_unit_quote.py b/test/t/unit/test_unit_quote.py
index e9f81c2d..b280bd68 100644
--- a/test/t/unit/test_unit_quote.py
+++ b/test/t/unit/test_unit_quote.py
@@ -1,6 +1,6 @@
 import pytest
 
-from conftest import assert_bash_exec, TestUnitBase
+from conftest import TestUnitBase, assert_bash_exec
 
 
 @pytest.mark.bashcomp(cmd=None)
diff --git a/test/t/unit/test_unit_quote_readline.py b/test/t/unit/test_unit_quote_readline.py
new file mode 100644
index 00000000..e2b437e3
--- /dev/null
+++ b/test/t/unit/test_unit_quote_readline.py
@@ -0,0 +1,15 @@
+import pytest
+
+from conftest import assert_bash_exec
+
+
+@pytest.mark.bashcomp(cmd=None)
+class TestUnitQuoteReadline:
+    def test_exec(self, bash):
+        assert_bash_exec(bash, "quote_readline '' >/dev/null")
+
+    def test_env_non_pollution(self, bash):
+        """Test environment non-pollution, detected at teardown."""
+        assert_bash_exec(
+            bash, "foo() { quote_readline meh >/dev/null; }; foo; unset foo"
+        )
diff --git a/test/t/unit/test_unit_variables.py b/test/t/unit/test_unit_variables.py
index dd7a4219..d62bc4a4 100644
--- a/test/t/unit/test_unit_variables.py
+++ b/test/t/unit/test_unit_variables.py
@@ -18,11 +18,11 @@ class TestUnitVariables:
 
     @pytest.mark.complete(": $___v")
     def test_simple_variable_name(self, functions, completion):
-        assert completion == "$___var".split()
+        assert completion == "ar"
 
     @pytest.mark.complete(": ${assoc1[")
     def test_single_array_index(self, functions, completion):
-        assert completion == "${assoc1[idx]}".split()
+        assert completion == "idx]}"
 
     @pytest.mark.complete(": ${assoc2[")
     def test_multiple_array_indexes(self, functions, completion):
@@ -30,12 +30,12 @@ class TestUnitVariables:
 
     @pytest.mark.complete(": ${assoc1[bogus]")
     def test_closing_curly_after_square(self, functions, completion):
-        assert completion == "${assoc1[bogus]}".split()
+        assert completion == "}"
 
     @pytest.mark.complete(": ${assoc1[@")
     def test_closing_brackets_after_at(self, functions, completion):
-        assert completion == "${assoc1[@]}".split()
+        assert completion == "]}"
 
     @pytest.mark.complete(": ${#___v")
     def test_hash_prefix(self, functions, completion):
-        assert completion == "${#___var}".split()
+        assert completion == "ar}"
diff --git a/test/t/unit/test_unit_xinetd_services.py b/test/t/unit/test_unit_xinetd_services.py
new file mode 100644
index 00000000..7a90cb7f
--- /dev/null
+++ b/test/t/unit/test_unit_xinetd_services.py
@@ -0,0 +1,22 @@
+import pytest
+
+from conftest import assert_bash_exec
+
+
+@pytest.mark.bashcomp(cmd=None, ignore_env=r"^\+COMPREPLY=")
+class TestUnitXinetdServices:
+    def test_direct(self, bash):
+        assert_bash_exec(bash, "_xinetd_services >/dev/null")
+
+    def test_env_non_pollution(self, bash):
+        """Test environment non-pollution, detected at teardown."""
+        assert_bash_exec(bash, "foo() { _xinetd_services; }; foo; unset foo")
+
+    def test_basic(self, bash):
+        output = assert_bash_exec(
+            bash,
+            "foo() { local BASHCOMP_XINETDDIR=$PWD/shared/bin;unset COMPREPLY; "
+            '_xinetd_services; printf "%s\\n" "${COMPREPLY[@]}"; }; foo; unset foo',
+            want_output=True,
+        )
+        assert sorted(output.split()) == ["arp", "ifconfig"]