Adding upstream version 3.0.43.upstream/3.0.43

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

21 files changed, 3361 insertions, 0 deletions

diff --git a/tests/test_async_generator.py b/tests/test_async_generator.py
new file mode 100644
index 0000000..8c95f8c
--- /dev/null
+++ b/tests/test_async_generator.py
@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from asyncio import run
+
+from prompt_toolkit.eventloop import generator_to_async_generator
+
+
+def _sync_generator():
+    yield 1
+    yield 10
+
+
+def test_generator_to_async_generator():
+    """
+    Test conversion of sync to async generator.
+    This should run the synchronous parts in a background thread.
+    """
+    async_gen = generator_to_async_generator(_sync_generator)
+
+    items = []
+
+    async def consume_async_generator():
+        async for item in async_gen:
+            items.append(item)
+
+    # Run the event loop until all items are collected.
+    run(consume_async_generator())
+    assert items == [1, 10]
diff --git a/tests/test_buffer.py b/tests/test_buffer.py
new file mode 100644
index 0000000..e636137
--- /dev/null
+++ b/tests/test_buffer.py
@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import pytest
+
+from prompt_toolkit.buffer import Buffer
+
+
+@pytest.fixture
+def _buffer():
+    buff = Buffer()
+    return buff
+
+
+def test_initial(_buffer):
+    assert _buffer.text == ""
+    assert _buffer.cursor_position == 0
+
+
+def test_insert_text(_buffer):
+    _buffer.insert_text("some_text")
+    assert _buffer.text == "some_text"
+    assert _buffer.cursor_position == len("some_text")
+
+
+def test_cursor_movement(_buffer):
+    _buffer.insert_text("some_text")
+    _buffer.cursor_left()
+    _buffer.cursor_left()
+    _buffer.cursor_left()
+    _buffer.cursor_right()
+    _buffer.insert_text("A")
+
+    assert _buffer.text == "some_teAxt"
+    assert _buffer.cursor_position == len("some_teA")
+
+
+def test_backspace(_buffer):
+    _buffer.insert_text("some_text")
+    _buffer.cursor_left()
+    _buffer.cursor_left()
+    _buffer.delete_before_cursor()
+
+    assert _buffer.text == "some_txt"
+    assert _buffer.cursor_position == len("some_t")
+
+
+def test_cursor_up(_buffer):
+    # Cursor up to a line thats longer.
+    _buffer.insert_text("long line1\nline2")
+    _buffer.cursor_up()
+
+    assert _buffer.document.cursor_position == 5
+
+    # Going up when already at the top.
+    _buffer.cursor_up()
+    assert _buffer.document.cursor_position == 5
+
+    # Going up to a line that's shorter.
+    _buffer.reset()
+    _buffer.insert_text("line1\nlong line2")
+
+    _buffer.cursor_up()
+    assert _buffer.document.cursor_position == 5
+
+
+def test_cursor_down(_buffer):
+    _buffer.insert_text("line1\nline2")
+    _buffer.cursor_position = 3
+
+    # Normally going down
+    _buffer.cursor_down()
+    assert _buffer.document.cursor_position == len("line1\nlin")
+
+    # Going down to a line that's shorter.
+    _buffer.reset()
+    _buffer.insert_text("long line1\na\nb")
+    _buffer.cursor_position = 3
+
+    _buffer.cursor_down()
+    assert _buffer.document.cursor_position == len("long line1\na")
+
+
+def test_join_next_line(_buffer):
+    _buffer.insert_text("line1\nline2\nline3")
+    _buffer.cursor_up()
+    _buffer.join_next_line()
+
+    assert _buffer.text == "line1\nline2 line3"
+
+    # Test when there is no '\n' in the text
+    _buffer.reset()
+    _buffer.insert_text("line1")
+    _buffer.cursor_position = 0
+    _buffer.join_next_line()
+
+    assert _buffer.text == "line1"
+
+
+def test_newline(_buffer):
+    _buffer.insert_text("hello world")
+    _buffer.newline()
+
+    assert _buffer.text == "hello world\n"
+
+
+def test_swap_characters_before_cursor(_buffer):
+    _buffer.insert_text("hello world")
+    _buffer.cursor_left()
+    _buffer.cursor_left()
+    _buffer.swap_characters_before_cursor()
+
+    assert _buffer.text == "hello wrold"
diff --git a/tests/test_cli.py b/tests/test_cli.py
new file mode 100644
index 0000000..3a16e9f
--- /dev/null
+++ b/tests/test_cli.py
@@ -0,0 +1,941 @@
+"""
+These are almost end-to-end tests. They create a Prompt, feed it with some
+input and check the result.
+"""
+from __future__ import annotations
+
+from functools import partial
+
+import pytest
+
+from prompt_toolkit.clipboard import ClipboardData, InMemoryClipboard
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.filters import ViInsertMode
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.input.defaults import create_pipe_input
+from prompt_toolkit.input.vt100_parser import ANSI_SEQUENCES
+from prompt_toolkit.key_binding.bindings.named_commands import prefix_meta
+from prompt_toolkit.key_binding.key_bindings import KeyBindings
+from prompt_toolkit.output import DummyOutput
+from prompt_toolkit.shortcuts import PromptSession
+
+
+def _history():
+    h = InMemoryHistory()
+    h.append_string("line1 first input")
+    h.append_string("line2 second input")
+    h.append_string("line3 third input")
+    return h
+
+
+def _feed_cli_with_input(
+    text,
+    editing_mode=EditingMode.EMACS,
+    clipboard=None,
+    history=None,
+    multiline=False,
+    check_line_ending=True,
+    key_bindings=None,
+):
+    """
+    Create a Prompt, feed it with the given user input and return the CLI
+    object.
+
+    This returns a (result, Application) tuple.
+    """
+    # If the given text doesn't end with a newline, the interface won't finish.
+    if check_line_ending:
+        assert text.endswith("\r")
+
+    with create_pipe_input() as inp:
+        inp.send_text(text)
+        session = PromptSession(
+            input=inp,
+            output=DummyOutput(),
+            editing_mode=editing_mode,
+            history=history,
+            multiline=multiline,
+            clipboard=clipboard,
+            key_bindings=key_bindings,
+        )
+
+        _ = session.prompt()
+        return session.default_buffer.document, session.app
+
+
+def test_simple_text_input():
+    # Simple text input, followed by enter.
+    result, cli = _feed_cli_with_input("hello\r")
+    assert result.text == "hello"
+    assert cli.current_buffer.text == "hello"
+
+
+def test_emacs_cursor_movements():
+    """
+    Test cursor movements with Emacs key bindings.
+    """
+    # ControlA (beginning-of-line)
+    result, cli = _feed_cli_with_input("hello\x01X\r")
+    assert result.text == "Xhello"
+
+    # ControlE (end-of-line)
+    result, cli = _feed_cli_with_input("hello\x01X\x05Y\r")
+    assert result.text == "XhelloY"
+
+    # ControlH or \b
+    result, cli = _feed_cli_with_input("hello\x08X\r")
+    assert result.text == "hellX"
+
+    # Delete.  (Left, left, delete)
+    result, cli = _feed_cli_with_input("hello\x1b[D\x1b[D\x1b[3~\r")
+    assert result.text == "helo"
+
+    # Left.
+    result, cli = _feed_cli_with_input("hello\x1b[DX\r")
+    assert result.text == "hellXo"
+
+    # ControlA, right
+    result, cli = _feed_cli_with_input("hello\x01\x1b[CX\r")
+    assert result.text == "hXello"
+
+    # ControlB (backward-char)
+    result, cli = _feed_cli_with_input("hello\x02X\r")
+    assert result.text == "hellXo"
+
+    # ControlF (forward-char)
+    result, cli = _feed_cli_with_input("hello\x01\x06X\r")
+    assert result.text == "hXello"
+
+    # ControlD: delete after cursor.
+    result, cli = _feed_cli_with_input("hello\x01\x04\r")
+    assert result.text == "ello"
+
+    # ControlD at the end of the input ssshould not do anything.
+    result, cli = _feed_cli_with_input("hello\x04\r")
+    assert result.text == "hello"
+
+    # Left, Left, ControlK  (kill-line)
+    result, cli = _feed_cli_with_input("hello\x1b[D\x1b[D\x0b\r")
+    assert result.text == "hel"
+
+    # Left, Left Esc- ControlK (kill-line, but negative)
+    result, cli = _feed_cli_with_input("hello\x1b[D\x1b[D\x1b-\x0b\r")
+    assert result.text == "lo"
+
+    # ControlL: should not influence the result.
+    result, cli = _feed_cli_with_input("hello\x0c\r")
+    assert result.text == "hello"
+
+    # ControlRight (forward-word)
+    result, cli = _feed_cli_with_input("hello world\x01X\x1b[1;5CY\r")
+    assert result.text == "XhelloY world"
+
+    # ContrlolLeft (backward-word)
+    result, cli = _feed_cli_with_input("hello world\x1b[1;5DY\r")
+    assert result.text == "hello Yworld"
+
+    # <esc>-f with argument. (forward-word)
+    result, cli = _feed_cli_with_input("hello world abc def\x01\x1b3\x1bfX\r")
+    assert result.text == "hello world abcX def"
+
+    # <esc>-f with negative argument. (forward-word)
+    result, cli = _feed_cli_with_input("hello world abc def\x1b-\x1b3\x1bfX\r")
+    assert result.text == "hello Xworld abc def"
+
+    # <esc>-b with argument. (backward-word)
+    result, cli = _feed_cli_with_input("hello world abc def\x1b3\x1bbX\r")
+    assert result.text == "hello Xworld abc def"
+
+    # <esc>-b with negative argument. (backward-word)
+    result, cli = _feed_cli_with_input("hello world abc def\x01\x1b-\x1b3\x1bbX\r")
+    assert result.text == "hello world abc Xdef"
+
+    # ControlW (kill-word / unix-word-rubout)
+    result, cli = _feed_cli_with_input("hello world\x17\r")
+    assert result.text == "hello "
+    assert cli.clipboard.get_data().text == "world"
+
+    result, cli = _feed_cli_with_input("test hello world\x1b2\x17\r")
+    assert result.text == "test "
+
+    # Escape Backspace (unix-word-rubout)
+    result, cli = _feed_cli_with_input("hello world\x1b\x7f\r")
+    assert result.text == "hello "
+    assert cli.clipboard.get_data().text == "world"
+
+    result, cli = _feed_cli_with_input("hello world\x1b\x08\r")
+    assert result.text == "hello "
+    assert cli.clipboard.get_data().text == "world"
+
+    # Backspace (backward-delete-char)
+    result, cli = _feed_cli_with_input("hello world\x7f\r")
+    assert result.text == "hello worl"
+    assert result.cursor_position == len("hello worl")
+
+    result, cli = _feed_cli_with_input("hello world\x08\r")
+    assert result.text == "hello worl"
+    assert result.cursor_position == len("hello worl")
+
+    # Delete (delete-char)
+    result, cli = _feed_cli_with_input("hello world\x01\x1b[3~\r")
+    assert result.text == "ello world"
+    assert result.cursor_position == 0
+
+    # Escape-\\ (delete-horizontal-space)
+    result, cli = _feed_cli_with_input("hello     world\x1b8\x02\x1b\\\r")
+    assert result.text == "helloworld"
+    assert result.cursor_position == len("hello")
+
+
+def test_emacs_kill_multiple_words_and_paste():
+    # Using control-w twice should place both words on the clipboard.
+    result, cli = _feed_cli_with_input(
+        "hello world test\x17\x17--\x19\x19\r"  # Twice c-w.  Twice c-y.
+    )
+    assert result.text == "hello --world testworld test"
+    assert cli.clipboard.get_data().text == "world test"
+
+    # Using alt-d twice should place both words on the clipboard.
+    result, cli = _feed_cli_with_input(
+        "hello world test"
+        "\x1bb\x1bb"  # Twice left.
+        "\x1bd\x1bd"  # Twice kill-word.
+        "abc"
+        "\x19"  # Paste.
+        "\r"
+    )
+    assert result.text == "hello abcworld test"
+    assert cli.clipboard.get_data().text == "world test"
+
+
+def test_interrupts():
+    # ControlC: raise KeyboardInterrupt.
+    with pytest.raises(KeyboardInterrupt):
+        result, cli = _feed_cli_with_input("hello\x03\r")
+
+    with pytest.raises(KeyboardInterrupt):
+        result, cli = _feed_cli_with_input("hello\x03\r")
+
+    # ControlD without any input: raises EOFError.
+    with pytest.raises(EOFError):
+        result, cli = _feed_cli_with_input("\x04\r")
+
+
+def test_emacs_yank():
+    # ControlY (yank)
+    c = InMemoryClipboard(ClipboardData("XYZ"))
+    result, cli = _feed_cli_with_input("hello\x02\x19\r", clipboard=c)
+    assert result.text == "hellXYZo"
+    assert result.cursor_position == len("hellXYZ")
+
+
+def test_quoted_insert():
+    # ControlQ - ControlB (quoted-insert)
+    result, cli = _feed_cli_with_input("hello\x11\x02\r")
+    assert result.text == "hello\x02"
+
+
+def test_transformations():
+    # Meta-c (capitalize-word)
+    result, cli = _feed_cli_with_input("hello world\01\x1bc\r")
+    assert result.text == "Hello world"
+    assert result.cursor_position == len("Hello")
+
+    # Meta-u (uppercase-word)
+    result, cli = _feed_cli_with_input("hello world\01\x1bu\r")
+    assert result.text == "HELLO world"
+    assert result.cursor_position == len("Hello")
+
+    # Meta-u (downcase-word)
+    result, cli = _feed_cli_with_input("HELLO WORLD\01\x1bl\r")
+    assert result.text == "hello WORLD"
+    assert result.cursor_position == len("Hello")
+
+    # ControlT (transpose-chars)
+    result, cli = _feed_cli_with_input("hello\x14\r")
+    assert result.text == "helol"
+    assert result.cursor_position == len("hello")
+
+    # Left, Left, Control-T (transpose-chars)
+    result, cli = _feed_cli_with_input("abcde\x1b[D\x1b[D\x14\r")
+    assert result.text == "abdce"
+    assert result.cursor_position == len("abcd")
+
+
+def test_emacs_other_bindings():
+    # Transpose characters.
+    result, cli = _feed_cli_with_input("abcde\x14X\r")  # Ctrl-T
+    assert result.text == "abcedX"
+
+    # Left, Left, Transpose. (This is slightly different.)
+    result, cli = _feed_cli_with_input("abcde\x1b[D\x1b[D\x14X\r")
+    assert result.text == "abdcXe"
+
+    # Clear before cursor.
+    result, cli = _feed_cli_with_input("hello\x1b[D\x1b[D\x15X\r")
+    assert result.text == "Xlo"
+
+    # unix-word-rubout: delete word before the cursor.
+    # (ControlW).
+    result, cli = _feed_cli_with_input("hello world test\x17X\r")
+    assert result.text == "hello world X"
+
+    result, cli = _feed_cli_with_input("hello world /some/very/long/path\x17X\r")
+    assert result.text == "hello world X"
+
+    # (with argument.)
+    result, cli = _feed_cli_with_input("hello world test\x1b2\x17X\r")
+    assert result.text == "hello X"
+
+    result, cli = _feed_cli_with_input("hello world /some/very/long/path\x1b2\x17X\r")
+    assert result.text == "hello X"
+
+    # backward-kill-word: delete word before the cursor.
+    # (Esc-ControlH).
+    result, cli = _feed_cli_with_input("hello world /some/very/long/path\x1b\x08X\r")
+    assert result.text == "hello world /some/very/long/X"
+
+    # (with arguments.)
+    result, cli = _feed_cli_with_input(
+        "hello world /some/very/long/path\x1b3\x1b\x08X\r"
+    )
+    assert result.text == "hello world /some/very/X"
+
+
+def test_controlx_controlx():
+    # At the end: go to the start of the line.
+    result, cli = _feed_cli_with_input("hello world\x18\x18X\r")
+    assert result.text == "Xhello world"
+    assert result.cursor_position == 1
+
+    # At the start: go to the end of the line.
+    result, cli = _feed_cli_with_input("hello world\x01\x18\x18X\r")
+    assert result.text == "hello worldX"
+
+    # Left, Left Control-X Control-X: go to the end of the line.
+    result, cli = _feed_cli_with_input("hello world\x1b[D\x1b[D\x18\x18X\r")
+    assert result.text == "hello worldX"
+
+
+def test_emacs_history_bindings():
+    # Adding a new item to the history.
+    history = _history()
+    result, cli = _feed_cli_with_input("new input\r", history=history)
+    assert result.text == "new input"
+    history.get_strings()[-1] == "new input"
+
+    # Go up in history, and accept the last item.
+    result, cli = _feed_cli_with_input("hello\x1b[A\r", history=history)
+    assert result.text == "new input"
+
+    # Esc< (beginning-of-history)
+    result, cli = _feed_cli_with_input("hello\x1b<\r", history=history)
+    assert result.text == "line1 first input"
+
+    # Esc> (end-of-history)
+    result, cli = _feed_cli_with_input(
+        "another item\x1b[A\x1b[a\x1b>\r", history=history
+    )
+    assert result.text == "another item"
+
+    # ControlUp (previous-history)
+    result, cli = _feed_cli_with_input("\x1b[1;5A\r", history=history)
+    assert result.text == "another item"
+
+    # Esc< ControlDown (beginning-of-history, next-history)
+    result, cli = _feed_cli_with_input("\x1b<\x1b[1;5B\r", history=history)
+    assert result.text == "line2 second input"
+
+
+def test_emacs_reverse_search():
+    history = _history()
+
+    # ControlR  (reverse-search-history)
+    result, cli = _feed_cli_with_input("\x12input\r\r", history=history)
+    assert result.text == "line3 third input"
+
+    # Hitting ControlR twice.
+    result, cli = _feed_cli_with_input("\x12input\x12\r\r", history=history)
+    assert result.text == "line2 second input"
+
+
+def test_emacs_arguments():
+    """
+    Test various combinations of arguments in Emacs mode.
+    """
+    # esc 4
+    result, cli = _feed_cli_with_input("\x1b4x\r")
+    assert result.text == "xxxx"
+
+    # esc 4 4
+    result, cli = _feed_cli_with_input("\x1b44x\r")
+    assert result.text == "x" * 44
+
+    # esc 4 esc 4
+    result, cli = _feed_cli_with_input("\x1b4\x1b4x\r")
+    assert result.text == "x" * 44
+
+    # esc - right (-1 position to the right, equals 1 to the left.)
+    result, cli = _feed_cli_with_input("aaaa\x1b-\x1b[Cbbbb\r")
+    assert result.text == "aaabbbba"
+
+    # esc - 3 right
+    result, cli = _feed_cli_with_input("aaaa\x1b-3\x1b[Cbbbb\r")
+    assert result.text == "abbbbaaa"
+
+    # esc - - - 3 right
+    result, cli = _feed_cli_with_input("aaaa\x1b---3\x1b[Cbbbb\r")
+    assert result.text == "abbbbaaa"
+
+
+def test_emacs_arguments_for_all_commands():
+    """
+    Test all Emacs commands with Meta-[0-9] arguments (both positive and
+    negative). No one should crash.
+    """
+    for key in ANSI_SEQUENCES:
+        # Ignore BracketedPaste. This would hang forever, because it waits for
+        # the end sequence.
+        if key != "\x1b[200~":
+            try:
+                # Note: we add an 'X' after the key, because Ctrl-Q (quoted-insert)
+                # expects something to follow. We add an additional \r, because
+                # Ctrl-R and Ctrl-S (reverse-search) expect that.
+                result, cli = _feed_cli_with_input("hello\x1b4" + key + "X\r\r")
+
+                result, cli = _feed_cli_with_input("hello\x1b-" + key + "X\r\r")
+            except KeyboardInterrupt:
+                # This exception should only be raised for Ctrl-C
+                assert key == "\x03"
+
+
+def test_emacs_kill_ring():
+    operations = (
+        # abc ControlA ControlK
+        "abc\x01\x0b"
+        # def ControlA ControlK
+        "def\x01\x0b"
+        # ghi ControlA ControlK
+        "ghi\x01\x0b"
+        # ControlY (yank)
+        "\x19"
+    )
+
+    result, cli = _feed_cli_with_input(operations + "\r")
+    assert result.text == "ghi"
+
+    result, cli = _feed_cli_with_input(operations + "\x1by\r")
+    assert result.text == "def"
+
+    result, cli = _feed_cli_with_input(operations + "\x1by\x1by\r")
+    assert result.text == "abc"
+
+    result, cli = _feed_cli_with_input(operations + "\x1by\x1by\x1by\r")
+    assert result.text == "ghi"
+
+
+def test_emacs_selection():
+    # Copy/paste empty selection should not do anything.
+    operations = (
+        "hello"
+        # Twice left.
+        "\x1b[D\x1b[D"
+        # Control-Space
+        "\x00"
+        # ControlW (cut)
+        "\x17"
+        # ControlY twice. (paste twice)
+        "\x19\x19\r"
+    )
+
+    result, cli = _feed_cli_with_input(operations)
+    assert result.text == "hello"
+
+    # Copy/paste one character.
+    operations = (
+        "hello"
+        # Twice left.
+        "\x1b[D\x1b[D"
+        # Control-Space
+        "\x00"
+        # Right.
+        "\x1b[C"
+        # ControlW (cut)
+        "\x17"
+        # ControlA (Home).
+        "\x01"
+        # ControlY (paste)
+        "\x19\r"
+    )
+
+    result, cli = _feed_cli_with_input(operations)
+    assert result.text == "lhelo"
+
+
+def test_emacs_insert_comment():
+    # Test insert-comment (M-#) binding.
+    result, cli = _feed_cli_with_input("hello\x1b#", check_line_ending=False)
+    assert result.text == "#hello"
+
+    result, cli = _feed_cli_with_input(
+        "hello\rworld\x1b#", check_line_ending=False, multiline=True
+    )
+    assert result.text == "#hello\n#world"
+
+
+def test_emacs_record_macro():
+    operations = (
+        "  "
+        "\x18("  # Start recording macro. C-X(
+        "hello"
+        "\x18)"  # Stop recording macro.
+        "  "
+        "\x18e"  # Execute macro.
+        "\x18e"  # Execute macro.
+        "\r"
+    )
+
+    result, cli = _feed_cli_with_input(operations)
+    assert result.text == "  hello  hellohello"
+
+
+def test_emacs_nested_macro():
+    "Test calling the macro within a macro."
+    # Calling a macro within a macro should take the previous recording (if one
+    # exists), not the one that is in progress.
+    operations = (
+        "\x18("  # Start recording macro. C-X(
+        "hello"
+        "\x18e"  # Execute macro.
+        "\x18)"  # Stop recording macro.
+        "\x18e"  # Execute macro.
+        "\r"
+    )
+
+    result, cli = _feed_cli_with_input(operations)
+    assert result.text == "hellohello"
+
+    operations = (
+        "\x18("  # Start recording macro. C-X(
+        "hello"
+        "\x18)"  # Stop recording macro.
+        "\x18("  # Start recording macro. C-X(
+        "\x18e"  # Execute macro.
+        "world"
+        "\x18)"  # Stop recording macro.
+        "\x01\x0b"  # Delete all (c-a c-k).
+        "\x18e"  # Execute macro.
+        "\r"
+    )
+
+    result, cli = _feed_cli_with_input(operations)
+    assert result.text == "helloworld"
+
+
+def test_prefix_meta():
+    # Test the prefix-meta command.
+    b = KeyBindings()
+    b.add("j", "j", filter=ViInsertMode())(prefix_meta)
+
+    result, cli = _feed_cli_with_input(
+        "hellojjIX\r", key_bindings=b, editing_mode=EditingMode.VI
+    )
+    assert result.text == "Xhello"
+
+
+def test_bracketed_paste():
+    result, cli = _feed_cli_with_input("\x1b[200~hello world\x1b[201~\r")
+    assert result.text == "hello world"
+
+    result, cli = _feed_cli_with_input("\x1b[200~hello\rworld\x1b[201~\x1b\r")
+    assert result.text == "hello\nworld"
+
+    # With \r\n endings.
+    result, cli = _feed_cli_with_input("\x1b[200~hello\r\nworld\x1b[201~\x1b\r")
+    assert result.text == "hello\nworld"
+
+    # With \n endings.
+    result, cli = _feed_cli_with_input("\x1b[200~hello\nworld\x1b[201~\x1b\r")
+    assert result.text == "hello\nworld"
+
+
+def test_vi_cursor_movements():
+    """
+    Test cursor movements with Vi key bindings.
+    """
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI)
+
+    result, cli = feed("\x1b\r")
+    assert result.text == ""
+    assert cli.editing_mode == EditingMode.VI
+
+    # Esc h a X
+    result, cli = feed("hello\x1bhaX\r")
+    assert result.text == "hellXo"
+
+    # Esc I X
+    result, cli = feed("hello\x1bIX\r")
+    assert result.text == "Xhello"
+
+    # Esc I X
+    result, cli = feed("hello\x1bIX\r")
+    assert result.text == "Xhello"
+
+    # Esc 2hiX
+    result, cli = feed("hello\x1b2hiX\r")
+    assert result.text == "heXllo"
+
+    # Esc 2h2liX
+    result, cli = feed("hello\x1b2h2liX\r")
+    assert result.text == "hellXo"
+
+    # Esc \b\b
+    result, cli = feed("hello\b\b\r")
+    assert result.text == "hel"
+
+    # Esc \b\b
+    result, cli = feed("hello\b\b\r")
+    assert result.text == "hel"
+
+    # Esc 2h D
+    result, cli = feed("hello\x1b2hD\r")
+    assert result.text == "he"
+
+    # Esc 2h rX \r
+    result, cli = feed("hello\x1b2hrX\r")
+    assert result.text == "heXlo"
+
+
+def test_vi_operators():
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI)
+
+    # Esc g~0
+    result, cli = feed("hello\x1bg~0\r")
+    assert result.text == "HELLo"
+
+    # Esc gU0
+    result, cli = feed("hello\x1bgU0\r")
+    assert result.text == "HELLo"
+
+    # Esc d0
+    result, cli = feed("hello\x1bd0\r")
+    assert result.text == "o"
+
+
+def test_vi_text_objects():
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI)
+
+    # Esc gUgg
+    result, cli = feed("hello\x1bgUgg\r")
+    assert result.text == "HELLO"
+
+    # Esc gUU
+    result, cli = feed("hello\x1bgUU\r")
+    assert result.text == "HELLO"
+
+    # Esc di(
+    result, cli = feed("before(inside)after\x1b8hdi(\r")
+    assert result.text == "before()after"
+
+    # Esc di[
+    result, cli = feed("before[inside]after\x1b8hdi[\r")
+    assert result.text == "before[]after"
+
+    # Esc da(
+    result, cli = feed("before(inside)after\x1b8hda(\r")
+    assert result.text == "beforeafter"
+
+
+def test_vi_digraphs():
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI)
+
+    # C-K o/
+    result, cli = feed("hello\x0bo/\r")
+    assert result.text == "helloø"
+
+    # C-K /o  (reversed input.)
+    result, cli = feed("hello\x0b/o\r")
+    assert result.text == "helloø"
+
+    # C-K e:
+    result, cli = feed("hello\x0be:\r")
+    assert result.text == "helloë"
+
+    # C-K xxy (Unknown digraph.)
+    result, cli = feed("hello\x0bxxy\r")
+    assert result.text == "helloy"
+
+
+def test_vi_block_editing():
+    "Test Vi Control-V style block insertion."
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI, multiline=True)
+
+    operations = (
+        # Six lines of text.
+        "-line1\r-line2\r-line3\r-line4\r-line5\r-line6"
+        # Go to the second character of the second line.
+        "\x1bkkkkkkkj0l"
+        # Enter Visual block mode.
+        "\x16"
+        # Go down two more lines.
+        "jj"
+        # Go 3 characters to the right.
+        "lll"
+        # Go to insert mode.
+        "insert"  # (Will be replaced.)
+        # Insert stars.
+        "***"
+        # Escape again.
+        "\x1b\r"
+    )
+
+    # Control-I
+    result, cli = feed(operations.replace("insert", "I"))
+
+    assert result.text == "-line1\n-***line2\n-***line3\n-***line4\n-line5\n-line6"
+
+    # Control-A
+    result, cli = feed(operations.replace("insert", "A"))
+
+    assert result.text == "-line1\n-line***2\n-line***3\n-line***4\n-line5\n-line6"
+
+
+def test_vi_block_editing_empty_lines():
+    "Test block editing on empty lines."
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI, multiline=True)
+
+    operations = (
+        # Six empty lines.
+        "\r\r\r\r\r"
+        # Go to beginning of the document.
+        "\x1bgg"
+        # Enter Visual block mode.
+        "\x16"
+        # Go down two more lines.
+        "jj"
+        # Go 3 characters to the right.
+        "lll"
+        # Go to insert mode.
+        "insert"  # (Will be replaced.)
+        # Insert stars.
+        "***"
+        # Escape again.
+        "\x1b\r"
+    )
+
+    # Control-I
+    result, cli = feed(operations.replace("insert", "I"))
+
+    assert result.text == "***\n***\n***\n\n\n"
+
+    # Control-A
+    result, cli = feed(operations.replace("insert", "A"))
+
+    assert result.text == "***\n***\n***\n\n\n"
+
+
+def test_vi_visual_line_copy():
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI, multiline=True)
+
+    operations = (
+        # Three lines of text.
+        "-line1\r-line2\r-line3\r-line4\r-line5\r-line6"
+        # Go to the second character of the second line.
+        "\x1bkkkkkkkj0l"
+        # Enter Visual linemode.
+        "V"
+        # Go down one line.
+        "j"
+        # Go 3 characters to the right (should not do much).
+        "lll"
+        # Copy this block.
+        "y"
+        # Go down one line.
+        "j"
+        # Insert block twice.
+        "2p"
+        # Escape again.
+        "\x1b\r"
+    )
+
+    result, cli = feed(operations)
+
+    assert (
+        result.text
+        == "-line1\n-line2\n-line3\n-line4\n-line2\n-line3\n-line2\n-line3\n-line5\n-line6"
+    )
+
+
+def test_vi_visual_empty_line():
+    """
+    Test edge case with an empty line in Visual-line mode.
+    """
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI, multiline=True)
+
+    # 1. Delete first two lines.
+    operations = (
+        # Three lines of text. The middle one is empty.
+        "hello\r\rworld"
+        # Go to the start.
+        "\x1bgg"
+        # Visual line and move down.
+        "Vj"
+        # Delete.
+        "d\r"
+    )
+    result, cli = feed(operations)
+    assert result.text == "world"
+
+    # 1. Delete middle line.
+    operations = (
+        # Three lines of text. The middle one is empty.
+        "hello\r\rworld"
+        # Go to middle line.
+        "\x1bggj"
+        # Delete line
+        "Vd\r"
+    )
+
+    result, cli = feed(operations)
+    assert result.text == "hello\nworld"
+
+
+def test_vi_character_delete_after_cursor():
+    "Test 'x' keypress."
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI, multiline=True)
+
+    # Delete one character.
+    result, cli = feed("abcd\x1bHx\r")
+    assert result.text == "bcd"
+
+    # Delete multiple character.s
+    result, cli = feed("abcd\x1bH3x\r")
+    assert result.text == "d"
+
+    # Delete on empty line.
+    result, cli = feed("\x1bo\x1bo\x1bggx\r")
+    assert result.text == "\n\n"
+
+    # Delete multiple on empty line.
+    result, cli = feed("\x1bo\x1bo\x1bgg10x\r")
+    assert result.text == "\n\n"
+
+    # Delete multiple on empty line.
+    result, cli = feed("hello\x1bo\x1bo\x1bgg3x\r")
+    assert result.text == "lo\n\n"
+
+
+def test_vi_character_delete_before_cursor():
+    "Test 'X' keypress."
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI, multiline=True)
+
+    # Delete one character.
+    result, cli = feed("abcd\x1bX\r")
+    assert result.text == "abd"
+
+    # Delete multiple character.
+    result, cli = feed("hello world\x1b3X\r")
+    assert result.text == "hello wd"
+
+    # Delete multiple character on multiple lines.
+    result, cli = feed("hello\x1boworld\x1bgg$3X\r")
+    assert result.text == "ho\nworld"
+
+    result, cli = feed("hello\x1boworld\x1b100X\r")
+    assert result.text == "hello\nd"
+
+    # Delete on empty line.
+    result, cli = feed("\x1bo\x1bo\x1b10X\r")
+    assert result.text == "\n\n"
+
+
+def test_vi_character_paste():
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI)
+
+    # Test 'p' character paste.
+    result, cli = feed("abcde\x1bhhxp\r")
+    assert result.text == "abdce"
+    assert result.cursor_position == 3
+
+    # Test 'P' character paste.
+    result, cli = feed("abcde\x1bhhxP\r")
+    assert result.text == "abcde"
+    assert result.cursor_position == 2
+
+
+def test_vi_temp_navigation_mode():
+    """
+    Test c-o binding: go for one action into navigation mode.
+    """
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI)
+
+    result, cli = feed("abcde" "\x0f" "3h" "x\r")  # c-o  # 3 times to the left.
+    assert result.text == "axbcde"
+    assert result.cursor_position == 2
+
+    result, cli = feed("abcde" "\x0f" "b" "x\r")  # c-o  # One word backwards.
+    assert result.text == "xabcde"
+    assert result.cursor_position == 1
+
+    # In replace mode
+    result, cli = feed(
+        "abcdef"
+        "\x1b"  # Navigation mode.
+        "0l"  # Start of line, one character to the right.
+        "R"  # Replace mode
+        "78"
+        "\x0f"  # c-o
+        "l"  # One character forwards.
+        "9\r"
+    )
+    assert result.text == "a78d9f"
+    assert result.cursor_position == 5
+
+
+def test_vi_macros():
+    feed = partial(_feed_cli_with_input, editing_mode=EditingMode.VI)
+
+    # Record and execute macro.
+    result, cli = feed("\x1bqcahello\x1bq@c\r")
+    assert result.text == "hellohello"
+    assert result.cursor_position == 9
+
+    # Running unknown macro.
+    result, cli = feed("\x1b@d\r")
+    assert result.text == ""
+    assert result.cursor_position == 0
+
+    # When a macro is called within a macro.
+    # It shouldn't result in eternal recursion.
+    result, cli = feed("\x1bqxahello\x1b@xq@x\r")
+    assert result.text == "hellohello"
+    assert result.cursor_position == 9
+
+    # Nested macros.
+    result, cli = feed(
+        # Define macro 'x'.
+        "\x1bqxahello\x1bq"
+        # Define macro 'y' which calls 'x'.
+        "qya\x1b@xaworld\x1bq"
+        # Delete line.
+        "2dd"
+        # Execute 'y'
+        "@y\r"
+    )
+
+    assert result.text == "helloworld"
+
+
+def test_accept_default():
+    """
+    Test `prompt(accept_default=True)`.
+    """
+    with create_pipe_input() as inp:
+        session = PromptSession(input=inp, output=DummyOutput())
+        result = session.prompt(default="hello", accept_default=True)
+        assert result == "hello"
+
+        # Test calling prompt() for a second time. (We had an issue where the
+        # prompt reset between calls happened at the wrong time, breaking this.)
+        result = session.prompt(default="world", accept_default=True)
+        assert result == "world"
diff --git a/tests/test_completion.py b/tests/test_completion.py
new file mode 100644
index 0000000..8b3541a
--- /dev/null
+++ b/tests/test_completion.py
@@ -0,0 +1,469 @@
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import tempfile
+from contextlib import contextmanager
+
+from prompt_toolkit.completion import (
+    CompleteEvent,
+    FuzzyWordCompleter,
+    NestedCompleter,
+    PathCompleter,
+    WordCompleter,
+    merge_completers,
+)
+from prompt_toolkit.document import Document
+
+
+@contextmanager
+def chdir(directory):
+    """Context manager for current working directory temporary change."""
+    orig_dir = os.getcwd()
+    os.chdir(directory)
+
+    try:
+        yield
+    finally:
+        os.chdir(orig_dir)
+
+
+def write_test_files(test_dir, names=None):
+    """Write test files in test_dir using the names list."""
+    names = names or range(10)
+    for i in names:
+        with open(os.path.join(test_dir, str(i)), "wb") as out:
+            out.write(b"")
+
+
+def test_pathcompleter_completes_in_current_directory():
+    completer = PathCompleter()
+    doc_text = ""
+    doc = Document(doc_text, len(doc_text))
+    event = CompleteEvent()
+    completions = list(completer.get_completions(doc, event))
+    assert len(completions) > 0
+
+
+def test_pathcompleter_completes_files_in_current_directory():
+    # setup: create a test dir with 10 files
+    test_dir = tempfile.mkdtemp()
+    write_test_files(test_dir)
+
+    expected = sorted(str(i) for i in range(10))
+
+    if not test_dir.endswith(os.path.sep):
+        test_dir += os.path.sep
+
+    with chdir(test_dir):
+        completer = PathCompleter()
+        # this should complete on the cwd
+        doc_text = ""
+        doc = Document(doc_text, len(doc_text))
+        event = CompleteEvent()
+        completions = list(completer.get_completions(doc, event))
+        result = sorted(c.text for c in completions)
+        assert expected == result
+
+    # cleanup
+    shutil.rmtree(test_dir)
+
+
+def test_pathcompleter_completes_files_in_absolute_directory():
+    # setup: create a test dir with 10 files
+    test_dir = tempfile.mkdtemp()
+    write_test_files(test_dir)
+
+    expected = sorted(str(i) for i in range(10))
+
+    test_dir = os.path.abspath(test_dir)
+    if not test_dir.endswith(os.path.sep):
+        test_dir += os.path.sep
+
+    completer = PathCompleter()
+    # force unicode
+    doc_text = str(test_dir)
+    doc = Document(doc_text, len(doc_text))
+    event = CompleteEvent()
+    completions = list(completer.get_completions(doc, event))
+    result = sorted(c.text for c in completions)
+    assert expected == result
+
+    # cleanup
+    shutil.rmtree(test_dir)
+
+
+def test_pathcompleter_completes_directories_with_only_directories():
+    # setup: create a test dir with 10 files
+    test_dir = tempfile.mkdtemp()
+    write_test_files(test_dir)
+
+    # create a sub directory there
+    os.mkdir(os.path.join(test_dir, "subdir"))
+
+    if not test_dir.endswith(os.path.sep):
+        test_dir += os.path.sep
+
+    with chdir(test_dir):
+        completer = PathCompleter(only_directories=True)
+        doc_text = ""
+        doc = Document(doc_text, len(doc_text))
+        event = CompleteEvent()
+        completions = list(completer.get_completions(doc, event))
+        result = [c.text for c in completions]
+        assert ["subdir"] == result
+
+    # check that there is no completion when passing a file
+    with chdir(test_dir):
+        completer = PathCompleter(only_directories=True)
+        doc_text = "1"
+        doc = Document(doc_text, len(doc_text))
+        event = CompleteEvent()
+        completions = list(completer.get_completions(doc, event))
+        assert [] == completions
+
+    # cleanup
+    shutil.rmtree(test_dir)
+
+
+def test_pathcompleter_respects_completions_under_min_input_len():
+    # setup: create a test dir with 10 files
+    test_dir = tempfile.mkdtemp()
+    write_test_files(test_dir)
+
+    # min len:1 and no text
+    with chdir(test_dir):
+        completer = PathCompleter(min_input_len=1)
+        doc_text = ""
+        doc = Document(doc_text, len(doc_text))
+        event = CompleteEvent()
+        completions = list(completer.get_completions(doc, event))
+        assert [] == completions
+
+    # min len:1 and text of len 1
+    with chdir(test_dir):
+        completer = PathCompleter(min_input_len=1)
+        doc_text = "1"
+        doc = Document(doc_text, len(doc_text))
+        event = CompleteEvent()
+        completions = list(completer.get_completions(doc, event))
+        result = [c.text for c in completions]
+        assert [""] == result
+
+    # min len:0 and text of len 2
+    with chdir(test_dir):
+        completer = PathCompleter(min_input_len=0)
+        doc_text = "1"
+        doc = Document(doc_text, len(doc_text))
+        event = CompleteEvent()
+        completions = list(completer.get_completions(doc, event))
+        result = [c.text for c in completions]
+        assert [""] == result
+
+    # create 10 files with a 2 char long name
+    for i in range(10):
+        with open(os.path.join(test_dir, str(i) * 2), "wb") as out:
+            out.write(b"")
+
+    # min len:1 and text of len 1
+    with chdir(test_dir):
+        completer = PathCompleter(min_input_len=1)
+        doc_text = "2"
+        doc = Document(doc_text, len(doc_text))
+        event = CompleteEvent()
+        completions = list(completer.get_completions(doc, event))
+        result = sorted(c.text for c in completions)
+        assert ["", "2"] == result
+
+    # min len:2 and text of len 1
+    with chdir(test_dir):
+        completer = PathCompleter(min_input_len=2)
+        doc_text = "2"
+        doc = Document(doc_text, len(doc_text))
+        event = CompleteEvent()
+        completions = list(completer.get_completions(doc, event))
+        assert [] == completions
+
+    # cleanup
+    shutil.rmtree(test_dir)
+
+
+def test_pathcompleter_does_not_expanduser_by_default():
+    completer = PathCompleter()
+    doc_text = "~"
+    doc = Document(doc_text, len(doc_text))
+    event = CompleteEvent()
+    completions = list(completer.get_completions(doc, event))
+    assert [] == completions
+
+
+def test_pathcompleter_can_expanduser():
+    completer = PathCompleter(expanduser=True)
+    doc_text = "~"
+    doc = Document(doc_text, len(doc_text))
+    event = CompleteEvent()
+    completions = list(completer.get_completions(doc, event))
+    assert len(completions) > 0
+
+
+def test_pathcompleter_can_apply_file_filter():
+    # setup: create a test dir with 10 files
+    test_dir = tempfile.mkdtemp()
+    write_test_files(test_dir)
+
+    # add a .csv file
+    with open(os.path.join(test_dir, "my.csv"), "wb") as out:
+        out.write(b"")
+
+    file_filter = lambda f: f and f.endswith(".csv")
+
+    with chdir(test_dir):
+        completer = PathCompleter(file_filter=file_filter)
+        doc_text = ""
+        doc = Document(doc_text, len(doc_text))
+        event = CompleteEvent()
+        completions = list(completer.get_completions(doc, event))
+        result = [c.text for c in completions]
+        assert ["my.csv"] == result
+
+    # cleanup
+    shutil.rmtree(test_dir)
+
+
+def test_pathcompleter_get_paths_constrains_path():
+    # setup: create a test dir with 10 files
+    test_dir = tempfile.mkdtemp()
+    write_test_files(test_dir)
+
+    # add a subdir with 10 other files with different names
+    subdir = os.path.join(test_dir, "subdir")
+    os.mkdir(subdir)
+    write_test_files(subdir, "abcdefghij")
+
+    get_paths = lambda: ["subdir"]
+
+    with chdir(test_dir):
+        completer = PathCompleter(get_paths=get_paths)
+        doc_text = ""
+        doc = Document(doc_text, len(doc_text))
+        event = CompleteEvent()
+        completions = list(completer.get_completions(doc, event))
+        result = [c.text for c in completions]
+        expected = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
+        assert expected == result
+
+    # cleanup
+    shutil.rmtree(test_dir)
+
+
+def test_word_completer_static_word_list():
+    completer = WordCompleter(["abc", "def", "aaa"])
+
+    # Static list on empty input.
+    completions = completer.get_completions(Document(""), CompleteEvent())
+    assert [c.text for c in completions] == ["abc", "def", "aaa"]
+
+    # Static list on non-empty input.
+    completions = completer.get_completions(Document("a"), CompleteEvent())
+    assert [c.text for c in completions] == ["abc", "aaa"]
+
+    completions = completer.get_completions(Document("A"), CompleteEvent())
+    assert [c.text for c in completions] == []
+
+    # Multiple words ending with space. (Accept all options)
+    completions = completer.get_completions(Document("test "), CompleteEvent())
+    assert [c.text for c in completions] == ["abc", "def", "aaa"]
+
+    # Multiple words. (Check last only.)
+    completions = completer.get_completions(Document("test a"), CompleteEvent())
+    assert [c.text for c in completions] == ["abc", "aaa"]
+
+
+def test_word_completer_ignore_case():
+    completer = WordCompleter(["abc", "def", "aaa"], ignore_case=True)
+    completions = completer.get_completions(Document("a"), CompleteEvent())
+    assert [c.text for c in completions] == ["abc", "aaa"]
+
+    completions = completer.get_completions(Document("A"), CompleteEvent())
+    assert [c.text for c in completions] == ["abc", "aaa"]
+
+
+def test_word_completer_match_middle():
+    completer = WordCompleter(["abc", "def", "abca"], match_middle=True)
+    completions = completer.get_completions(Document("bc"), CompleteEvent())
+    assert [c.text for c in completions] == ["abc", "abca"]
+
+
+def test_word_completer_sentence():
+    # With sentence=True
+    completer = WordCompleter(
+        ["hello world", "www", "hello www", "hello there"], sentence=True
+    )
+    completions = completer.get_completions(Document("hello w"), CompleteEvent())
+    assert [c.text for c in completions] == ["hello world", "hello www"]
+
+    # With sentence=False
+    completer = WordCompleter(
+        ["hello world", "www", "hello www", "hello there"], sentence=False
+    )
+    completions = completer.get_completions(Document("hello w"), CompleteEvent())
+    assert [c.text for c in completions] == ["www"]
+
+
+def test_word_completer_dynamic_word_list():
+    called = [0]
+
+    def get_words():
+        called[0] += 1
+        return ["abc", "def", "aaa"]
+
+    completer = WordCompleter(get_words)
+
+    # Dynamic list on empty input.
+    completions = completer.get_completions(Document(""), CompleteEvent())
+    assert [c.text for c in completions] == ["abc", "def", "aaa"]
+    assert called[0] == 1
+
+    # Static list on non-empty input.
+    completions = completer.get_completions(Document("a"), CompleteEvent())
+    assert [c.text for c in completions] == ["abc", "aaa"]
+    assert called[0] == 2
+
+
+def test_word_completer_pattern():
+    # With a pattern which support '.'
+    completer = WordCompleter(
+        ["abc", "a.b.c", "a.b", "xyz"],
+        pattern=re.compile(r"^([a-zA-Z0-9_.]+|[^a-zA-Z0-9_.\s]+)"),
+    )
+    completions = completer.get_completions(Document("a."), CompleteEvent())
+    assert [c.text for c in completions] == ["a.b.c", "a.b"]
+
+    # Without pattern
+    completer = WordCompleter(["abc", "a.b.c", "a.b", "xyz"])
+    completions = completer.get_completions(Document("a."), CompleteEvent())
+    assert [c.text for c in completions] == []
+
+
+def test_fuzzy_completer():
+    collection = [
+        "migrations.py",
+        "django_migrations.py",
+        "django_admin_log.py",
+        "api_user.doc",
+        "user_group.doc",
+        "users.txt",
+        "accounts.txt",
+        "123.py",
+        "test123test.py",
+    ]
+    completer = FuzzyWordCompleter(collection)
+    completions = completer.get_completions(Document("txt"), CompleteEvent())
+    assert [c.text for c in completions] == ["users.txt", "accounts.txt"]
+
+    completions = completer.get_completions(Document("djmi"), CompleteEvent())
+    assert [c.text for c in completions] == [
+        "django_migrations.py",
+        "django_admin_log.py",
+    ]
+
+    completions = completer.get_completions(Document("mi"), CompleteEvent())
+    assert [c.text for c in completions] == [
+        "migrations.py",
+        "django_migrations.py",
+        "django_admin_log.py",
+    ]
+
+    completions = completer.get_completions(Document("user"), CompleteEvent())
+    assert [c.text for c in completions] == [
+        "user_group.doc",
+        "users.txt",
+        "api_user.doc",
+    ]
+
+    completions = completer.get_completions(Document("123"), CompleteEvent())
+    assert [c.text for c in completions] == ["123.py", "test123test.py"]
+
+    completions = completer.get_completions(Document("miGr"), CompleteEvent())
+    assert [c.text for c in completions] == [
+        "migrations.py",
+        "django_migrations.py",
+    ]
+
+    # Multiple words ending with space. (Accept all options)
+    completions = completer.get_completions(Document("test "), CompleteEvent())
+    assert [c.text for c in completions] == collection
+
+    # Multiple words. (Check last only.)
+    completions = completer.get_completions(Document("test txt"), CompleteEvent())
+    assert [c.text for c in completions] == ["users.txt", "accounts.txt"]
+
+
+def test_nested_completer():
+    completer = NestedCompleter.from_nested_dict(
+        {
+            "show": {
+                "version": None,
+                "clock": None,
+                "interfaces": None,
+                "ip": {"interface": {"brief"}},
+            },
+            "exit": None,
+        }
+    )
+
+    # Empty input.
+    completions = completer.get_completions(Document(""), CompleteEvent())
+    assert {c.text for c in completions} == {"show", "exit"}
+
+    # One character.
+    completions = completer.get_completions(Document("s"), CompleteEvent())
+    assert {c.text for c in completions} == {"show"}
+
+    # One word.
+    completions = completer.get_completions(Document("show"), CompleteEvent())
+    assert {c.text for c in completions} == {"show"}
+
+    # One word + space.
+    completions = completer.get_completions(Document("show "), CompleteEvent())
+    assert {c.text for c in completions} == {"version", "clock", "interfaces", "ip"}
+
+    # One word + space + one character.
+    completions = completer.get_completions(Document("show i"), CompleteEvent())
+    assert {c.text for c in completions} == {"ip", "interfaces"}
+
+    # One space + one word + space + one character.
+    completions = completer.get_completions(Document(" show i"), CompleteEvent())
+    assert {c.text for c in completions} == {"ip", "interfaces"}
+
+    # Test nested set.
+    completions = completer.get_completions(
+        Document("show ip interface br"), CompleteEvent()
+    )
+    assert {c.text for c in completions} == {"brief"}
+
+
+def test_deduplicate_completer():
+    def create_completer(deduplicate: bool):
+        return merge_completers(
+            [
+                WordCompleter(["hello", "world", "abc", "def"]),
+                WordCompleter(["xyz", "xyz", "abc", "def"]),
+            ],
+            deduplicate=deduplicate,
+        )
+
+    completions = list(
+        create_completer(deduplicate=False).get_completions(
+            Document(""), CompleteEvent()
+        )
+    )
+    assert len(completions) == 8
+
+    completions = list(
+        create_completer(deduplicate=True).get_completions(
+            Document(""), CompleteEvent()
+        )
+    )
+    assert len(completions) == 5
diff --git a/tests/test_document.py b/tests/test_document.py
new file mode 100644
index 0000000..d052d53
--- /dev/null
+++ b/tests/test_document.py
@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import pytest
+
+from prompt_toolkit.document import Document
+
+
+@pytest.fixture
+def document():
+    return Document(
+        "line 1\n" + "line 2\n" + "line 3\n" + "line 4\n", len("line 1\n" + "lin")
+    )
+
+
+def test_current_char(document):
+    assert document.current_char == "e"
+    assert document.char_before_cursor == "n"
+
+
+def test_text_before_cursor(document):
+    assert document.text_before_cursor == "line 1\nlin"
+
+
+def test_text_after_cursor(document):
+    assert document.text_after_cursor == "e 2\n" + "line 3\n" + "line 4\n"
+
+
+def test_lines(document):
+    assert document.lines == ["line 1", "line 2", "line 3", "line 4", ""]
+
+
+def test_line_count(document):
+    assert document.line_count == 5
+
+
+def test_current_line_before_cursor(document):
+    assert document.current_line_before_cursor == "lin"
+
+
+def test_current_line_after_cursor(document):
+    assert document.current_line_after_cursor == "e 2"
+
+
+def test_current_line(document):
+    assert document.current_line == "line 2"
+
+
+def test_cursor_position(document):
+    assert document.cursor_position_row == 1
+    assert document.cursor_position_col == 3
+
+    d = Document("", 0)
+    assert d.cursor_position_row == 0
+    assert d.cursor_position_col == 0
+
+
+def test_translate_index_to_position(document):
+    pos = document.translate_index_to_position(len("line 1\nline 2\nlin"))
+
+    assert pos[0] == 2
+    assert pos[1] == 3
+
+    pos = document.translate_index_to_position(0)
+    assert pos == (0, 0)
+
+
+def test_is_cursor_at_the_end(document):
+    assert Document("hello", 5).is_cursor_at_the_end
+    assert not Document("hello", 4).is_cursor_at_the_end
diff --git a/tests/test_filter.py b/tests/test_filter.py
new file mode 100644
index 0000000..f7184c2
--- /dev/null
+++ b/tests/test_filter.py
@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import pytest
+
+from prompt_toolkit.filters import Always, Condition, Filter, Never, to_filter
+from prompt_toolkit.filters.base import _AndList, _OrList
+
+
+def test_never():
+    assert not Never()()
+
+
+def test_always():
+    assert Always()()
+
+
+def test_invert():
+    assert not (~Always())()
+    assert ~Never()()
+
+    c = ~Condition(lambda: False)
+    assert c()
+
+
+def test_or():
+    for a in (True, False):
+        for b in (True, False):
+            c1 = Condition(lambda: a)
+            c2 = Condition(lambda: b)
+            c3 = c1 | c2
+
+            assert isinstance(c3, Filter)
+            assert c3() == a or b
+
+
+def test_and():
+    for a in (True, False):
+        for b in (True, False):
+            c1 = Condition(lambda: a)
+            c2 = Condition(lambda: b)
+            c3 = c1 & c2
+
+            assert isinstance(c3, Filter)
+            assert c3() == (a and b)
+
+
+def test_nested_and():
+    for a in (True, False):
+        for b in (True, False):
+            for c in (True, False):
+                c1 = Condition(lambda: a)
+                c2 = Condition(lambda: b)
+                c3 = Condition(lambda: c)
+                c4 = (c1 & c2) & c3
+
+                assert isinstance(c4, Filter)
+                assert c4() == (a and b and c)
+
+
+def test_nested_or():
+    for a in (True, False):
+        for b in (True, False):
+            for c in (True, False):
+                c1 = Condition(lambda: a)
+                c2 = Condition(lambda: b)
+                c3 = Condition(lambda: c)
+                c4 = (c1 | c2) | c3
+
+                assert isinstance(c4, Filter)
+                assert c4() == (a or b or c)
+
+
+def test_to_filter():
+    f1 = to_filter(True)
+    f2 = to_filter(False)
+    f3 = to_filter(Condition(lambda: True))
+    f4 = to_filter(Condition(lambda: False))
+
+    assert isinstance(f1, Filter)
+    assert isinstance(f2, Filter)
+    assert isinstance(f3, Filter)
+    assert isinstance(f4, Filter)
+    assert f1()
+    assert not f2()
+    assert f3()
+    assert not f4()
+
+    with pytest.raises(TypeError):
+        to_filter(4)
+
+
+def test_filter_cache_regression_1():
+    # See: https://github.com/prompt-toolkit/python-prompt-toolkit/issues/1729
+
+    cond = Condition(lambda: True)
+
+    # The use of a `WeakValueDictionary` caused this following expression to
+    # fail. The problem is that the nested `(a & a)` expression gets garbage
+    # collected between the two statements and is removed from our cache.
+    x = (cond & cond) & cond
+    y = (cond & cond) & cond
+    assert x == y
+
+
+def test_filter_cache_regression_2():
+    cond1 = Condition(lambda: True)
+    cond2 = Condition(lambda: True)
+    cond3 = Condition(lambda: True)
+
+    x = (cond1 & cond2) & cond3
+    y = (cond1 & cond2) & cond3
+    assert x == y
+
+
+def test_filter_remove_duplicates():
+    cond1 = Condition(lambda: True)
+    cond2 = Condition(lambda: True)
+
+    # When a condition is appended to itself using an `&` or `|` operator, it
+    # should not be present twice. Having it twice in the `_AndList` or
+    # `_OrList` will make them more expensive to evaluate.
+
+    assert isinstance(cond1 & cond1, Condition)
+    assert isinstance(cond1 & cond1 & cond1, Condition)
+    assert isinstance(cond1 & cond1 & cond2, _AndList)
+    assert len((cond1 & cond1 & cond2).filters) == 2
+
+    assert isinstance(cond1 | cond1, Condition)
+    assert isinstance(cond1 | cond1 | cond1, Condition)
+    assert isinstance(cond1 | cond1 | cond2, _OrList)
+    assert len((cond1 | cond1 | cond2).filters) == 2
diff --git a/tests/test_formatted_text.py b/tests/test_formatted_text.py
new file mode 100644
index 0000000..843aac1
--- /dev/null
+++ b/tests/test_formatted_text.py
@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+from prompt_toolkit.formatted_text import (
+    ANSI,
+    HTML,
+    FormattedText,
+    PygmentsTokens,
+    Template,
+    merge_formatted_text,
+    to_formatted_text,
+)
+from prompt_toolkit.formatted_text.utils import split_lines
+
+
+def test_basic_html():
+    html = HTML("<i>hello</i>")
+    assert to_formatted_text(html) == [("class:i", "hello")]
+
+    html = HTML("<i><b>hello</b></i>")
+    assert to_formatted_text(html) == [("class:i,b", "hello")]
+
+    html = HTML("<i><b>hello</b>world<strong>test</strong></i>after")
+    assert to_formatted_text(html) == [
+        ("class:i,b", "hello"),
+        ("class:i", "world"),
+        ("class:i,strong", "test"),
+        ("", "after"),
+    ]
+
+    # It's important that `to_formatted_text` returns a `FormattedText`
+    # instance. Otherwise, `print_formatted_text` won't recognize it and will
+    # print a list literal instead.
+    assert isinstance(to_formatted_text(html), FormattedText)
+
+
+def test_html_with_fg_bg():
+    html = HTML('<style bg="ansired">hello</style>')
+    assert to_formatted_text(html) == [
+        ("bg:ansired", "hello"),
+    ]
+
+    html = HTML('<style bg="ansired" fg="#ff0000">hello</style>')
+    assert to_formatted_text(html) == [
+        ("fg:#ff0000 bg:ansired", "hello"),
+    ]
+
+    html = HTML(
+        '<style bg="ansired" fg="#ff0000">hello <world fg="ansiblue">world</world></style>'
+    )
+    assert to_formatted_text(html) == [
+        ("fg:#ff0000 bg:ansired", "hello "),
+        ("class:world fg:ansiblue bg:ansired", "world"),
+    ]
+
+
+def test_ansi_formatting():
+    value = ANSI("\x1b[32mHe\x1b[45mllo")
+
+    assert to_formatted_text(value) == [
+        ("ansigreen", "H"),
+        ("ansigreen", "e"),
+        ("ansigreen bg:ansimagenta", "l"),
+        ("ansigreen bg:ansimagenta", "l"),
+        ("ansigreen bg:ansimagenta", "o"),
+    ]
+
+    # Bold and italic.
+    value = ANSI("\x1b[1mhe\x1b[0mllo")
+
+    assert to_formatted_text(value) == [
+        ("bold", "h"),
+        ("bold", "e"),
+        ("", "l"),
+        ("", "l"),
+        ("", "o"),
+    ]
+
+    # Zero width escapes.
+    value = ANSI("ab\001cd\002ef")
+
+    assert to_formatted_text(value) == [
+        ("", "a"),
+        ("", "b"),
+        ("[ZeroWidthEscape]", "cd"),
+        ("", "e"),
+        ("", "f"),
+    ]
+
+    assert isinstance(to_formatted_text(value), FormattedText)
+
+
+def test_ansi_256_color():
+    assert to_formatted_text(ANSI("\x1b[38;5;124mtest")) == [
+        ("#af0000", "t"),
+        ("#af0000", "e"),
+        ("#af0000", "s"),
+        ("#af0000", "t"),
+    ]
+
+
+def test_ansi_true_color():
+    assert to_formatted_text(ANSI("\033[38;2;144;238;144m$\033[0;39;49m ")) == [
+        ("#90ee90", "$"),
+        ("ansidefault bg:ansidefault", " "),
+    ]
+
+
+def test_ansi_interpolation():
+    # %-style interpolation.
+    value = ANSI("\x1b[1m%s\x1b[0m") % "hello\x1b"
+    assert to_formatted_text(value) == [
+        ("bold", "h"),
+        ("bold", "e"),
+        ("bold", "l"),
+        ("bold", "l"),
+        ("bold", "o"),
+        ("bold", "?"),
+    ]
+
+    value = ANSI("\x1b[1m%s\x1b[0m") % ("\x1bhello",)
+    assert to_formatted_text(value) == [
+        ("bold", "?"),
+        ("bold", "h"),
+        ("bold", "e"),
+        ("bold", "l"),
+        ("bold", "l"),
+        ("bold", "o"),
+    ]
+
+    value = ANSI("\x1b[32m%s\x1b[45m%s") % ("He", "\x1bllo")
+    assert to_formatted_text(value) == [
+        ("ansigreen", "H"),
+        ("ansigreen", "e"),
+        ("ansigreen bg:ansimagenta", "?"),
+        ("ansigreen bg:ansimagenta", "l"),
+        ("ansigreen bg:ansimagenta", "l"),
+        ("ansigreen bg:ansimagenta", "o"),
+    ]
+
+    # Format function.
+    value = ANSI("\x1b[32m{0}\x1b[45m{1}").format("He\x1b", "llo")
+    assert to_formatted_text(value) == [
+        ("ansigreen", "H"),
+        ("ansigreen", "e"),
+        ("ansigreen", "?"),
+        ("ansigreen bg:ansimagenta", "l"),
+        ("ansigreen bg:ansimagenta", "l"),
+        ("ansigreen bg:ansimagenta", "o"),
+    ]
+
+    value = ANSI("\x1b[32m{a}\x1b[45m{b}").format(a="\x1bHe", b="llo")
+    assert to_formatted_text(value) == [
+        ("ansigreen", "?"),
+        ("ansigreen", "H"),
+        ("ansigreen", "e"),
+        ("ansigreen bg:ansimagenta", "l"),
+        ("ansigreen bg:ansimagenta", "l"),
+        ("ansigreen bg:ansimagenta", "o"),
+    ]
+
+    value = ANSI("\x1b[32m{:02d}\x1b[45m{:.3f}").format(3, 3.14159)
+    assert to_formatted_text(value) == [
+        ("ansigreen", "0"),
+        ("ansigreen", "3"),
+        ("ansigreen bg:ansimagenta", "3"),
+        ("ansigreen bg:ansimagenta", "."),
+        ("ansigreen bg:ansimagenta", "1"),
+        ("ansigreen bg:ansimagenta", "4"),
+        ("ansigreen bg:ansimagenta", "2"),
+    ]
+
+
+def test_interpolation():
+    value = Template(" {} ").format(HTML("<b>hello</b>"))
+
+    assert to_formatted_text(value) == [
+        ("", " "),
+        ("class:b", "hello"),
+        ("", " "),
+    ]
+
+    value = Template("a{}b{}c").format(HTML("<b>hello</b>"), "world")
+
+    assert to_formatted_text(value) == [
+        ("", "a"),
+        ("class:b", "hello"),
+        ("", "b"),
+        ("", "world"),
+        ("", "c"),
+    ]
+
+
+def test_html_interpolation():
+    # %-style interpolation.
+    value = HTML("<b>%s</b>") % "&hello"
+    assert to_formatted_text(value) == [("class:b", "&hello")]
+
+    value = HTML("<b>%s</b>") % ("<hello>",)
+    assert to_formatted_text(value) == [("class:b", "<hello>")]
+
+    value = HTML("<b>%s</b><u>%s</u>") % ("<hello>", "</world>")
+    assert to_formatted_text(value) == [("class:b", "<hello>"), ("class:u", "</world>")]
+
+    # Format function.
+    value = HTML("<b>{0}</b><u>{1}</u>").format("'hello'", '"world"')
+    assert to_formatted_text(value) == [("class:b", "'hello'"), ("class:u", '"world"')]
+
+    value = HTML("<b>{a}</b><u>{b}</u>").format(a="hello", b="world")
+    assert to_formatted_text(value) == [("class:b", "hello"), ("class:u", "world")]
+
+    value = HTML("<b>{:02d}</b><u>{:.3f}</u>").format(3, 3.14159)
+    assert to_formatted_text(value) == [("class:b", "03"), ("class:u", "3.142")]
+
+
+def test_merge_formatted_text():
+    html1 = HTML("<u>hello</u>")
+    html2 = HTML("<b>world</b>")
+    result = merge_formatted_text([html1, html2])
+
+    assert to_formatted_text(result) == [
+        ("class:u", "hello"),
+        ("class:b", "world"),
+    ]
+
+
+def test_pygments_tokens():
+    text = [
+        (("A", "B"), "hello"),  # Token.A.B
+        (("C", "D", "E"), "hello"),  # Token.C.D.E
+        ((), "world"),  # Token
+    ]
+
+    assert to_formatted_text(PygmentsTokens(text)) == [
+        ("class:pygments.a.b", "hello"),
+        ("class:pygments.c.d.e", "hello"),
+        ("class:pygments", "world"),
+    ]
+
+
+def test_split_lines():
+    lines = list(split_lines([("class:a", "line1\nline2\nline3")]))
+
+    assert lines == [
+        [("class:a", "line1")],
+        [("class:a", "line2")],
+        [("class:a", "line3")],
+    ]
+
+
+def test_split_lines_2():
+    lines = list(
+        split_lines([("class:a", "line1"), ("class:b", "line2\nline3\nline4")])
+    )
+
+    assert lines == [
+        [("class:a", "line1"), ("class:b", "line2")],
+        [("class:b", "line3")],
+        [("class:b", "line4")],
+    ]
+
+
+def test_split_lines_3():
+    "Edge cases: inputs ending with newlines."
+    # -1-
+    lines = list(split_lines([("class:a", "line1\nline2\n")]))
+
+    assert lines == [
+        [("class:a", "line1")],
+        [("class:a", "line2")],
+        [("class:a", "")],
+    ]
+
+    # -2-
+    lines = list(split_lines([("class:a", "\n")]))
+
+    assert lines == [
+        [],
+        [("class:a", "")],
+    ]
+
+    # -3-
+    lines = list(split_lines([("class:a", "")]))
+
+    assert lines == [
+        [("class:a", "")],
+    ]
diff --git a/tests/test_history.py b/tests/test_history.py
new file mode 100644
index 0000000..500b7f1
--- /dev/null
+++ b/tests/test_history.py
@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from asyncio import run
+
+from prompt_toolkit.history import FileHistory, InMemoryHistory, ThreadedHistory
+
+
+def _call_history_load(history):
+    """
+    Helper: Call the history "load" method and return the result as a list of strings.
+    """
+    result = []
+
+    async def call_load():
+        async for item in history.load():
+            result.append(item)
+
+    run(call_load())
+    return result
+
+
+def test_in_memory_history():
+    history = InMemoryHistory()
+    history.append_string("hello")
+    history.append_string("world")
+
+    # Newest should yield first.
+    assert _call_history_load(history) == ["world", "hello"]
+
+    # Test another call.
+    assert _call_history_load(history) == ["world", "hello"]
+
+    history.append_string("test3")
+    assert _call_history_load(history) == ["test3", "world", "hello"]
+
+    # Passing history as a parameter.
+    history2 = InMemoryHistory(["abc", "def"])
+    assert _call_history_load(history2) == ["def", "abc"]
+
+
+def test_file_history(tmpdir):
+    histfile = tmpdir.join("history")
+
+    history = FileHistory(histfile)
+
+    history.append_string("hello")
+    history.append_string("world")
+
+    # Newest should yield first.
+    assert _call_history_load(history) == ["world", "hello"]
+
+    # Test another call.
+    assert _call_history_load(history) == ["world", "hello"]
+
+    history.append_string("test3")
+    assert _call_history_load(history) == ["test3", "world", "hello"]
+
+    # Create another history instance pointing to the same file.
+    history2 = FileHistory(histfile)
+    assert _call_history_load(history2) == ["test3", "world", "hello"]
+
+
+def test_threaded_file_history(tmpdir):
+    histfile = tmpdir.join("history")
+
+    history = ThreadedHistory(FileHistory(histfile))
+
+    history.append_string("hello")
+    history.append_string("world")
+
+    # Newest should yield first.
+    assert _call_history_load(history) == ["world", "hello"]
+
+    # Test another call.
+    assert _call_history_load(history) == ["world", "hello"]
+
+    history.append_string("test3")
+    assert _call_history_load(history) == ["test3", "world", "hello"]
+
+    # Create another history instance pointing to the same file.
+    history2 = ThreadedHistory(FileHistory(histfile))
+    assert _call_history_load(history2) == ["test3", "world", "hello"]
+
+
+def test_threaded_in_memory_history():
+    # Threaded in memory history is not useful. But testing it anyway, just to
+    # see whether everything plays nicely together.
+    history = ThreadedHistory(InMemoryHistory())
+    history.append_string("hello")
+    history.append_string("world")
+
+    # Newest should yield first.
+    assert _call_history_load(history) == ["world", "hello"]
+
+    # Test another call.
+    assert _call_history_load(history) == ["world", "hello"]
+
+    history.append_string("test3")
+    assert _call_history_load(history) == ["test3", "world", "hello"]
+
+    # Passing history as a parameter.
+    history2 = ThreadedHistory(InMemoryHistory(["abc", "def"]))
+    assert _call_history_load(history2) == ["def", "abc"]
diff --git a/tests/test_inputstream.py b/tests/test_inputstream.py
new file mode 100644
index 0000000..ab1b036
--- /dev/null
+++ b/tests/test_inputstream.py
@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import pytest
+
+from prompt_toolkit.input.vt100_parser import Vt100Parser
+from prompt_toolkit.keys import Keys
+
+
+class _ProcessorMock:
+    def __init__(self):
+        self.keys = []
+
+    def feed_key(self, key_press):
+        self.keys.append(key_press)
+
+
+@pytest.fixture
+def processor():
+    return _ProcessorMock()
+
+
+@pytest.fixture
+def stream(processor):
+    return Vt100Parser(processor.feed_key)
+
+
+def test_control_keys(processor, stream):
+    stream.feed("\x01\x02\x10")
+
+    assert len(processor.keys) == 3
+    assert processor.keys[0].key == Keys.ControlA
+    assert processor.keys[1].key == Keys.ControlB
+    assert processor.keys[2].key == Keys.ControlP
+    assert processor.keys[0].data == "\x01"
+    assert processor.keys[1].data == "\x02"
+    assert processor.keys[2].data == "\x10"
+
+
+def test_arrows(processor, stream):
+    stream.feed("\x1b[A\x1b[B\x1b[C\x1b[D")
+
+    assert len(processor.keys) == 4
+    assert processor.keys[0].key == Keys.Up
+    assert processor.keys[1].key == Keys.Down
+    assert processor.keys[2].key == Keys.Right
+    assert processor.keys[3].key == Keys.Left
+    assert processor.keys[0].data == "\x1b[A"
+    assert processor.keys[1].data == "\x1b[B"
+    assert processor.keys[2].data == "\x1b[C"
+    assert processor.keys[3].data == "\x1b[D"
+
+
+def test_escape(processor, stream):
+    stream.feed("\x1bhello")
+
+    assert len(processor.keys) == 1 + len("hello")
+    assert processor.keys[0].key == Keys.Escape
+    assert processor.keys[1].key == "h"
+    assert processor.keys[0].data == "\x1b"
+    assert processor.keys[1].data == "h"
+
+
+def test_special_double_keys(processor, stream):
+    stream.feed("\x1b[1;3D")  # Should both send escape and left.
+
+    assert len(processor.keys) == 2
+    assert processor.keys[0].key == Keys.Escape
+    assert processor.keys[1].key == Keys.Left
+    assert processor.keys[0].data == "\x1b[1;3D"
+    assert processor.keys[1].data == ""
+
+
+def test_flush_1(processor, stream):
+    # Send left key in two parts without flush.
+    stream.feed("\x1b")
+    stream.feed("[D")
+
+    assert len(processor.keys) == 1
+    assert processor.keys[0].key == Keys.Left
+    assert processor.keys[0].data == "\x1b[D"
+
+
+def test_flush_2(processor, stream):
+    # Send left key with a 'Flush' in between.
+    # The flush should make sure that we process everything before as-is,
+    # with makes the first part just an escape character instead.
+    stream.feed("\x1b")
+    stream.flush()
+    stream.feed("[D")
+
+    assert len(processor.keys) == 3
+    assert processor.keys[0].key == Keys.Escape
+    assert processor.keys[1].key == "["
+    assert processor.keys[2].key == "D"
+
+    assert processor.keys[0].data == "\x1b"
+    assert processor.keys[1].data == "["
+    assert processor.keys[2].data == "D"
+
+
+def test_meta_arrows(processor, stream):
+    stream.feed("\x1b\x1b[D")
+
+    assert len(processor.keys) == 2
+    assert processor.keys[0].key == Keys.Escape
+    assert processor.keys[1].key == Keys.Left
+
+
+def test_control_square_close(processor, stream):
+    stream.feed("\x1dC")
+
+    assert len(processor.keys) == 2
+    assert processor.keys[0].key == Keys.ControlSquareClose
+    assert processor.keys[1].key == "C"
+
+
+def test_invalid(processor, stream):
+    # Invalid sequence that has at two characters in common with other
+    # sequences.
+    stream.feed("\x1b[*")
+
+    assert len(processor.keys) == 3
+    assert processor.keys[0].key == Keys.Escape
+    assert processor.keys[1].key == "["
+    assert processor.keys[2].key == "*"
+
+
+def test_cpr_response(processor, stream):
+    stream.feed("a\x1b[40;10Rb")
+    assert len(processor.keys) == 3
+    assert processor.keys[0].key == "a"
+    assert processor.keys[1].key == Keys.CPRResponse
+    assert processor.keys[2].key == "b"
+
+
+def test_cpr_response_2(processor, stream):
+    # Make sure that the newline is not included in the CPR response.
+    stream.feed("\x1b[40;1R\n")
+    assert len(processor.keys) == 2
+    assert processor.keys[0].key == Keys.CPRResponse
+    assert processor.keys[1].key == Keys.ControlJ
diff --git a/tests/test_key_binding.py b/tests/test_key_binding.py
new file mode 100644
index 0000000..1c60880
--- /dev/null
+++ b/tests/test_key_binding.py
@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+
+import pytest
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.application.current import set_app
+from prompt_toolkit.input.defaults import create_pipe_input
+from prompt_toolkit.key_binding.key_bindings import KeyBindings
+from prompt_toolkit.key_binding.key_processor import KeyPress, KeyProcessor
+from prompt_toolkit.keys import Keys
+from prompt_toolkit.layout import Layout, Window
+from prompt_toolkit.output import DummyOutput
+
+
+class Handlers:
+    def __init__(self):
+        self.called = []
+
+    def __getattr__(self, name):
+        def func(event):
+            self.called.append(name)
+
+        return func
+
+
+@contextmanager
+def set_dummy_app():
+    """
+    Return a context manager that makes sure that this dummy application is
+    active. This is important, because we need an `Application` with
+    `is_done=False` flag, otherwise no keys will be processed.
+    """
+    with create_pipe_input() as pipe_input:
+        app = Application(
+            layout=Layout(Window()),
+            output=DummyOutput(),
+            input=pipe_input,
+        )
+
+        # Don't start background tasks for these tests. The `KeyProcessor`
+        # wants to create a background task for flushing keys. We can ignore it
+        # here for these tests.
+        # This patch is not clean. In the future, when we can use Taskgroups,
+        # the `Application` should pass its task group to the constructor of
+        # `KeyProcessor`. That way, it doesn't have to do a lookup using
+        # `get_app()`.
+        app.create_background_task = lambda *_, **kw: None
+
+        with set_app(app):
+            yield
+
+
+@pytest.fixture
+def handlers():
+    return Handlers()
+
+
+@pytest.fixture
+def bindings(handlers):
+    bindings = KeyBindings()
+    bindings.add(Keys.ControlX, Keys.ControlC)(handlers.controlx_controlc)
+    bindings.add(Keys.ControlX)(handlers.control_x)
+    bindings.add(Keys.ControlD)(handlers.control_d)
+    bindings.add(Keys.ControlSquareClose, Keys.Any)(handlers.control_square_close_any)
+
+    return bindings
+
+
+@pytest.fixture
+def processor(bindings):
+    return KeyProcessor(bindings)
+
+
+def test_remove_bindings(handlers):
+    with set_dummy_app():
+        h = handlers.controlx_controlc
+        h2 = handlers.controld
+
+        # Test passing a handler to the remove() function.
+        bindings = KeyBindings()
+        bindings.add(Keys.ControlX, Keys.ControlC)(h)
+        bindings.add(Keys.ControlD)(h2)
+        assert len(bindings.bindings) == 2
+        bindings.remove(h)
+        assert len(bindings.bindings) == 1
+
+        # Test passing a key sequence to the remove() function.
+        bindings = KeyBindings()
+        bindings.add(Keys.ControlX, Keys.ControlC)(h)
+        bindings.add(Keys.ControlD)(h2)
+        assert len(bindings.bindings) == 2
+        bindings.remove(Keys.ControlX, Keys.ControlC)
+        assert len(bindings.bindings) == 1
+
+
+def test_feed_simple(processor, handlers):
+    with set_dummy_app():
+        processor.feed(KeyPress(Keys.ControlX, "\x18"))
+        processor.feed(KeyPress(Keys.ControlC, "\x03"))
+        processor.process_keys()
+
+        assert handlers.called == ["controlx_controlc"]
+
+
+def test_feed_several(processor, handlers):
+    with set_dummy_app():
+        # First an unknown key first.
+        processor.feed(KeyPress(Keys.ControlQ, ""))
+        processor.process_keys()
+
+        assert handlers.called == []
+
+        # Followed by a know key sequence.
+        processor.feed(KeyPress(Keys.ControlX, ""))
+        processor.feed(KeyPress(Keys.ControlC, ""))
+        processor.process_keys()
+
+        assert handlers.called == ["controlx_controlc"]
+
+        # Followed by another unknown sequence.
+        processor.feed(KeyPress(Keys.ControlR, ""))
+        processor.feed(KeyPress(Keys.ControlS, ""))
+
+        # Followed again by a know key sequence.
+        processor.feed(KeyPress(Keys.ControlD, ""))
+        processor.process_keys()
+
+        assert handlers.called == ["controlx_controlc", "control_d"]
+
+
+def test_control_square_closed_any(processor, handlers):
+    with set_dummy_app():
+        processor.feed(KeyPress(Keys.ControlSquareClose, ""))
+        processor.feed(KeyPress("C", "C"))
+        processor.process_keys()
+
+        assert handlers.called == ["control_square_close_any"]
+
+
+def test_common_prefix(processor, handlers):
+    with set_dummy_app():
+        # Sending Control_X should not yet do anything, because there is
+        # another sequence starting with that as well.
+        processor.feed(KeyPress(Keys.ControlX, ""))
+        processor.process_keys()
+
+        assert handlers.called == []
+
+        # When another key is pressed, we know that we did not meant the longer
+        # "ControlX ControlC" sequence and the callbacks are called.
+        processor.feed(KeyPress(Keys.ControlD, ""))
+        processor.process_keys()
+
+        assert handlers.called == ["control_x", "control_d"]
+
+
+def test_previous_key_sequence(processor):
+    """
+    test whether we receive the correct previous_key_sequence.
+    """
+    with set_dummy_app():
+        events = []
+
+        def handler(event):
+            events.append(event)
+
+        # Build registry.
+        registry = KeyBindings()
+        registry.add("a", "a")(handler)
+        registry.add("b", "b")(handler)
+        processor = KeyProcessor(registry)
+
+        # Create processor and feed keys.
+        processor.feed(KeyPress("a", "a"))
+        processor.feed(KeyPress("a", "a"))
+        processor.feed(KeyPress("b", "b"))
+        processor.feed(KeyPress("b", "b"))
+        processor.process_keys()
+
+        # Test.
+        assert len(events) == 2
+        assert len(events[0].key_sequence) == 2
+        assert events[0].key_sequence[0].key == "a"
+        assert events[0].key_sequence[0].data == "a"
+        assert events[0].key_sequence[1].key == "a"
+        assert events[0].key_sequence[1].data == "a"
+        assert events[0].previous_key_sequence == []
+
+        assert len(events[1].key_sequence) == 2
+        assert events[1].key_sequence[0].key == "b"
+        assert events[1].key_sequence[0].data == "b"
+        assert events[1].key_sequence[1].key == "b"
+        assert events[1].key_sequence[1].data == "b"
+        assert len(events[1].previous_key_sequence) == 2
+        assert events[1].previous_key_sequence[0].key == "a"
+        assert events[1].previous_key_sequence[0].data == "a"
+        assert events[1].previous_key_sequence[1].key == "a"
+        assert events[1].previous_key_sequence[1].data == "a"
diff --git a/tests/test_layout.py b/tests/test_layout.py
new file mode 100644
index 0000000..cbbbcd0
--- /dev/null
+++ b/tests/test_layout.py
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import pytest
+
+from prompt_toolkit.layout import InvalidLayoutError, Layout
+from prompt_toolkit.layout.containers import HSplit, VSplit, Window
+from prompt_toolkit.layout.controls import BufferControl
+
+
+def test_layout_class():
+    c1 = BufferControl()
+    c2 = BufferControl()
+    c3 = BufferControl()
+    win1 = Window(content=c1)
+    win2 = Window(content=c2)
+    win3 = Window(content=c3)
+
+    layout = Layout(container=VSplit([HSplit([win1, win2]), win3]))
+
+    # Listing of windows/controls.
+    assert list(layout.find_all_windows()) == [win1, win2, win3]
+    assert list(layout.find_all_controls()) == [c1, c2, c3]
+
+    # Focusing something.
+    layout.focus(c1)
+    assert layout.has_focus(c1)
+    assert layout.has_focus(win1)
+    assert layout.current_control == c1
+    assert layout.previous_control == c1
+
+    layout.focus(c2)
+    assert layout.has_focus(c2)
+    assert layout.has_focus(win2)
+    assert layout.current_control == c2
+    assert layout.previous_control == c1
+
+    layout.focus(win3)
+    assert layout.has_focus(c3)
+    assert layout.has_focus(win3)
+    assert layout.current_control == c3
+    assert layout.previous_control == c2
+
+    # Pop focus. This should focus the previous control again.
+    layout.focus_last()
+    assert layout.has_focus(c2)
+    assert layout.has_focus(win2)
+    assert layout.current_control == c2
+    assert layout.previous_control == c1
+
+
+def test_create_invalid_layout():
+    with pytest.raises(InvalidLayoutError):
+        Layout(HSplit([]))
diff --git a/tests/test_memory_leaks.py b/tests/test_memory_leaks.py
new file mode 100644
index 0000000..31ea7c8
--- /dev/null
+++ b/tests/test_memory_leaks.py
@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import gc
+
+import pytest
+
+from prompt_toolkit.shortcuts.prompt import PromptSession
+
+
+def _count_prompt_session_instances() -> int:
+    # Run full GC collection first.
+    gc.collect()
+
+    # Count number of remaining referenced `PromptSession` instances.
+    objects = gc.get_objects()
+    return len([obj for obj in objects if isinstance(obj, PromptSession)])
+
+
+# Fails in GitHub CI, probably due to GC differences.
+@pytest.mark.xfail(reason="Memory leak testing fails in GitHub CI.")
+def test_prompt_session_memory_leak() -> None:
+    before_count = _count_prompt_session_instances()
+
+    # Somehow in CI/CD, the before_count is > 0
+    assert before_count == 0
+
+    p = PromptSession()
+
+    after_count = _count_prompt_session_instances()
+    assert after_count == before_count + 1
+
+    del p
+
+    after_delete_count = _count_prompt_session_instances()
+    assert after_delete_count == before_count
diff --git a/tests/test_print_formatted_text.py b/tests/test_print_formatted_text.py
new file mode 100644
index 0000000..26c7265
--- /dev/null
+++ b/tests/test_print_formatted_text.py
@@ -0,0 +1,92 @@
+"""
+Test the `print` function.
+"""
+from __future__ import annotations
+
+import pytest
+
+from prompt_toolkit import print_formatted_text as pt_print
+from prompt_toolkit.formatted_text import HTML, FormattedText, to_formatted_text
+from prompt_toolkit.output import ColorDepth
+from prompt_toolkit.styles import Style
+from prompt_toolkit.utils import is_windows
+
+
+class _Capture:
+    "Emulate an stdout object."
+
+    def __init__(self):
+        self._data = []
+
+    def write(self, data):
+        self._data.append(data)
+
+    @property
+    def data(self):
+        return "".join(self._data)
+
+    def flush(self):
+        pass
+
+    def isatty(self):
+        return True
+
+    def fileno(self):
+        # File descriptor is not used for printing formatted text.
+        # (It is only needed for getting the terminal size.)
+        return -1
+
+
+@pytest.mark.skipif(is_windows(), reason="Doesn't run on Windows yet.")
+def test_print_formatted_text():
+    f = _Capture()
+    pt_print([("", "hello"), ("", "world")], file=f)
+    assert "hello" in f.data
+    assert "world" in f.data
+
+
+@pytest.mark.skipif(is_windows(), reason="Doesn't run on Windows yet.")
+def test_print_formatted_text_backslash_r():
+    f = _Capture()
+    pt_print("hello\r\n", file=f)
+    assert "hello" in f.data
+
+
+@pytest.mark.skipif(is_windows(), reason="Doesn't run on Windows yet.")
+def test_formatted_text_with_style():
+    f = _Capture()
+    style = Style.from_dict(
+        {
+            "hello": "#ff0066",
+            "world": "#44ff44 italic",
+        }
+    )
+    tokens = FormattedText(
+        [
+            ("class:hello", "Hello "),
+            ("class:world", "world"),
+        ]
+    )
+
+    # NOTE: We pass the default (8bit) color depth, so that the unit tests
+    #       don't start failing when environment variables change.
+    pt_print(tokens, style=style, file=f, color_depth=ColorDepth.DEFAULT)
+    assert "\x1b[0;38;5;197mHello" in f.data
+    assert "\x1b[0;38;5;83;3mworld" in f.data
+
+
+@pytest.mark.skipif(is_windows(), reason="Doesn't run on Windows yet.")
+def test_html_with_style():
+    """
+    Text `print_formatted_text` with `HTML` wrapped in `to_formatted_text`.
+    """
+    f = _Capture()
+
+    html = HTML("<ansigreen>hello</ansigreen> <b>world</b>")
+    formatted_text = to_formatted_text(html, style="class:myhtml")
+    pt_print(formatted_text, file=f, color_depth=ColorDepth.DEFAULT)
+
+    assert (
+        f.data
+        == "\x1b[0m\x1b[?7h\x1b[0;32mhello\x1b[0m \x1b[0;1mworld\x1b[0m\r\n\x1b[0m"
+    )
diff --git a/tests/test_regular_languages.py b/tests/test_regular_languages.py
new file mode 100644
index 0000000..deef6b8
--- /dev/null
+++ b/tests/test_regular_languages.py
@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+from prompt_toolkit.contrib.regular_languages import compile
+from prompt_toolkit.contrib.regular_languages.compiler import Match, Variables
+from prompt_toolkit.contrib.regular_languages.completion import GrammarCompleter
+from prompt_toolkit.document import Document
+
+
+def test_simple_match():
+    g = compile("hello|world")
+
+    m = g.match("hello")
+    assert isinstance(m, Match)
+
+    m = g.match("world")
+    assert isinstance(m, Match)
+
+    m = g.match("somethingelse")
+    assert m is None
+
+
+def test_variable_varname():
+    """
+    Test `Variable` with varname.
+    """
+    g = compile("((?P<varname>hello|world)|test)")
+
+    m = g.match("hello")
+    variables = m.variables()
+    assert isinstance(variables, Variables)
+    assert variables.get("varname") == "hello"
+    assert variables["varname"] == "hello"
+
+    m = g.match("world")
+    variables = m.variables()
+    assert isinstance(variables, Variables)
+    assert variables.get("varname") == "world"
+    assert variables["varname"] == "world"
+
+    m = g.match("test")
+    variables = m.variables()
+    assert isinstance(variables, Variables)
+    assert variables.get("varname") is None
+    assert variables["varname"] is None
+
+
+def test_prefix():
+    """
+    Test `match_prefix`.
+    """
+    g = compile(r"(hello\ world|something\ else)")
+
+    m = g.match_prefix("hello world")
+    assert isinstance(m, Match)
+
+    m = g.match_prefix("he")
+    assert isinstance(m, Match)
+
+    m = g.match_prefix("")
+    assert isinstance(m, Match)
+
+    m = g.match_prefix("som")
+    assert isinstance(m, Match)
+
+    m = g.match_prefix("hello wor")
+    assert isinstance(m, Match)
+
+    m = g.match_prefix("no-match")
+    assert m.trailing_input().start == 0
+    assert m.trailing_input().stop == len("no-match")
+
+    m = g.match_prefix("hellotest")
+    assert m.trailing_input().start == len("hello")
+    assert m.trailing_input().stop == len("hellotest")
+
+
+def test_completer():
+    class completer1(Completer):
+        def get_completions(self, document, complete_event):
+            yield Completion("before-%s-after" % document.text, -len(document.text))
+            yield Completion("before-%s-after-B" % document.text, -len(document.text))
+
+    class completer2(Completer):
+        def get_completions(self, document, complete_event):
+            yield Completion("before2-%s-after2" % document.text, -len(document.text))
+            yield Completion("before2-%s-after2-B" % document.text, -len(document.text))
+
+    # Create grammar.  "var1" + "whitespace" + "var2"
+    g = compile(r"(?P<var1>[a-z]*) \s+ (?P<var2>[a-z]*)")
+
+    # Test 'get_completions()'
+    completer = GrammarCompleter(g, {"var1": completer1(), "var2": completer2()})
+    completions = list(
+        completer.get_completions(Document("abc def", len("abc def")), CompleteEvent())
+    )
+
+    assert len(completions) == 2
+    assert completions[0].text == "before2-def-after2"
+    assert completions[0].start_position == -3
+    assert completions[1].text == "before2-def-after2-B"
+    assert completions[1].start_position == -3
diff --git a/tests/test_shortcuts.py b/tests/test_shortcuts.py
new file mode 100644
index 0000000..287c6d3
--- /dev/null
+++ b/tests/test_shortcuts.py
@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from prompt_toolkit.shortcuts import print_container
+from prompt_toolkit.shortcuts.prompt import _split_multiline_prompt
+from prompt_toolkit.widgets import Frame, TextArea
+
+
+def test_split_multiline_prompt():
+    # Test 1: no newlines:
+    tokens = [("class:testclass", "ab")]
+    has_before_tokens, before, first_input_line = _split_multiline_prompt(
+        lambda: tokens
+    )
+    assert has_before_tokens() is False
+    assert before() == []
+    assert first_input_line() == [
+        ("class:testclass", "a"),
+        ("class:testclass", "b"),
+    ]
+
+    # Test 1: multiple lines.
+    tokens = [("class:testclass", "ab\ncd\nef")]
+    has_before_tokens, before, first_input_line = _split_multiline_prompt(
+        lambda: tokens
+    )
+    assert has_before_tokens() is True
+    assert before() == [
+        ("class:testclass", "a"),
+        ("class:testclass", "b"),
+        ("class:testclass", "\n"),
+        ("class:testclass", "c"),
+        ("class:testclass", "d"),
+    ]
+    assert first_input_line() == [
+        ("class:testclass", "e"),
+        ("class:testclass", "f"),
+    ]
+
+    # Edge case 1: starting with a newline.
+    tokens = [("class:testclass", "\nab")]
+    has_before_tokens, before, first_input_line = _split_multiline_prompt(
+        lambda: tokens
+    )
+    assert has_before_tokens() is True
+    assert before() == []
+    assert first_input_line() == [("class:testclass", "a"), ("class:testclass", "b")]
+
+    # Edge case 2: starting with two newlines.
+    tokens = [("class:testclass", "\n\nab")]
+    has_before_tokens, before, first_input_line = _split_multiline_prompt(
+        lambda: tokens
+    )
+    assert has_before_tokens() is True
+    assert before() == [("class:testclass", "\n")]
+    assert first_input_line() == [("class:testclass", "a"), ("class:testclass", "b")]
+
+
+def test_print_container(tmpdir):
+    # Call `print_container`, render to a dummy file.
+    f = tmpdir.join("output")
+    with open(f, "w") as fd:
+        print_container(Frame(TextArea(text="Hello world!\n"), title="Title"), file=fd)
+
+    # Verify rendered output.
+    with open(f) as fd:
+        text = fd.read()
+        assert "Hello world" in text
+        assert "Title" in text
diff --git a/tests/test_style.py b/tests/test_style.py
new file mode 100644
index 0000000..d0a4790
--- /dev/null
+++ b/tests/test_style.py
@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+from prompt_toolkit.styles import Attrs, Style, SwapLightAndDarkStyleTransformation
+
+
+def test_style_from_dict():
+    style = Style.from_dict(
+        {
+            "a": "#ff0000 bold underline strike italic",
+            "b": "bg:#00ff00 blink reverse",
+        }
+    )
+
+    # Lookup of class:a.
+    expected = Attrs(
+        color="ff0000",
+        bgcolor="",
+        bold=True,
+        underline=True,
+        strike=True,
+        italic=True,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("class:a") == expected
+
+    # Lookup of class:b.
+    expected = Attrs(
+        color="",
+        bgcolor="00ff00",
+        bold=False,
+        underline=False,
+        strike=False,
+        italic=False,
+        blink=True,
+        reverse=True,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("class:b") == expected
+
+    # Test inline style.
+    expected = Attrs(
+        color="ff0000",
+        bgcolor="",
+        bold=False,
+        underline=False,
+        strike=False,
+        italic=False,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("#ff0000") == expected
+
+    # Combine class name and inline style (Whatever is defined later gets priority.)
+    expected = Attrs(
+        color="00ff00",
+        bgcolor="",
+        bold=True,
+        underline=True,
+        strike=True,
+        italic=True,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("class:a #00ff00") == expected
+
+    expected = Attrs(
+        color="ff0000",
+        bgcolor="",
+        bold=True,
+        underline=True,
+        strike=True,
+        italic=True,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("#00ff00 class:a") == expected
+
+
+def test_class_combinations_1():
+    # In this case, our style has both class 'a' and 'b'.
+    # Given that the style for 'a b' is defined at the end, that one is used.
+    style = Style(
+        [
+            ("a", "#0000ff"),
+            ("b", "#00ff00"),
+            ("a b", "#ff0000"),
+        ]
+    )
+    expected = Attrs(
+        color="ff0000",
+        bgcolor="",
+        bold=False,
+        underline=False,
+        strike=False,
+        italic=False,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("class:a class:b") == expected
+    assert style.get_attrs_for_style_str("class:a,b") == expected
+    assert style.get_attrs_for_style_str("class:a,b,c") == expected
+
+    # Changing the order shouldn't matter.
+    assert style.get_attrs_for_style_str("class:b class:a") == expected
+    assert style.get_attrs_for_style_str("class:b,a") == expected
+
+
+def test_class_combinations_2():
+    # In this case, our style has both class 'a' and 'b'.
+    # The style that is defined the latest get priority.
+    style = Style(
+        [
+            ("a b", "#ff0000"),
+            ("b", "#00ff00"),
+            ("a", "#0000ff"),
+        ]
+    )
+    expected = Attrs(
+        color="00ff00",
+        bgcolor="",
+        bold=False,
+        underline=False,
+        strike=False,
+        italic=False,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("class:a class:b") == expected
+    assert style.get_attrs_for_style_str("class:a,b") == expected
+    assert style.get_attrs_for_style_str("class:a,b,c") == expected
+
+    # Defining 'a' latest should give priority to 'a'.
+    expected = Attrs(
+        color="0000ff",
+        bgcolor="",
+        bold=False,
+        underline=False,
+        strike=False,
+        italic=False,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("class:b class:a") == expected
+    assert style.get_attrs_for_style_str("class:b,a") == expected
+
+
+def test_substyles():
+    style = Style(
+        [
+            ("a.b", "#ff0000 bold"),
+            ("a", "#0000ff"),
+            ("b", "#00ff00"),
+            ("b.c", "#0000ff italic"),
+        ]
+    )
+
+    # Starting with a.*
+    expected = Attrs(
+        color="0000ff",
+        bgcolor="",
+        bold=False,
+        underline=False,
+        strike=False,
+        italic=False,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("class:a") == expected
+
+    expected = Attrs(
+        color="ff0000",
+        bgcolor="",
+        bold=True,
+        underline=False,
+        strike=False,
+        italic=False,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("class:a.b") == expected
+    assert style.get_attrs_for_style_str("class:a.b.c") == expected
+
+    # Starting with b.*
+    expected = Attrs(
+        color="00ff00",
+        bgcolor="",
+        bold=False,
+        underline=False,
+        strike=False,
+        italic=False,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("class:b") == expected
+    assert style.get_attrs_for_style_str("class:b.a") == expected
+
+    expected = Attrs(
+        color="0000ff",
+        bgcolor="",
+        bold=False,
+        underline=False,
+        strike=False,
+        italic=True,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    assert style.get_attrs_for_style_str("class:b.c") == expected
+    assert style.get_attrs_for_style_str("class:b.c.d") == expected
+
+
+def test_swap_light_and_dark_style_transformation():
+    transformation = SwapLightAndDarkStyleTransformation()
+
+    # Test with 6 digit hex colors.
+    before = Attrs(
+        color="440000",
+        bgcolor="888844",
+        bold=True,
+        underline=True,
+        strike=True,
+        italic=True,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    after = Attrs(
+        color="ffbbbb",
+        bgcolor="bbbb76",
+        bold=True,
+        underline=True,
+        strike=True,
+        italic=True,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+
+    assert transformation.transform_attrs(before) == after
+
+    # Test with ANSI colors.
+    before = Attrs(
+        color="ansired",
+        bgcolor="ansiblack",
+        bold=True,
+        underline=True,
+        strike=True,
+        italic=True,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+    after = Attrs(
+        color="ansibrightred",
+        bgcolor="ansiwhite",
+        bold=True,
+        underline=True,
+        strike=True,
+        italic=True,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+
+    assert transformation.transform_attrs(before) == after
diff --git a/tests/test_style_transformation.py b/tests/test_style_transformation.py
new file mode 100644
index 0000000..e4eee7c
--- /dev/null
+++ b/tests/test_style_transformation.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import pytest
+
+from prompt_toolkit.styles import AdjustBrightnessStyleTransformation, Attrs
+
+
+@pytest.fixture
+def default_attrs():
+    return Attrs(
+        color="",
+        bgcolor="",
+        bold=False,
+        underline=False,
+        strike=False,
+        italic=False,
+        blink=False,
+        reverse=False,
+        hidden=False,
+    )
+
+
+def test_adjust_brightness_style_transformation(default_attrs):
+    tr = AdjustBrightnessStyleTransformation(0.5, 1.0)
+
+    attrs = tr.transform_attrs(default_attrs._replace(color="ff0000"))
+    assert attrs.color == "ff7f7f"
+
+    attrs = tr.transform_attrs(default_attrs._replace(color="00ffaa"))
+    assert attrs.color == "7fffd4"
+
+    # When a background color is given, nothing should change.
+    attrs = tr.transform_attrs(default_attrs._replace(color="00ffaa", bgcolor="white"))
+    assert attrs.color == "00ffaa"
+
+    # Test ansi colors.
+    attrs = tr.transform_attrs(default_attrs._replace(color="ansiblue"))
+    assert attrs.color == "6666ff"
+
+    # Test 'ansidefault'. This shouldn't change.
+    attrs = tr.transform_attrs(default_attrs._replace(color="ansidefault"))
+    assert attrs.color == "ansidefault"
+
+    # When 0 and 1 are given, don't do any style transformation.
+    tr2 = AdjustBrightnessStyleTransformation(0, 1)
+
+    attrs = tr2.transform_attrs(default_attrs._replace(color="ansiblue"))
+    assert attrs.color == "ansiblue"
+
+    attrs = tr2.transform_attrs(default_attrs._replace(color="00ffaa"))
+    assert attrs.color == "00ffaa"
diff --git a/tests/test_utils.py b/tests/test_utils.py
new file mode 100644
index 0000000..9d4c808
--- /dev/null
+++ b/tests/test_utils.py
@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import itertools
+
+import pytest
+
+from prompt_toolkit.utils import take_using_weights
+
+
+def test_using_weights():
+    def take(generator, count):
+        return list(itertools.islice(generator, 0, count))
+
+    # Check distribution.
+    data = take(take_using_weights(["A", "B", "C"], [5, 10, 20]), 35)
+    assert data.count("A") == 5
+    assert data.count("B") == 10
+    assert data.count("C") == 20
+
+    assert data == [
+        "A",
+        "B",
+        "C",
+        "C",
+        "B",
+        "C",
+        "C",
+        "A",
+        "B",
+        "C",
+        "C",
+        "B",
+        "C",
+        "C",
+        "A",
+        "B",
+        "C",
+        "C",
+        "B",
+        "C",
+        "C",
+        "A",
+        "B",
+        "C",
+        "C",
+        "B",
+        "C",
+        "C",
+        "A",
+        "B",
+        "C",
+        "C",
+        "B",
+        "C",
+        "C",
+    ]
+
+    # Another order.
+    data = take(take_using_weights(["A", "B", "C"], [20, 10, 5]), 35)
+    assert data.count("A") == 20
+    assert data.count("B") == 10
+    assert data.count("C") == 5
+
+    # Bigger numbers.
+    data = take(take_using_weights(["A", "B", "C"], [20, 10, 5]), 70)
+    assert data.count("A") == 40
+    assert data.count("B") == 20
+    assert data.count("C") == 10
+
+    # Negative numbers.
+    data = take(take_using_weights(["A", "B", "C"], [-20, 10, 0]), 70)
+    assert data.count("A") == 0
+    assert data.count("B") == 70
+    assert data.count("C") == 0
+
+    # All zero-weight items.
+    with pytest.raises(ValueError):
+        take(take_using_weights(["A", "B", "C"], [0, 0, 0]), 70)
diff --git a/tests/test_vt100_output.py b/tests/test_vt100_output.py
new file mode 100644
index 0000000..65c8377
--- /dev/null
+++ b/tests/test_vt100_output.py
@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from prompt_toolkit.output.vt100 import _get_closest_ansi_color
+
+
+def test_get_closest_ansi_color():
+    # White
+    assert _get_closest_ansi_color(255, 255, 255) == "ansiwhite"
+    assert _get_closest_ansi_color(250, 250, 250) == "ansiwhite"
+
+    # Black
+    assert _get_closest_ansi_color(0, 0, 0) == "ansiblack"
+    assert _get_closest_ansi_color(5, 5, 5) == "ansiblack"
+
+    # Green
+    assert _get_closest_ansi_color(0, 255, 0) == "ansibrightgreen"
+    assert _get_closest_ansi_color(10, 255, 0) == "ansibrightgreen"
+    assert _get_closest_ansi_color(0, 255, 10) == "ansibrightgreen"
+
+    assert _get_closest_ansi_color(220, 220, 100) == "ansiyellow"
diff --git a/tests/test_widgets.py b/tests/test_widgets.py
new file mode 100644
index 0000000..ee7745a
--- /dev/null
+++ b/tests/test_widgets.py
@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from prompt_toolkit.formatted_text import fragment_list_to_text
+from prompt_toolkit.layout import to_window
+from prompt_toolkit.widgets import Button
+
+
+def _to_text(button: Button) -> str:
+    control = to_window(button).content
+    return fragment_list_to_text(control.text())
+
+
+def test_default_button():
+    button = Button("Exit")
+    assert _to_text(button) == "<   Exit   >"
+
+
+def test_custom_button():
+    button = Button("Exit", left_symbol="[", right_symbol="]")
+    assert _to_text(button) == "[   Exit   ]"
diff --git a/tests/test_yank_nth_arg.py b/tests/test_yank_nth_arg.py
new file mode 100644
index 0000000..7167a26
--- /dev/null
+++ b/tests/test_yank_nth_arg.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import pytest
+
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.history import InMemoryHistory
+
+
+@pytest.fixture
+def _history():
+    "Prefilled history."
+    history = InMemoryHistory()
+    history.append_string("alpha beta gamma delta")
+    history.append_string("one two three four")
+    return history
+
+
+# Test yank_last_arg.
+
+
+def test_empty_history():
+    buf = Buffer()
+    buf.yank_last_arg()
+    assert buf.document.current_line == ""
+
+
+def test_simple_search(_history):
+    buff = Buffer(history=_history)
+    buff.yank_last_arg()
+    assert buff.document.current_line == "four"
+
+
+def test_simple_search_with_quotes(_history):
+    _history.append_string("""one two "three 'x' four"\n""")
+    buff = Buffer(history=_history)
+    buff.yank_last_arg()
+    assert buff.document.current_line == '''"three 'x' four"'''
+
+
+def test_simple_search_with_arg(_history):
+    buff = Buffer(history=_history)
+    buff.yank_last_arg(n=2)
+    assert buff.document.current_line == "three"
+
+
+def test_simple_search_with_arg_out_of_bounds(_history):
+    buff = Buffer(history=_history)
+    buff.yank_last_arg(n=8)
+    assert buff.document.current_line == ""
+
+
+def test_repeated_search(_history):
+    buff = Buffer(history=_history)
+    buff.yank_last_arg()
+    buff.yank_last_arg()
+    assert buff.document.current_line == "delta"
+
+
+def test_repeated_search_with_wraparound(_history):
+    buff = Buffer(history=_history)
+    buff.yank_last_arg()
+    buff.yank_last_arg()
+    buff.yank_last_arg()
+    assert buff.document.current_line == "four"
+
+
+# Test yank_last_arg.
+
+
+def test_yank_nth_arg(_history):
+    buff = Buffer(history=_history)
+    buff.yank_nth_arg()
+    assert buff.document.current_line == "two"
+
+
+def test_repeated_yank_nth_arg(_history):
+    buff = Buffer(history=_history)
+    buff.yank_nth_arg()
+    buff.yank_nth_arg()
+    assert buff.document.current_line == "beta"
+
+
+def test_yank_nth_arg_with_arg(_history):
+    buff = Buffer(history=_history)
+    buff.yank_nth_arg(n=2)
+    assert buff.document.current_line == "three"