# SPDX-FileCopyrightText: Ryan Roden-Corrent (rcorre) <ryan@rcorre.net>
#
# SPDX-License-Identifier: GPL-3.0-or-later

"""Tests for completion models."""

import collections
import os
import pathlib
import random
import string
import time
from datetime import datetime
from unittest import mock

import hypothesis
import hypothesis.strategies as hst
import pytest
from qutebrowser.qt.core import QUrl, QDateTime, QProcess
try:
    from qutebrowser.qt.webenginecore import (
        QWebEngineHistory, QWebEngineHistoryItem
    )
except ImportError:
    pass

from qutebrowser.misc import objects, guiprocess
from qutebrowser.completion import completer
from qutebrowser.completion.models import (
    configmodel, listcategory, miscmodels, urlmodel, filepathcategory)
from qutebrowser.config import configdata, configtypes
from qutebrowser.utils import usertypes, utils
from qutebrowser.mainwindow import tabbedbrowser


def _check_completions(model, expected):
    """Check that a model contains the expected items in order.

    Args:
        expected: A dict of form
            {
                CategoryName: [(name, desc, misc), ...],
                CategoryName: [(name, desc, misc), ...],
                ...
            }
    """
    __tracebackhide__ = True
    actual = {}
    assert model.rowCount() == len(expected)
    for i in range(0, model.rowCount()):
        catidx = model.index(i, 0)
        catname = model.data(catidx)
        actual[catname] = []
        for j in range(model.rowCount(catidx)):
            name = model.data(model.index(j, 0, parent=catidx))
            desc = model.data(model.index(j, 1, parent=catidx))
            misc = model.data(model.index(j, 2, parent=catidx))
            actual[catname].append((name, desc, misc))
    assert actual == expected
    # sanity-check the column_widths
    assert sum(model.column_widths) == 100


@pytest.fixture
def cmdutils_stub(monkeypatch, stubs):
    """Patch the cmdutils module to provide fake commands."""
    return monkeypatch.setattr(objects, 'commands', {
        'quit': stubs.FakeCommand(name='quit', desc='quit qutebrowser'),
        'open': stubs.FakeCommand(name='open', desc='open a url'),
        'prompt-yes': stubs.FakeCommand(name='prompt-yes', deprecated=True),
        'scroll': stubs.FakeCommand(
            name='scroll',
            desc='Scroll the current tab in the given direction.',
            modes=()),
        'tab-close': stubs.FakeCommand(
            name='tab-close',
            desc='Close the current tab.'),
    })


@pytest.fixture
def configdata_stub(config_stub, monkeypatch, configdata_init):
    """Patch the configdata module to provide fake data."""
    monkeypatch.setattr(configdata, 'DATA', collections.OrderedDict([
        ('aliases', configdata.Option(
            name='aliases',
            description='Aliases for commands.',
            typ=configtypes.Dict(
                keytype=configtypes.String(),
                valtype=configtypes.Command(),
            ),
            default={'q': 'quit'},
            backends=[usertypes.Backend.QtWebKit,
                      usertypes.Backend.QtWebEngine],
            raw_backends=None)),
        ('bindings.default', configdata.Option(
            name='bindings.default',
            description='Default keybindings',
            typ=configtypes.Dict(
                keytype=configtypes.String(),
                valtype=configtypes.Dict(
                    keytype=configtypes.Key(),
                    valtype=configtypes.Command(),
                ),
            ),
            default={
                'normal': collections.OrderedDict([
                    ('<Ctrl+q>', 'quit'),
                    ('d', 'tab-close'),
                ])
            },
            backends=[],
            raw_backends=None,
            no_autoconfig=True)),
        ('bindings.commands', configdata.Option(
            name='bindings.commands',
            description='Custom keybindings',
            typ=configtypes.Dict(
                keytype=configtypes.String(),
                valtype=configtypes.Dict(
                    keytype=configtypes.Key(),
                    valtype=configtypes.Command(),
                ),
            ),
            default={
                'normal': collections.OrderedDict([
                    ('<Ctrl+q>', 'quit'),
                    ('ZQ', 'quit'),
                    ('I', 'invalid'),
                    ('d', 'scroll down'),
                ])
            },
            backends=[],
            raw_backends=None)),
        ('content.javascript.enabled', configdata.Option(
            name='content.javascript.enabled',
            description='Enable/Disable JavaScript',
            typ=configtypes.Bool(),
            default=True,
            backends=[],
            raw_backends=None)),
        ('completion.open_categories', configdata.Option(
            name='completion.open_categories',
            description=('Which categories to show (in which order) in the '
                         ':open completion.'),
            typ=configtypes.FlagList(),
            default=["searchengines", "quickmarks", "bookmarks", "history"],
            backends=[],
            raw_backends=None)),
        ('url.searchengines', configdata.Option(
            name='url.searchengines',
            description='searchengines list',
            typ=configtypes.Dict(
                keytype=configtypes.String(),
                valtype=configtypes.String(),
            ),
            default={"DEFAULT": "https://duckduckgo.com/?q={}", "google": "https://google.com/?q={}"},
            backends=[],
            raw_backends=None)),
    ]))
    config_stub._init_values()


@pytest.fixture
def quickmarks(quickmark_manager_stub):
    """Pre-populate the quickmark-manager stub with some quickmarks."""
    quickmark_manager_stub.marks = collections.OrderedDict([
        ('aw', 'https://wiki.archlinux.org'),
        ('wiki', 'https://wikipedia.org'),
        ('ddg', 'https://duckduckgo.com'),
    ])
    return quickmark_manager_stub


@pytest.fixture
def bookmarks(bookmark_manager_stub):
    """Pre-populate the bookmark-manager stub with some quickmarks."""
    bookmark_manager_stub.marks = collections.OrderedDict([
        ('https://github.com', 'GitHub'),
        ('https://python.org', 'Welcome to Python.org'),
        ('http://qutebrowser.org', 'qutebrowser | qutebrowser'),
    ])
    return bookmark_manager_stub


@pytest.fixture
def local_files_path(tmp_path):
    files_dir = tmp_path / 'files'
    files_dir.mkdir()
    (files_dir / 'file1.txt').touch()
    (files_dir / 'file2.txt').touch()
    return files_dir


@pytest.fixture
def web_history_populated(web_history):
    """Pre-populate the web-history database."""
    web_history.add_url(
        url=QUrl('http://qutebrowser.org'),
        title='qutebrowser',
        atime=datetime(2015, 9, 5).timestamp()
    )
    web_history.add_url(
        url=QUrl('https://python.org'),
        title='Welcome to Python.org',
        atime=datetime(2016, 3, 8).timestamp()
    )
    web_history.add_url(
        url=QUrl('https://github.com'),
        title='https://github.com',
        atime=datetime(2016, 5, 1).timestamp()
    )
    return web_history


@pytest.fixture
def info(config_stub, key_config_stub):
    return completer.CompletionInfo(config=config_stub,
                                    keyconf=key_config_stub,
                                    win_id=0,
                                    cur_tab=None)


def test_command_completion(qtmodeltester, cmdutils_stub, configdata_stub,
                            key_config_stub, info):
    """Test the results of command completion.

    Validates that:
        - only non-hidden and non-deprecated commands are included
        - the command description is shown in the desc column
        - the binding (if any) is shown in the misc column
        - aliases are included
    """
    model = miscmodels.command(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Commands": [
            ('open', 'open a url', ''),
            ('q', "Alias for 'quit'", ''),
            ('quit', 'quit qutebrowser', 'ZQ, <Ctrl+q>'),
            ('tab-close', 'Close the current tab.', ''),
        ]
    })


def test_help_completion(qtmodeltester, cmdutils_stub, key_config_stub,
                         configdata_stub, config_stub, info):
    """Test the results of command completion.

    Validates that:
        - only non-deprecated commands are included
        - the command description is shown in the desc column
        - the binding (if any) is shown in the misc column
        - aliases are not included
        - only the first line of a multiline description is shown
    """
    model = miscmodels.helptopic(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Commands": [
            (':open', 'open a url', ''),
            (':quit', 'quit qutebrowser', 'ZQ, <Ctrl+q>'),
            (':scroll', 'Scroll the current tab in the given direction.', ''),
            (':tab-close', 'Close the current tab.', ''),
        ],
        "Settings": [
            (
                'aliases',
                'Aliases for commands.',
                '{"q": "quit"}',
            ),
            (
                'bindings.commands',
                'Custom keybindings',
                ('{"normal": {"<Ctrl+q>": "quit", "I": "invalid", "ZQ": "quit", '
                 '"d": "scroll down"}}'),
            ),
            (
                'bindings.default',
                'Default keybindings',
                '{"normal": {"<Ctrl+q>": "quit", "d": "tab-close"}}',
            ),
            (
                'completion.open_categories',
                'Which categories to show (in which order) in the :open completion.',
                '["searchengines", "quickmarks", "bookmarks", "history"]',
            ),
            (
                'content.javascript.enabled',
                'Enable/Disable JavaScript',
                'true'
            ),
            (
                'url.searchengines',
                'searchengines list',
                ('{"DEFAULT": "https://duckduckgo.com/?q={}", '
                 '"google": "https://google.com/?q={}"}'),
            ),
        ],
    })


def test_open_categories(qtmodeltester, config_stub, web_history_populated,
                         quickmarks, bookmarks, info):
    """Test that the open_categories setting has the desired effect.

    Verify that:
        - All categories are listed when they are defined in the
          completion.open_categories list.
    """
    config_stub.val.url.searchengines = {
        "DEFAULT": "https://duckduckgo.com/?q={}",
        "google": "https://google.com/?q={}",
    }
    config_stub.val.completion.open_categories = [
        "searchengines",
        "quickmarks",
        "bookmarks",
        "history",
    ]
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Search engines": [
            ('google', 'https://google.com/?q={}', None),
        ],
        "Quickmarks": [
            ('https://wiki.archlinux.org', 'aw', None),
            ('https://wikipedia.org', 'wiki', None),
            ('https://duckduckgo.com', 'ddg', None),
        ],
        "Bookmarks": [
            ('https://github.com', 'GitHub', None),
            ('https://python.org', 'Welcome to Python.org', None),
            ('http://qutebrowser.org', 'qutebrowser | qutebrowser', None),
        ],
        "History": [
            ('https://github.com', 'https://github.com', '2016-05-01'),
            ('https://python.org', 'Welcome to Python.org', '2016-03-08'),
            ('http://qutebrowser.org', 'qutebrowser', '2015-09-05'),
        ],
    })


def test_open_categories_remove_all(qtmodeltester, config_stub, web_history_populated,
                                    quickmarks, bookmarks, info):
    """Test removing all items from open_categories."""
    config_stub.val.url.searchengines = {
        "DEFAULT": "https://duckduckgo.com/?q={}",
        "google": "https://google.com/?q={}",
    }
    config_stub.val.completion.open_categories = []
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {})


def test_open_categories_remove_one(qtmodeltester, config_stub, web_history_populated,
                                    quickmarks, bookmarks, info):
    """Test removing an item (boookmarks) from open_categories."""
    config_stub.val.url.searchengines = {
        "DEFAULT": "https://duckduckgo.com/?q={}",
        "google": "https://google.com/?q={}",
    }
    config_stub.val.completion.open_categories = [
        "searchengines", "quickmarks", "history"]
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Search engines": [
            ('google', 'https://google.com/?q={}', None),
        ],
        "Quickmarks": [
            ('https://wiki.archlinux.org', 'aw', None),
            ('https://wikipedia.org', 'wiki', None),
            ('https://duckduckgo.com', 'ddg', None),
        ],
        "History": [
            ('https://github.com', 'https://github.com', '2016-05-01'),
            ('https://python.org', 'Welcome to Python.org', '2016-03-08'),
            ('http://qutebrowser.org', 'qutebrowser', '2015-09-05'),
        ],
    })


@pytest.mark.parametrize('method', ['normal', 'url', 'home'])
def test_filesystem_completion(qtmodeltester, config_stub, info,
                               web_history_populated, quickmarks, bookmarks,
                               local_files_path, monkeypatch, method):
    file_1 = local_files_path / 'file1.txt'
    file_2 = local_files_path / 'file2.txt'

    if method == 'normal':
        base = str(local_files_path)
        expected_1 = str(file_1)
        expected_2 = str(file_2)
    elif method == 'url':
        base = local_files_path.as_uri()
        expected_1 = file_1.as_uri()
        expected_2 = file_2.as_uri()
    elif method == 'home':
        homedir = str(local_files_path)
        monkeypatch.setenv('HOME', homedir)  # POSIX
        monkeypatch.setenv('USERPROFILE', homedir)  # Windows
        assert str(pathlib.Path.home()) == homedir

        base = '~'
        expected_1 = str(pathlib.Path('~') / 'file1.txt')
        expected_2 = str(pathlib.Path('~') / 'file2.txt')
    else:
        raise utils.Unreachable(method)

    config_stub.val.completion.open_categories = ['filesystem']
    model = urlmodel.url(info=info)
    model.set_pattern(base + os.sep)
    qtmodeltester.check(model)

    _check_completions(model, {
        "Filesystem": [
            (expected_1, None, None),
            (expected_2, None, None),
        ]
    })


def test_filesystem_completion_model_interface(info, local_files_path):
    model = filepathcategory.FilePathCategory('filepaths')
    model.set_pattern(str(local_files_path) + os.sep)

    index = model.index(0, 0)
    assert index.isValid()
    assert model.rowCount(parent=index) == 0

    index2 = model.index(0, 5)
    assert not index2.isValid()
    assert model.data(index2) is None


@hypothesis.given(
    as_uri=hst.booleans(),
    add_sep=hst.booleans(),
    text=hst.text(),
)
def test_filesystem_completion_hypothesis(info, as_uri, add_sep, text):
    if as_uri:
        text = 'file:///' + text
    if add_sep:
        text += os.sep

    model = filepathcategory.FilePathCategory('filepaths')
    model.set_pattern(text)


@pytest.mark.parametrize('text', ['~\ud800', '~\x00'])
def test_filesystem_completion_corner_cases(info, text):
    model = filepathcategory.FilePathCategory('filepaths')
    model.set_pattern(text)


def test_default_filesystem_completion(qtmodeltester, config_stub, info,
                                       web_history_populated, quickmarks, bookmarks,
                                       local_files_path):
    config_stub.val.completion.open_categories = ['filesystem']
    config_stub.val.completion.favorite_paths = [str(local_files_path)]
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Filesystem": [(str(local_files_path), None, None)]
    })


def test_quickmark_completion(qtmodeltester, quickmarks):
    """Test the results of quickmark completion."""
    model = miscmodels.quickmark()
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Quickmarks": [
            ('aw', 'https://wiki.archlinux.org', None),
            ('wiki', 'https://wikipedia.org', None),
            ('ddg', 'https://duckduckgo.com', None),
        ]
    })


@pytest.mark.parametrize('row, removed', [
    (0, 'aw'),
    (1, 'wiki'),
    (2, 'ddg'),
])
def test_quickmark_completion_delete(qtmodeltester, quickmarks, row, removed):
    """Test deleting a quickmark from the quickmark completion model."""
    model = miscmodels.quickmark()
    model.set_pattern('')
    qtmodeltester.check(model)

    parent = model.index(0, 0)
    idx = model.index(row, 0, parent)

    before = set(quickmarks.marks.keys())
    model.delete_cur_item(idx)
    after = set(quickmarks.marks.keys())
    assert before.difference(after) == {removed}


def test_bookmark_completion(qtmodeltester, bookmarks):
    """Test the results of bookmark completion."""
    model = miscmodels.bookmark()
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Bookmarks": [
            ('https://github.com', 'GitHub', None),
            ('https://python.org', 'Welcome to Python.org', None),
            ('http://qutebrowser.org', 'qutebrowser | qutebrowser', None),
        ]
    })


@pytest.mark.parametrize('row, removed', [
    (0, 'https://github.com'),
    (1, 'https://python.org'),
    (2, 'http://qutebrowser.org'),
])
def test_bookmark_completion_delete(qtmodeltester, bookmarks, row, removed):
    """Test deleting a quickmark from the quickmark completion model."""
    model = miscmodels.bookmark()
    model.set_pattern('')
    qtmodeltester.check(model)

    parent = model.index(0, 0)
    idx = model.index(row, 0, parent)

    before = set(bookmarks.marks.keys())
    model.delete_cur_item(idx)
    after = set(bookmarks.marks.keys())
    assert before.difference(after) == {removed}


def test_url_completion(qtmodeltester, config_stub, web_history_populated,
                        quickmarks, bookmarks, info):
    """Test the results of url completion.

    Verify that:
        - searchengines, quickmarks, bookmarks, and urls are included
        - default search engine is not displayed
        - entries are sorted by access time
        - only the most recent entry is included for each url
    """
    config_stub.val.completion.open_categories = [
        "searchengines",
        "quickmarks",
        "bookmarks",
        "history",
    ]
    config_stub.val.url.searchengines = {
        "DEFAULT": "https://duckduckgo.com/?q={}",
        "google": "https://google.com/?q={}"
    }
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Search engines": [
            ('google', 'https://google.com/?q={}', None),
        ],
        "Quickmarks": [
            ('https://wiki.archlinux.org', 'aw', None),
            ('https://wikipedia.org', 'wiki', None),
            ('https://duckduckgo.com', 'ddg', None),
        ],
        "Bookmarks": [
            ('https://github.com', 'GitHub', None),
            ('https://python.org', 'Welcome to Python.org', None),
            ('http://qutebrowser.org', 'qutebrowser | qutebrowser', None),
        ],
        "History": [
            ('https://github.com', 'https://github.com', '2016-05-01'),
            ('https://python.org', 'Welcome to Python.org', '2016-03-08'),
            ('http://qutebrowser.org', 'qutebrowser', '2015-09-05'),
        ],
    })


def test_search_only_default(qtmodeltester, config_stub, web_history_populated,
                             quickmarks, bookmarks, info):
    """Test that search engines are not shown with only the default engine."""
    config_stub.val.completion.open_categories = [
        "searchengines",
        "quickmarks",
        "bookmarks",
        "history",
    ]
    config_stub.val.url.searchengines = {
        "DEFAULT": "https://duckduckgo.com/?q={}",
    }
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Quickmarks": [
            ('https://wiki.archlinux.org', 'aw', None),
            ('https://wikipedia.org', 'wiki', None),
            ('https://duckduckgo.com', 'ddg', None),
        ],
        "Bookmarks": [
            ('https://github.com', 'GitHub', None),
            ('https://python.org', 'Welcome to Python.org', None),
            ('http://qutebrowser.org', 'qutebrowser | qutebrowser', None),
        ],
        "History": [
            ('https://github.com', 'https://github.com', '2016-05-01'),
            ('https://python.org', 'Welcome to Python.org', '2016-03-08'),
            ('http://qutebrowser.org', 'qutebrowser', '2015-09-05'),
        ],
    })


def test_url_completion_no_quickmarks(qtmodeltester, web_history_populated,
                                      quickmark_manager_stub, bookmarks, info):
    """Test that the quickmark category is gone with no quickmarks."""
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Bookmarks": [
            ('https://github.com', 'GitHub', None),
            ('https://python.org', 'Welcome to Python.org', None),
            ('http://qutebrowser.org', 'qutebrowser | qutebrowser', None),
        ],
        "History": [
            ('https://github.com', 'https://github.com', '2016-05-01'),
            ('https://python.org', 'Welcome to Python.org', '2016-03-08'),
            ('http://qutebrowser.org', 'qutebrowser', '2015-09-05'),
        ],
        'Filesystem': [],
    })


def test_url_completion_no_bookmarks(qtmodeltester, web_history_populated,
                                     quickmarks, bookmark_manager_stub, info):
    """Test that the bookmarks category is gone with no bookmarks."""
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Quickmarks": [
            ('https://wiki.archlinux.org', 'aw', None),
            ('https://wikipedia.org', 'wiki', None),
            ('https://duckduckgo.com', 'ddg', None),
        ],
        "History": [
            ('https://github.com', 'https://github.com', '2016-05-01'),
            ('https://python.org', 'Welcome to Python.org', '2016-03-08'),
            ('http://qutebrowser.org', 'qutebrowser', '2015-09-05'),
        ],
        'Filesystem': [],
    })


@pytest.mark.parametrize('url, title, pattern, rowcount', [
    ('example.com', 'Site Title', '', 1),
    ('example.com', 'Site Title', 'ex', 1),
    ('example.com', 'Site Title', 'am', 1),
    ('example.com', 'Site Title', 'com', 1),
    ('example.com', 'Site Title', 'ex com', 1),
    ('example.com', 'Site Title', 'com ex', 1),
    ('example.com', 'Site Title', 'ex foo', 0),
    ('example.com', 'Site Title', 'foo com', 0),
    ('example.com', 'Site Title', 'exm', 0),
    ('example.com', 'Site Title', 'Si Ti', 1),
    ('example.com', 'Site Title', 'Ti Si', 1),
    ('example.com', '', 'foo', 0),
    ('foo_bar', '', '_', 1),
    ('foobar', '', '_', 0),
    ('foo%bar', '', '%', 1),
    ('foobar', '', '%', 0),
])
def test_url_completion_pattern(web_history, quickmark_manager_stub,
                                bookmark_manager_stub, info,
                                url, title, pattern, rowcount):
    """Test that url completion filters by url and title."""
    web_history.add_url(QUrl(url), title)
    model = urlmodel.url(info=info)
    model.set_pattern(pattern)
    # 2, 0 is History
    assert model.rowCount(model.index(0, 0)) == rowcount


def test_url_completion_delete_bookmark(qtmodeltester, bookmarks,
                                        web_history, quickmarks, info):
    """Test deleting a bookmark from the url completion model."""
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    parent = model.index(1, 0)
    idx = model.index(1, 0, parent)

    # sanity checks
    assert model.data(parent) == "Bookmarks"
    assert model.data(idx) == 'https://python.org'
    assert 'https://github.com' in bookmarks.marks

    len_before = len(bookmarks.marks)
    model.delete_cur_item(idx)
    assert 'https://python.org' not in bookmarks.marks
    assert len_before == len(bookmarks.marks) + 1


def test_url_completion_delete_quickmark(qtmodeltester, info, qtbot,
                                         quickmarks, web_history, bookmarks):
    """Test deleting a bookmark from the url completion model."""
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    parent = model.index(0, 0)
    idx = model.index(0, 0, parent)

    # sanity checks
    assert model.data(parent) == "Quickmarks"
    assert model.data(idx) == 'https://wiki.archlinux.org'
    assert 'ddg' in quickmarks.marks

    len_before = len(quickmarks.marks)
    model.delete_cur_item(idx)
    assert 'aw' not in quickmarks.marks
    assert len_before == len(quickmarks.marks) + 1


def test_url_completion_delete_history(qtmodeltester, info,
                                       web_history_populated,
                                       quickmarks, bookmarks):
    """Test deleting a history entry."""
    model = urlmodel.url(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    parent = model.index(2, 0)
    idx = model.index(1, 0, parent)

    # sanity checks
    assert model.data(parent) == "History"
    assert model.data(idx) == 'https://python.org'

    assert 'https://python.org' in web_history_populated
    model.delete_cur_item(idx)
    assert 'https://python.org' not in web_history_populated


def test_url_completion_zero_limit(config_stub, web_history, quickmarks, info,
                                   bookmarks):
    """Make sure there's no history if the limit was set to zero."""
    config_stub.val.completion.web_history.max_items = 0
    config_stub.val.completion.open_categories = [
        "searchengines",
        "quickmarks",
        "bookmarks",
        "history",
    ]
    config_stub.val.url.searchengines = {
        "DEFAULT": "https://duckduckgo.com/?q={}",
        "google": "https://google.com/?q={}",
    }
    model = urlmodel.url(info=info)
    model.set_pattern('')
    category = model.index(3, 0)  # "History" normally
    assert model.data(category) is None


def test_session_completion(qtmodeltester, session_manager_stub):
    session_manager_stub.sessions = ['default', '1', '2']
    model = miscmodels.session()
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Sessions": [('1', None, None),
                     ('2', None, None),
                     ('default', None, None)]
    })


def test_tab_completion(qtmodeltester, fake_web_tab, win_registry,
                        tabbed_browser_stubs):
    tabbed_browser_stubs[0].widget.tabs = [
        fake_web_tab(QUrl('https://github.com'), 'GitHub', 0),
        fake_web_tab(QUrl('https://wikipedia.org'), 'Wikipedia', 1),
        fake_web_tab(QUrl('https://duckduckgo.com'), 'DuckDuckGo', 2),
    ]
    tabbed_browser_stubs[1].widget.tabs = [
        fake_web_tab(QUrl('https://wiki.archlinux.org'), 'ArchWiki', 0),
    ]
    model = miscmodels.tabs()
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        '0': [
            ('0/1', 'https://github.com', 'GitHub'),
            ('0/2', 'https://wikipedia.org', 'Wikipedia'),
            ('0/3', 'https://duckduckgo.com', 'DuckDuckGo')
        ],
        '1': [
            ('1/1', 'https://wiki.archlinux.org', 'ArchWiki'),
        ]
    })


def test_tab_completion_delete(qtmodeltester, fake_web_tab, win_registry,
                               tabbed_browser_stubs):
    """Verify closing a tab by deleting it from the completion widget."""
    tabbed_browser_stubs[0].widget.tabs = [
        fake_web_tab(QUrl('https://github.com'), 'GitHub', 0),
        fake_web_tab(QUrl('https://wikipedia.org'), 'Wikipedia', 1),
        fake_web_tab(QUrl('https://duckduckgo.com'), 'DuckDuckGo', 2)
    ]
    tabbed_browser_stubs[1].widget.tabs = [
        fake_web_tab(QUrl('https://wiki.archlinux.org'), 'ArchWiki', 0),
    ]
    model = miscmodels.tabs()
    model.set_pattern('')
    qtmodeltester.check(model)

    parent = model.index(0, 0)
    idx = model.index(1, 0, parent)

    # sanity checks
    assert model.data(parent) == "0"
    assert model.data(idx) == '0/2'

    model.delete_cur_item(idx)
    actual = [tab.url() for tab in tabbed_browser_stubs[0].widget.tabs]
    assert actual == [QUrl('https://github.com'),
                      QUrl('https://duckduckgo.com')]


def test_tab_focus_completion_delete(qtmodeltester, fake_web_tab, win_registry,
                              tabbed_browser_stubs, info):
    """Verify closing a tab by deleting it from the completion widget."""
    tabbed_browser_stubs[0].widget.tabs = [
        fake_web_tab(QUrl('https://github.com'), 'GitHub', 0),
        fake_web_tab(QUrl('https://wikipedia.org'), 'Wikipedia', 1),
        fake_web_tab(QUrl('https://duckduckgo.com'), 'DuckDuckGo', 2)
    ]
    tabbed_browser_stubs[1].widget.tabs = [
        fake_web_tab(QUrl('https://wiki.archlinux.org'), 'ArchWiki', 0),
    ]
    model = miscmodels.tab_focus(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    parent = model.index(0, 0)
    idx = model.index(1, 0, parent)

    # sanity checks
    assert model.data(parent) == "Tabs"
    assert model.data(idx) == '2'

    model.delete_cur_item(idx)
    actual = [tab.url() for tab in tabbed_browser_stubs[0].widget.tabs]
    assert actual == [QUrl('https://github.com'),
                      QUrl('https://duckduckgo.com')]


def test_tab_completion_not_sorted(qtmodeltester, fake_web_tab, win_registry,
                                   tabbed_browser_stubs):
    """Ensure that the completion row order is the same as tab index order.

    Would be violated for more than 9 tabs if the completion was being
    alphabetically sorted on the first column, or the others.
    """
    expected = []
    for idx in range(1, 11):
        url = "".join(random.sample(string.ascii_letters, 12))
        title = "".join(random.sample(string.ascii_letters, 12))
        expected.append(("0/{}".format(idx), url, title))

    tabbed_browser_stubs[0].widget.tabs = [
        fake_web_tab(QUrl(tab[1]), tab[2], idx)
        for idx, tab in enumerate(expected)
    ]
    model = miscmodels.tabs()
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        '0': expected,
        '1': [],
    })


def test_tab_completion_tabs_are_windows(qtmodeltester, fake_web_tab,
                                         win_registry, tabbed_browser_stubs,
                                         config_stub):
    """Verify tabs across all windows are listed under a single category."""
    tabbed_browser_stubs[0].widget.tabs = [
        fake_web_tab(QUrl('https://github.com'), 'GitHub', 0),
        fake_web_tab(QUrl('https://wikipedia.org'), 'Wikipedia', 1),
        fake_web_tab(QUrl('https://duckduckgo.com'), 'DuckDuckGo', 2),
    ]
    tabbed_browser_stubs[1].widget.tabs = [
        fake_web_tab(QUrl('https://wiki.archlinux.org'), 'ArchWiki', 0),
    ]

    config_stub.val.tabs.tabs_are_windows = True
    model = miscmodels.tabs()
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        'Windows': [
            ('0/1', 'https://github.com', 'GitHub'),
            ('0/2', 'https://wikipedia.org', 'Wikipedia'),
            ('0/3', 'https://duckduckgo.com', 'DuckDuckGo'),
            ('1/1', 'https://wiki.archlinux.org', 'ArchWiki'),
        ]
    })


def test_other_tabs_completion(qtmodeltester, fake_web_tab, win_registry,
                               tabbed_browser_stubs, info):
    tabbed_browser_stubs[0].widget.tabs = [
        fake_web_tab(QUrl('https://github.com'), 'GitHub', 0),
        fake_web_tab(QUrl('https://wikipedia.org'), 'Wikipedia', 1),
        fake_web_tab(QUrl('https://duckduckgo.com'), 'DuckDuckGo', 2),
    ]
    tabbed_browser_stubs[1].widget.tabs = [
        fake_web_tab(QUrl('https://wiki.archlinux.org'), 'ArchWiki', 0),
    ]
    info.win_id = 1
    model = miscmodels.other_tabs(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        '0': [
            ('0/1', 'https://github.com', 'GitHub'),
            ('0/2', 'https://wikipedia.org', 'Wikipedia'),
            ('0/3', 'https://duckduckgo.com', 'DuckDuckGo')
        ],
    })


def test_other_tabs_completion_id0(qtmodeltester, fake_web_tab,
                                   win_registry, tabbed_browser_stubs, info):
    tabbed_browser_stubs[0].widget.tabs = [
        fake_web_tab(QUrl('https://github.com'), 'GitHub', 0),
        fake_web_tab(QUrl('https://wikipedia.org'), 'Wikipedia', 1),
        fake_web_tab(QUrl('https://duckduckgo.com'), 'DuckDuckGo', 2),
    ]
    tabbed_browser_stubs[1].widget.tabs = [
        fake_web_tab(QUrl('https://wiki.archlinux.org'), 'ArchWiki', 0),
    ]
    info.win_id = 0
    model = miscmodels.other_tabs(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        '1': [
            ('1/1', 'https://wiki.archlinux.org', 'ArchWiki'),
        ],
    })


def test_tab_focus_completion(qtmodeltester, fake_web_tab, win_registry,
                              tabbed_browser_stubs, info):
    tabbed_browser_stubs[0].widget.tabs = [
        fake_web_tab(QUrl('https://github.com'), 'GitHub', 0),
        fake_web_tab(QUrl('https://wikipedia.org'), 'Wikipedia', 1),
        fake_web_tab(QUrl('https://duckduckgo.com'), 'DuckDuckGo', 2),
    ]
    tabbed_browser_stubs[1].widget.tabs = [
        fake_web_tab(QUrl('https://wiki.archlinux.org'), 'ArchWiki', 0),
    ]
    info.win_id = 1
    model = miscmodels.tab_focus(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        'Tabs': [
            ('1', 'https://wiki.archlinux.org', 'ArchWiki'),
        ],
        'Special': [
            ("last",
             "Focus the last-focused tab",
             None),

            ("stack-next",
             "Go forward through a stack of focused tabs",
             None),

            ("stack-prev",
             "Go backward through a stack of focused tabs",
             None),
        ]
    })


def test_window_completion(qtmodeltester, fake_web_tab, tabbed_browser_stubs,
                           info):
    tabbed_browser_stubs[0].widget.tabs = [
        fake_web_tab(QUrl('https://github.com'), 'GitHub', 0),
        fake_web_tab(QUrl('https://wikipedia.org'), 'Wikipedia', 1),
        fake_web_tab(QUrl('https://duckduckgo.com'), 'DuckDuckGo', 2)
    ]
    tabbed_browser_stubs[1].widget.tabs = [
        fake_web_tab(QUrl('https://wiki.archlinux.org'), 'ArchWiki', 0)
    ]

    info.win_id = 1
    model = miscmodels.window(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        'Windows': [
            ('0', 'window title - qutebrowser',
             'GitHub, Wikipedia, DuckDuckGo'),
        ]
    })


def test_setting_option_completion(qtmodeltester, config_stub,
                                   configdata_stub, info):
    model = configmodel.option(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Options": [
            ('aliases', 'Aliases for commands.', '{"q": "quit"}'),
            ('bindings.commands', 'Custom keybindings', (
                '{"normal": {"<Ctrl+q>": "quit", "I": "invalid", '
                '"ZQ": "quit", "d": "scroll down"}}')),
            ('completion.open_categories', 'Which categories to show (in '
             'which order) in the :open completion.',
             '["searchengines", "quickmarks", "bookmarks", "history"]'),
            ('content.javascript.enabled', 'Enable/Disable JavaScript',
             'true'),
            ('url.searchengines', 'searchengines list',
             '{"DEFAULT": "https://duckduckgo.com/?q={}", '
             '"google": "https://google.com/?q={}"}'),
        ]
    })


def test_setting_dict_option_completion(qtmodeltester, config_stub,
                                        configdata_stub, info):
    model = configmodel.dict_option(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Dict options": [
            ('aliases', 'Aliases for commands.', '{"q": "quit"}'),
            ('bindings.commands', 'Custom keybindings', (
                '{"normal": {"<Ctrl+q>": "quit", "I": "invalid", '
                '"ZQ": "quit", "d": "scroll down"}}')),
            ('url.searchengines', 'searchengines list',
             '{"DEFAULT": "https://duckduckgo.com/?q={}", '
             '"google": "https://google.com/?q={}"}'),
        ]
    })


def test_setting_list_option_completion(qtmodeltester, config_stub,
                                        configdata_stub, info):
    model = configmodel.list_option(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "List options": [
            ('completion.open_categories', 'Which categories to show (in '
             'which order) in the :open completion.',
             '["searchengines", "quickmarks", "bookmarks", "history"]'),
        ]
    })


def test_setting_customized_option_completion(qtmodeltester, config_stub,
                                              configdata_stub, info):
    info.config.set_obj('aliases', {'foo': 'nop'})

    model = configmodel.customized_option(info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Customized options": [
            ('aliases', 'Aliases for commands.', '{"foo": "nop"}'),
        ]
    })


def test_setting_value_completion(qtmodeltester, config_stub, configdata_stub,
                                  info):
    model = configmodel.value(optname='content.javascript.enabled', info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Current/Default": [
            ('true', 'Current value', None),
            ('true', 'Default value', None),
        ],
        "Completions": [
            ('false', '', None),
            ('true', '', None),
        ],
    })


def test_setting_value_no_completions(qtmodeltester, config_stub,
                                      configdata_stub, info):
    model = configmodel.value(optname='aliases', info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Current/Default": [
            ('{"q": "quit"}', 'Current value', None),
            ('{"q": "quit"}', 'Default value', None),
        ],
    })


def test_setting_value_completion_invalid(info):
    assert configmodel.value(optname='foobarbaz', info=info) is None


@pytest.mark.parametrize('args, expected', [
    ([], {
        "Current/Default": [
            ('true', 'Current value', None),
            ('true', 'Default value', None),
        ],
        "Completions": [
            ('false', '', None),
            ('true', '', None),
        ],
    }),
    (['false'], {
        "Current/Default": [
            ('true', 'Current value', None),
            ('true', 'Default value', None),
        ],
        "Completions": [
            ('true', '', None),
        ],
    }),
    (['true'], {
        "Completions": [
            ('false', '', None),
        ],
    }),
    (['false', 'true'], {}),
])
def test_setting_value_cycle(qtmodeltester, config_stub, configdata_stub,
                             info, args, expected):
    opt = 'content.javascript.enabled'

    model = configmodel.value(opt, *args, info=info)
    model.set_pattern('')
    qtmodeltester.check(model)
    _check_completions(model, expected)


def test_bind_completion(qtmodeltester, cmdutils_stub, config_stub,
                         key_config_stub, configdata_stub, info):
    """Test the results of keybinding command completion.

    Validates that:
        - only non-deprecated commands are included
        - the command description is shown in the desc column
        - the binding (if any) is shown in the misc column
        - aliases are included
    """
    model = configmodel.bind('ZQ', info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Current/Default": [
            ('quit', '(Current) quit qutebrowser', 'ZQ'),
        ],
        "Commands": [
            ('open', 'open a url', ''),
            ('q', "Alias for 'quit'", ''),
            ('quit', 'quit qutebrowser', 'ZQ, <Ctrl+q>'),
            ('scroll', 'Scroll the current tab in the given direction.', ''),
            ('tab-close', 'Close the current tab.', ''),
        ],
    })


def test_bind_completion_invalid(cmdutils_stub, config_stub, key_config_stub,
                                 configdata_stub, info):
    """Test command completion with an invalid command bound."""
    model = configmodel.bind('I', info=info)
    model.set_pattern('')

    _check_completions(model, {
        "Current/Default": [
            ('invalid', '(Current) Invalid command!', 'I'),
        ],
        "Commands": [
            ('open', 'open a url', ''),
            ('q', "Alias for 'quit'", ''),
            ('quit', 'quit qutebrowser', 'ZQ, <Ctrl+q>'),
            ('scroll', 'Scroll the current tab in the given direction.', ''),
            ('tab-close', 'Close the current tab.', ''),
        ],
    })


def test_bind_completion_invalid_binding(cmdutils_stub, config_stub,
                                         key_config_stub, configdata_stub,
                                         info):
    """Test command completion with an invalid key binding."""
    model = configmodel.bind('<blub>', info=info)
    model.set_pattern('')

    _check_completions(model, {
        "Current/Default": [
            ('', "Could not parse '<blub>': Got invalid key!", '<blub>'),
        ],
        "Commands": [
            ('open', 'open a url', ''),
            ('q', "Alias for 'quit'", ''),
            ('quit', 'quit qutebrowser', 'ZQ, <Ctrl+q>'),
            ('scroll', 'Scroll the current tab in the given direction.', ''),
            ('tab-close', 'Close the current tab.', ''),
        ],
    })


def test_bind_completion_no_binding(qtmodeltester, cmdutils_stub, config_stub,
                                    key_config_stub, configdata_stub, info):
    """Test keybinding completion with no current or default binding."""
    model = configmodel.bind('x', info=info)
    model.set_pattern('')
    qtmodeltester.check(model)

    _check_completions(model, {
        "Commands": [
            ('open', 'open a url', ''),
            ('q', "Alias for 'quit'", ''),
            ('quit', 'quit qutebrowser', 'ZQ, <Ctrl+q>'),
            ('scroll', 'Scroll the current tab in the given direction.', ''),
            ('tab-close', 'Close the current tab.', ''),
        ],
    })


def test_bind_completion_changed(cmdutils_stub, config_stub, key_config_stub,
                                 configdata_stub, info):
    """Test command completion with a non-default command bound."""
    model = configmodel.bind('d', info=info)
    model.set_pattern('')

    _check_completions(model, {
        "Current/Default": [
            ('scroll down',
             '(Current) Scroll the current tab in the given direction.', 'd'),
            ('tab-close', '(Default) Close the current tab.', 'd'),
        ],
        "Commands": [
            ('open', 'open a url', ''),
            ('q', "Alias for 'quit'", ''),
            ('quit', 'quit qutebrowser', 'ZQ, <Ctrl+q>'),
            ('scroll', 'Scroll the current tab in the given direction.', ''),
            ('tab-close', 'Close the current tab.', ''),
        ],
    })


def test_url_completion_benchmark(benchmark, info,
                                  quickmark_manager_stub,
                                  bookmark_manager_stub,
                                  web_history):
    """Benchmark url completion."""
    r = range(100000)
    entries = {
        'last_atime': list(r),
        'url': ['http://example.com/{}'.format(i) for i in r],
        'title': ['title{}'.format(i) for i in r]
    }

    web_history.completion.insert_batch(entries)

    quickmark_manager_stub.marks = collections.OrderedDict([
        ('title{}'.format('a'*i), 'example.com/{}'.format(i))
        for i in range(1000)])

    bookmark_manager_stub.marks = collections.OrderedDict([
        ('example.com/{}'.format('a'*i), 'title{}'.format(i))
        for i in range(1000)])

    def bench():
        model = urlmodel.url(info=info)
        model.set_pattern('')
        model.set_pattern('e')
        model.set_pattern('ex')
        model.set_pattern('ex ')
        model.set_pattern('ex 1')
        model.set_pattern('ex 12')
        model.set_pattern('ex 123')
        model.set_pattern('zzzzz')  # no match

    benchmark(bench)


@pytest.fixture
def tab_with_history(fake_web_tab, tabbed_browser_stubs, info, monkeypatch):
    """Returns a fake tab with some fake history items."""
    pytest.importorskip('qutebrowser.qt.webenginewidgets')
    tab = fake_web_tab(QUrl('https://github.com'), 'GitHub', 0)
    current_idx = 2
    monkeypatch.setattr(
        tab.history, 'current_idx',
        lambda: current_idx,
    )

    history = []
    now = time.time()
    for url, title, ts in [
            ("http://example.com/index", "list of things", now),
            ("http://example.com/thing1", "thing1 detail", now+5),
            ("http://example.com/thing2", "thing2 detail", now+10),
            ("http://example.com/thing3", "thing3 detail", now+15),
            ("http://example.com/thing4", "thing4 detail", now+20),
    ]:
        entry = mock.Mock(spec=QWebEngineHistoryItem)
        entry.url.return_value = QUrl(url)
        entry.title.return_value = title
        dt = QDateTime.fromMSecsSinceEpoch(int(ts * 1000))
        entry.lastVisited.return_value = dt
        history.append(entry)
    tab.history._history = mock.Mock(spec=QWebEngineHistory)
    tab.history._history.items.return_value = history
    monkeypatch.setattr(
        tab.history, 'back_items',
        lambda *_args: (
            entry for idx, entry in enumerate(tab.history._history.items())
            if idx < current_idx
        ),
    )
    monkeypatch.setattr(
        tab.history, 'forward_items',
        lambda *_args: (
            entry for idx, entry in enumerate(tab.history._history.items())
            if idx > current_idx
        ),
    )

    tabbed_browser_stubs[0].widget.tabs = [tab]
    tabbed_browser_stubs[0].widget.current_index = 0

    info.cur_tab = tab
    return tab


def test_back_completion(tab_with_history, info):
    """Test back tab history completion."""
    model = miscmodels.back(info=info)
    model.set_pattern('')

    _check_completions(model, {
        "History": [
            ("1", "http://example.com/thing1", "thing1 detail"),
            ("0", "http://example.com/index", "list of things"),
        ],
    })


def test_forward_completion(tab_with_history, info):
    """Test forward tab history completion."""
    model = miscmodels.forward(info=info)
    model.set_pattern('')

    _check_completions(model, {
        "History": [
            ("3", "http://example.com/thing3", "thing3 detail"),
            ("4", "http://example.com/thing4", "thing4 detail"),
        ],
    })


def test_undo_completion(tabbed_browser_stubs, info):
    """Test :undo completion."""
    entry1 = tabbedbrowser._UndoEntry(url=QUrl('https://example.org/'),
                                      history=None, index=None, pinned=None,
                                      created_at=datetime(2020, 1, 1))
    entry2 = tabbedbrowser._UndoEntry(url=QUrl('https://example.com/'),
                                      history=None, index=None, pinned=None,
                                      created_at=datetime(2020, 1, 2))
    entry3 = tabbedbrowser._UndoEntry(url=QUrl('https://example.net/'),
                                      history=None, index=None, pinned=None,
                                      created_at=datetime(2020, 1, 2))

    # Most recently closed is at the end
    tabbed_browser_stubs[0].undo_stack = [
        [entry1],
        [entry2, entry3],
    ]

    model = miscmodels.undo(info=info)
    model.set_pattern('')

    # Most recently closed is at the top, indices are used like "-x" for the
    # undo stack.
    _check_completions(model, {
        "Closed tabs": [
            ("1",
             "https://example.com/, https://example.net/",
             "2020-01-02 00:00"),
            ("2",
             "https://example.org/",
             "2020-01-01 00:00"),
        ],
    })


def undo_completion_retains_sort_order(tabbed_browser_stubs, info):
    """Test :undo completion sort order with > 10 entries."""
    created_dt = datetime(2020, 1, 1)
    created_str = "2020-01-02 00:00"

    tabbed_browser_stubs[0].undo_stack = [
        tabbedbrowser._UndoEntry(
            url=QUrl(f'https://example.org/{idx}'),
            history=None, index=None, pinned=None,
            created_at=created_dt,
        )
        for idx in range(1, 11)
    ]

    model = miscmodels.undo(info=info)
    model.set_pattern('')

    expected = [
        (str(idx), f'https://example.org/{idx}', created_str)
        for idx in range(1, 11)
    ]
    _check_completions(model, {"Closed tabs": expected})


def test_process_completion(monkeypatch, stubs, info):
    monkeypatch.setattr(guiprocess, 'QProcess', stubs.FakeProcess)
    p1 = guiprocess.GUIProcess('testprocess')
    p2 = guiprocess.GUIProcess('testprocess')
    p3 = guiprocess.GUIProcess('editor')

    p1.pid = 1001
    p1.cmd = 'cmd1'
    p1.args = []
    p1.outcome.running = False
    p1.outcome.status = QProcess.ExitStatus.NormalExit
    p1.outcome.code = 0

    p2.pid = 1002
    p2.cmd = 'cmd2'
    p2.args = []
    p2.outcome.running = True

    p3.pid = 1003
    p3.cmd = 'cmd3'
    p3.args = []
    p3.outcome.running = False
    p3.outcome.status = QProcess.ExitStatus.NormalExit
    p3.outcome.code = 1

    monkeypatch.setattr(guiprocess, 'all_processes', {
        1001: p1,
        1002: p2,
        1003: p3,
        1004: None,  # cleaned up
    })

    model = miscmodels.process(info=info)
    model.set_pattern('')

    expected = {
        'Testprocess': [
            ('1002', 'running', 'cmd2'),
            ('1001', 'successful', 'cmd1'),
        ],
        'Editor': [
            ('1003', 'unsuccessful', 'cmd3'),
        ],
    }
    _check_completions(model, expected)


@hypothesis.given(text=hst.text())
def test_listcategory_hypothesis(text):
    """Make sure we can't produce invalid patterns."""
    cat = listcategory.ListCategory("test", [])
    cat.set_pattern(text)