1120 lines
38 KiB
Python
1120 lines
38 KiB
Python
"""Tests for gamepad input navigation."""
|
|
|
|
from inspect import signature
|
|
from types import SimpleNamespace
|
|
from typing import Any, cast
|
|
from unittest.mock import MagicMock
|
|
|
|
from PySide6.QtCore import QEvent, QObject, QStringListModel, Qt
|
|
from PySide6.QtWidgets import QApplication, QCheckBox, QComboBox, QDialog, QFrame, QHBoxLayout, QLineEdit, QListView, QMenu, QPushButton, QSlider, QStackedWidget, QTableWidget, QTableWidgetItem, QWidget
|
|
from pytest import MonkeyPatch, raises
|
|
|
|
import portprotonqt.input_manager as input_manager
|
|
import portprotonqt.input_manager.buttons as input_buttons
|
|
import portprotonqt.input_manager.dpad as input_dpad
|
|
import portprotonqt.input_manager.runtime as input_runtime
|
|
import portprotonqt.native_gamepad as native_gamepad
|
|
from portprotonqt.input_manager.constants import (
|
|
GamepadType,
|
|
KEY_LEFT,
|
|
PAD_BUTTON_SOUTH,
|
|
PAD_BUTTON_SELECT,
|
|
SDL_GAMEPAD_TYPE_PS5,
|
|
SDL_GAMEPAD_BUTTON_DPAD_DOWN,
|
|
SDL_GAMEPAD_BUTTON_DPAD_UP,
|
|
)
|
|
from portprotonqt.input_manager import InputManager, MainWindowProtocol, PAD_DPAD_X, PAD_DPAD_Y
|
|
from portprotonqt.game_library_manager import FullLibraryTile
|
|
from portprotonqt.native_gamepad import GamepadBackendError, SDLGamepad
|
|
from portprotonqt.themes.standart.styles.constants import GAME_CARD_ANIMATION
|
|
|
|
FIRST_CARD_X = 0
|
|
HIDDEN_CARD_X = 20
|
|
NEXT_CARD_X = 40
|
|
|
|
|
|
def _tile_theme() -> Any:
|
|
return SimpleNamespace(
|
|
fullLibraryTileSize=(180, 180),
|
|
fullLibraryTileColumns=2,
|
|
fullLibraryTileRows=2,
|
|
fullLibraryTileRadius=10,
|
|
GAME_CARD_HORIZONTAL={},
|
|
GAME_CARD_ANIMATION=GAME_CARD_ANIMATION,
|
|
)
|
|
|
|
|
|
def test_dpad_first_repeat_uses_long_press_delay() -> None:
|
|
parameters = signature(InputManager).parameters
|
|
|
|
assert parameters["initial_axis_move_delay"].default == 0.5
|
|
|
|
|
|
def test_theme_tab_focusables_include_delete_button(monkeypatch: MonkeyPatch) -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
manager = InputManager.__new__(InputManager)
|
|
widgets = [QWidget() for _index in range(5)]
|
|
cast(Any, manager)._parent = SimpleNamespace(
|
|
themesCombo=widgets[0],
|
|
themeVariantCombo=widgets[1],
|
|
screenshotsCarousel=widgets[2],
|
|
applyButton=widgets[3],
|
|
deleteThemeButton=widgets[4],
|
|
)
|
|
monkeypatch.setattr(manager, "_is_theme_store_visible", lambda: False)
|
|
monkeypatch.setattr(manager, "_is_visible_enabled_widget", lambda _widget: True)
|
|
|
|
assert manager._get_theme_tab_focusables() == widgets
|
|
assert app is not None
|
|
|
|
|
|
def test_native_gamepad_result_preserves_python_interface(monkeypatch: MonkeyPatch) -> None:
|
|
controller = 42
|
|
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_find", lambda: controller)
|
|
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_close", lambda _handle: None)
|
|
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_get_instance_id", lambda _handle: 7)
|
|
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_get_name", lambda _handle: b"DualSense")
|
|
monkeypatch.setattr(
|
|
native_gamepad._library,
|
|
"portproton_gamepad_get_type",
|
|
lambda _handle: SDL_GAMEPAD_TYPE_PS5,
|
|
)
|
|
|
|
gamepad = native_gamepad.find_gamepad()
|
|
|
|
assert gamepad is not None
|
|
assert gamepad.controller == controller
|
|
assert gamepad.name == "DualSense"
|
|
assert gamepad.path == "sdl3-gamepad:7"
|
|
manager = InputManager.__new__(InputManager)
|
|
assert manager._detect_gamepad_type(gamepad) == GamepadType.PLAYSTATION
|
|
gamepad.close()
|
|
|
|
|
|
def test_native_gamepad_update_passes_collection_handle(monkeypatch: MonkeyPatch) -> None:
|
|
updated_handles: list[int] = []
|
|
gamepad = SDLGamepad(42, "Gamepads", "sdl3-gamepad:7", 7, 1)
|
|
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_close", lambda _handle: None)
|
|
monkeypatch.setattr(
|
|
native_gamepad._library,
|
|
"portproton_gamepad_update",
|
|
updated_handles.append,
|
|
)
|
|
monkeypatch.setattr(
|
|
native_gamepad._library,
|
|
"portproton_gamepad_get_active_instance_id",
|
|
lambda _handle: 9,
|
|
)
|
|
monkeypatch.setattr(
|
|
native_gamepad._library,
|
|
"portproton_gamepad_get_type",
|
|
lambda _handle: SDL_GAMEPAD_TYPE_PS5,
|
|
)
|
|
|
|
changed = gamepad.update()
|
|
|
|
assert updated_handles == [42]
|
|
assert changed is True
|
|
assert gamepad.active_instance_id == 9
|
|
assert gamepad.sdl_type == SDL_GAMEPAD_TYPE_PS5
|
|
assert gamepad.update() is False
|
|
gamepad.close()
|
|
|
|
|
|
def test_native_gamepad_reports_sdl_discovery_error(monkeypatch: MonkeyPatch) -> None:
|
|
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_find", lambda: None)
|
|
monkeypatch.setattr(
|
|
native_gamepad._library,
|
|
"portproton_gamepad_get_error",
|
|
lambda: b"SDL gamepad initialization failed",
|
|
)
|
|
|
|
with raises(GamepadBackendError, match="SDL gamepad initialization failed"):
|
|
native_gamepad.find_gamepad()
|
|
|
|
|
|
def test_native_gamepad_absence_is_not_an_error(monkeypatch: MonkeyPatch) -> None:
|
|
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_find", lambda: None)
|
|
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_get_error", lambda: b"")
|
|
|
|
assert native_gamepad.find_gamepad() is None
|
|
|
|
|
|
def test_repeated_gamepad_backend_error_is_logged_once(monkeypatch: MonkeyPatch) -> None:
|
|
logged_errors: list[tuple[object, ...]] = []
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._last_gamepad_error = None
|
|
|
|
def fail_discovery() -> None:
|
|
raise GamepadBackendError("SDL initialization failed")
|
|
|
|
monkeypatch.setattr(input_runtime, "find_gamepad", fail_discovery)
|
|
monkeypatch.setattr(
|
|
input_runtime.logger,
|
|
"error",
|
|
lambda *args, **_kwargs: logged_errors.append(args),
|
|
)
|
|
|
|
assert manager.find_gamepad() is None
|
|
assert manager.find_gamepad() is None
|
|
|
|
assert len(logged_errors) == 1
|
|
|
|
|
|
def test_qt_event_to_input_key_supports_cyrillic() -> None:
|
|
event = cast(
|
|
QEvent,
|
|
SimpleNamespace(
|
|
nativeScanCode=lambda: 0,
|
|
text=lambda: "Я",
|
|
key=lambda: 0,
|
|
),
|
|
)
|
|
manager = InputManager.__new__(InputManager)
|
|
|
|
assert manager._qt_event_to_input_key(event) == ord("я")
|
|
|
|
|
|
def test_sdl_dpad_vertical_directions() -> None:
|
|
emitted: list[tuple[int, int, float]] = []
|
|
pressed_button = SDL_GAMEPAD_BUTTON_DPAD_UP
|
|
gamepad = cast(
|
|
SDLGamepad,
|
|
SimpleNamespace(get_button=lambda button: int(button == pressed_button)),
|
|
)
|
|
manager = InputManager.__new__(InputManager)
|
|
QObject.__init__(manager)
|
|
manager._hat_states = {}
|
|
manager.mouse_emulation_enabled = False
|
|
manager.emulation_active = False
|
|
manager.emulation_triggered = False
|
|
manager.dpad_moved.connect(lambda code, value, now: emitted.append((code, value, now)))
|
|
|
|
InputManager._poll_hat_events(manager, gamepad, 1.0)
|
|
pressed_button = SDL_GAMEPAD_BUTTON_DPAD_DOWN
|
|
InputManager._poll_hat_events(manager, gamepad, 2.0)
|
|
|
|
assert emitted == [(PAD_DPAD_Y, -1, 1.0), (PAD_DPAD_Y, 1, 2.0)]
|
|
|
|
|
|
def test_disabling_mouse_emulation_keeps_gamepad_events_working() -> None:
|
|
emitted: list[tuple[int, int]] = []
|
|
manager = InputManager.__new__(InputManager)
|
|
QObject.__init__(manager)
|
|
manager._button_states = {}
|
|
manager.mouse_emulation_enabled = True
|
|
manager.emulation_active = True
|
|
manager.emulation_triggered = True
|
|
manager.start_held = True
|
|
manager.select_held = False
|
|
manager.pending_menu_fullscreen_time = 0.0
|
|
manager.button_event.connect(lambda code, value: emitted.append((code, value)))
|
|
|
|
manager._handle_button_value(0, PAD_BUTTON_SELECT, 1, 1.0)
|
|
manager._handle_button_value(1, PAD_BUTTON_SOUTH, 1, 2.0)
|
|
|
|
assert manager.emulation_triggered is False
|
|
assert emitted == [(PAD_BUTTON_SOUTH, 1)]
|
|
|
|
|
|
class DummyCard(QFrame):
|
|
def __init__(self, parent: QWidget, x_pos: int) -> None:
|
|
super().__init__(parent)
|
|
self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
|
|
self.setGeometry(x_pos, 0, 10, 10)
|
|
|
|
|
|
def test_game_card_navigation_skips_hidden_cards(monkeypatch: MonkeyPatch) -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
container = QWidget()
|
|
container.show()
|
|
|
|
next_card = DummyCard(container, NEXT_CARD_X)
|
|
hidden_card = DummyCard(container, HIDDEN_CARD_X)
|
|
first_card = DummyCard(container, FIRST_CARD_X)
|
|
first_card.show()
|
|
hidden_card.hide()
|
|
next_card.show()
|
|
app.processEvents()
|
|
|
|
monkeypatch.setattr(input_manager, "AnimatedCard", DummyCard)
|
|
monkeypatch.setattr(input_dpad, "AnimatedCard", DummyCard)
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(MainWindowProtocol, SimpleNamespace(tabButtons={0: QWidget()}))
|
|
|
|
first_card.setFocus(Qt.FocusReason.OtherFocusReason)
|
|
manager._navigate_game_cards(container, 0, PAD_DPAD_X, 1)
|
|
|
|
assert QApplication.focusWidget() is next_card
|
|
|
|
manager._navigate_game_cards(container, 0, PAD_DPAD_X, -1)
|
|
|
|
assert QApplication.focusWidget() is first_card
|
|
|
|
|
|
def test_card_grid_navigation_uses_visual_rows() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
container = QWidget()
|
|
container.show()
|
|
|
|
bottom_right = DummyCard(container, NEXT_CARD_X)
|
|
bottom_right.move(NEXT_CARD_X, 20)
|
|
top_left = DummyCard(container, FIRST_CARD_X)
|
|
bottom_left = DummyCard(container, FIRST_CARD_X)
|
|
bottom_left.move(FIRST_CARD_X, 20)
|
|
top_right = DummyCard(container, NEXT_CARD_X)
|
|
for card in (bottom_right, top_left, bottom_left, top_right):
|
|
card.show()
|
|
app.processEvents()
|
|
|
|
manager = InputManager.__new__(InputManager)
|
|
top_left.setFocus(Qt.FocusReason.OtherFocusReason)
|
|
|
|
assert manager._navigate_card_grid(
|
|
[bottom_right, top_left, bottom_left, top_right], PAD_DPAD_X, 1
|
|
)
|
|
assert QApplication.focusWidget() is top_right
|
|
|
|
assert manager._navigate_card_grid(
|
|
[bottom_right, top_left, bottom_left, top_right], PAD_DPAD_Y, 1
|
|
)
|
|
assert QApplication.focusWidget() is bottom_right
|
|
|
|
|
|
def test_horizontal_library_navigation_wraps_at_both_ends() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
container = QWidget()
|
|
layout = QHBoxLayout(container)
|
|
cards: list[QWidget] = [QPushButton() for _index in range(3)]
|
|
for card in cards:
|
|
layout.addWidget(card)
|
|
card.show()
|
|
container.show()
|
|
app.processEvents()
|
|
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(
|
|
game_library_manager=SimpleNamespace(
|
|
layout_mode="horizontal",
|
|
gamesListLayout=layout,
|
|
)
|
|
),
|
|
)
|
|
cards[-1].setFocus(Qt.FocusReason.OtherFocusReason)
|
|
|
|
assert manager._navigate_horizontal_library(cards, 0, PAD_DPAD_X, 1)
|
|
assert QApplication.focusWidget() is cards[0]
|
|
|
|
assert manager._navigate_horizontal_library(cards, 0, PAD_DPAD_X, -1)
|
|
assert QApplication.focusWidget() is cards[-1]
|
|
|
|
tile = FullLibraryTile(_tile_theme())
|
|
tile.setParent(container)
|
|
layout.addWidget(tile)
|
|
tile.show()
|
|
manager._parent.game_library_manager.layout_mode = "horizontal_top"
|
|
manager._parent.game_library_manager.fullLibraryTile = tile
|
|
navigable_cards = [*cards, tile]
|
|
assert manager._navigate_horizontal_library(navigable_cards, 0, PAD_DPAD_X, 1)
|
|
assert QApplication.focusWidget() is tile
|
|
|
|
assert manager._navigate_horizontal_library(navigable_cards, 0, PAD_DPAD_X, -1)
|
|
assert QApplication.focusWidget() is cards[-1]
|
|
|
|
assert manager._navigate_horizontal_library(navigable_cards, 0, PAD_DPAD_X, 1)
|
|
assert QApplication.focusWidget() is tile
|
|
|
|
assert manager._navigate_horizontal_library(navigable_cards, 0, PAD_DPAD_X, 1)
|
|
assert QApplication.focusWidget() is cards[0]
|
|
|
|
|
|
def test_horizontal_autoinstall_navigation_uses_its_layout() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
container = QWidget()
|
|
layout = QHBoxLayout(container)
|
|
cards: list[QWidget] = [QPushButton() for _index in range(3)]
|
|
for card in cards:
|
|
layout.addWidget(card)
|
|
card.show()
|
|
container.show()
|
|
app.processEvents()
|
|
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(
|
|
theme=SimpleNamespace(LIBRARY_LAYOUT_MODE="horizontal"),
|
|
autoInstallContainerLayout=layout,
|
|
),
|
|
)
|
|
cards[0].setFocus(Qt.FocusReason.OtherFocusReason)
|
|
|
|
assert manager._navigate_horizontal_library(cards, 1, PAD_DPAD_X, 1)
|
|
assert QApplication.focusWidget() is cards[1]
|
|
|
|
|
|
def test_full_library_tile_arrow_does_not_switch_tabs() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
tile = FullLibraryTile(_tile_theme())
|
|
tile.show()
|
|
tile.setFocus(Qt.FocusReason.OtherFocusReason)
|
|
app.processEvents()
|
|
manager = InputManager.__new__(InputManager)
|
|
manager.file_explorer = None
|
|
switch_tab = MagicMock()
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(switchTab=switch_tab),
|
|
)
|
|
|
|
assert not manager._handle_input_tab_key(KEY_LEFT)
|
|
switch_tab.assert_not_called()
|
|
|
|
|
|
def test_backspace_uses_standard_back_navigation() -> None:
|
|
manager = InputManager.__new__(InputManager)
|
|
standard_back = MagicMock()
|
|
cast(Any, manager)._handle_standard_back = standard_back
|
|
|
|
assert manager._handle_input_back_key(QWidget())
|
|
standard_back.assert_called_once_with()
|
|
|
|
|
|
def test_library_toolbar_navigation_includes_delete_missing_button() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
toolbar = QWidget()
|
|
toolbar.show()
|
|
|
|
widgets = []
|
|
for _index in range(5):
|
|
widget = QWidget(toolbar)
|
|
widget.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
|
|
widget.show()
|
|
widgets.append(widget)
|
|
app.processEvents()
|
|
|
|
parent = SimpleNamespace(
|
|
quickLaunchButton=widgets[0],
|
|
addGameButton=widgets[1],
|
|
searchEdit=widgets[2],
|
|
refreshButton=widgets[3],
|
|
deleteMissingExeButton=widgets[4],
|
|
libraryControlsButton=QWidget(toolbar),
|
|
stackedWidget=QStackedWidget(),
|
|
tabButtons={0: QWidget()},
|
|
)
|
|
parent.stackedWidget.addWidget(QWidget())
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(MainWindowProtocol, parent)
|
|
|
|
widgets[3].setFocus(Qt.FocusReason.OtherFocusReason)
|
|
handled = manager._handle_toolbar_navigation(PAD_DPAD_X, 1)
|
|
|
|
assert handled is True
|
|
assert QApplication.focusWidget() is widgets[4]
|
|
|
|
|
|
def test_library_filter_navigation_includes_only_installed_checkbox() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
controls = QWidget()
|
|
controls.show()
|
|
widgets = [
|
|
QComboBox(controls),
|
|
QComboBox(controls),
|
|
QCheckBox(controls),
|
|
QComboBox(controls),
|
|
]
|
|
for widget in widgets:
|
|
widget.show()
|
|
app.processEvents()
|
|
|
|
parent = SimpleNamespace(
|
|
libraryControlsWidget=controls,
|
|
gamesSortCombo=widgets[0],
|
|
gamesDisplayCombo=widgets[1],
|
|
onlyInstalledCheckBox=widgets[2],
|
|
gamesBadgeViewCombo=widgets[3],
|
|
)
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(MainWindowProtocol, parent)
|
|
|
|
assert manager._get_library_filter_widgets() == widgets
|
|
|
|
|
|
def test_library_size_adjustment_uses_original_step() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
slider = QSlider()
|
|
slider.setRange(100, 300)
|
|
slider.setValue(200)
|
|
slider.setTickInterval(25)
|
|
callbacks: list[bool] = []
|
|
parent = SimpleNamespace(
|
|
stackedWidget=SimpleNamespace(currentIndex=lambda: 0),
|
|
system_tab_index=4,
|
|
game_library_manager=SimpleNamespace(sizeSlider=slider),
|
|
on_slider_released=lambda: callbacks.append(True),
|
|
)
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(MainWindowProtocol, parent)
|
|
|
|
assert manager._adjust_active_slider(1)
|
|
assert slider.value() == 210
|
|
assert callbacks == [True]
|
|
assert app is not None
|
|
|
|
|
|
def test_system_volume_adjustment_uses_original_step() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
section_stack = QStackedWidget()
|
|
for _index in range(5):
|
|
section_stack.addWidget(QWidget())
|
|
section_stack.setCurrentIndex(4)
|
|
slider = QSlider()
|
|
slider.setRange(0, 100)
|
|
slider.setValue(50)
|
|
slider.setPageStep(17)
|
|
callbacks: list[bool] = []
|
|
parent = SimpleNamespace(
|
|
stackedWidget=SimpleNamespace(currentIndex=lambda: 3),
|
|
system_tab_index=3,
|
|
systemSectionStack=section_stack,
|
|
audioVolumeSlider=slider,
|
|
_applySelectedAudioVolume=lambda: callbacks.append(True),
|
|
)
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(MainWindowProtocol, parent)
|
|
|
|
assert manager._adjust_active_slider(-1)
|
|
assert slider.value() == 45
|
|
assert callbacks == [True]
|
|
assert app is not None
|
|
|
|
|
|
def test_context_menu_button_routes_to_table_current_item() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
table = QTableWidget(1, 1)
|
|
table.setItem(0, 0, QTableWidgetItem("Game"))
|
|
table.setCurrentCell(0, 0)
|
|
emitted = []
|
|
table.customContextMenuRequested.connect(emitted.append)
|
|
manager = InputManager.__new__(InputManager)
|
|
context_button = next(iter(input_manager.BUTTONS["context_menu"]))
|
|
|
|
assert manager._open_focused_context_menu(table, context_button)
|
|
item = table.item(0, 0)
|
|
assert item is not None
|
|
assert emitted == [table.visualItemRect(item).center()]
|
|
assert app is not None
|
|
|
|
|
|
def test_context_menu_button_ignores_widget_without_custom_menu() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
widget = QWidget()
|
|
manager = InputManager.__new__(InputManager)
|
|
context_button = next(iter(input_manager.BUTTONS["context_menu"]))
|
|
|
|
assert not manager._open_focused_context_menu(widget, context_button)
|
|
assert app is not None
|
|
|
|
|
|
def test_popup_menu_buttons_activate_and_close_menu() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
menu = QMenu()
|
|
action = menu.addAction("Launch")
|
|
triggered = []
|
|
action.triggered.connect(lambda: triggered.append(True))
|
|
menu.setActiveAction(action)
|
|
manager = InputManager.__new__(InputManager)
|
|
confirm_button = next(iter(input_manager.BUTTONS["confirm"]))
|
|
back_button = next(iter(input_manager.BUTTONS["back"]))
|
|
|
|
assert manager._handle_popup_menu_button(menu, confirm_button)
|
|
assert manager._handle_popup_menu_button(menu, back_button)
|
|
assert triggered == [True]
|
|
assert app is not None
|
|
|
|
|
|
def test_confirm_button_opens_combo_popup() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
combo = QComboBox()
|
|
combo.addItems(["First", "Second"])
|
|
manager = InputManager.__new__(InputManager)
|
|
confirm_button = next(iter(input_manager.BUTTONS["confirm"]))
|
|
|
|
assert manager._handle_combo_button(combo, confirm_button)
|
|
assert combo.view().isVisible()
|
|
combo.hidePopup()
|
|
assert app is not None
|
|
|
|
|
|
def test_user_conf_table_combo_gets_focus_and_opens() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
table = QTableWidget(1, 2)
|
|
combo = QComboBox()
|
|
combo.addItems(["Default", "Yes", "No"])
|
|
table.setCellWidget(0, 1, combo)
|
|
table.setCurrentCell(0, 1)
|
|
table.show()
|
|
combo.show()
|
|
app.processEvents()
|
|
manager = InputManager.__new__(InputManager)
|
|
manager.settings_dialog = SimpleNamespace(settings_table=table)
|
|
|
|
manager._focus_settings_advanced_value_widget(table, 0)
|
|
assert QApplication.focusWidget() is combo
|
|
assert manager.handle_table_confirm(table)
|
|
assert combo.view().isVisible()
|
|
combo.hidePopup()
|
|
assert app is not None
|
|
|
|
|
|
def test_back_button_closes_visible_combo_popup() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
combo = QComboBox()
|
|
combo.addItems(["First", "Second"])
|
|
combo.showPopup()
|
|
manager = InputManager.__new__(InputManager)
|
|
back_button = next(iter(input_manager.BUTTONS["back"]))
|
|
|
|
assert manager._handle_combo_button(combo, back_button)
|
|
assert not combo.view().isVisible()
|
|
assert app is not None
|
|
|
|
|
|
def test_list_confirm_emits_selection_actions() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
view = QListView()
|
|
model = QStringListModel(["First", "Second"])
|
|
view.setModel(model)
|
|
view.setCurrentIndex(model.index(1, 0))
|
|
activated = []
|
|
clicked = []
|
|
view.activated.connect(activated.append)
|
|
view.clicked.connect(clicked.append)
|
|
manager = InputManager.__new__(InputManager)
|
|
|
|
manager._activate_list_view_selection(view)
|
|
|
|
assert [index.row() for index in activated] == [1]
|
|
assert [index.row() for index in clicked] == [1]
|
|
assert app is not None
|
|
|
|
|
|
def test_list_back_preserves_dialog_fallthrough() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
view = QListView()
|
|
model = QStringListModel(["First"])
|
|
view.setModel(model)
|
|
view.setCurrentIndex(model.index(0, 0))
|
|
manager = InputManager.__new__(InputManager)
|
|
back_button = next(iter(input_manager.BUTTONS["back"]))
|
|
|
|
assert not manager._handle_list_view_button(view, back_button)
|
|
assert not view.selectionModel().hasSelection()
|
|
assert app is not None
|
|
|
|
|
|
def test_system_table_button_routes_action_and_sound(monkeypatch: MonkeyPatch) -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
actions = []
|
|
sounds = []
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(
|
|
handleSystemTableGamepadAction=lambda _table, action: actions.append(action) or True,
|
|
),
|
|
)
|
|
monkeypatch.setattr(input_manager, "SoundManager", lambda: SimpleNamespace(play=sounds.append))
|
|
monkeypatch.setattr(input_buttons, "SoundManager", lambda: SimpleNamespace(play=sounds.append))
|
|
table = QTableWidget()
|
|
back_button = next(iter(input_manager.BUTTONS["back"]))
|
|
|
|
assert manager._handle_system_table_button(table, back_button)
|
|
assert actions == ["back"]
|
|
assert sounds == ["back"]
|
|
assert app is not None
|
|
|
|
|
|
def test_confirm_button_activates_table_callback(monkeypatch: MonkeyPatch) -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
table = QTableWidget(1, 1)
|
|
table.setItem(0, 0, QTableWidgetItem("Game"))
|
|
table.setCurrentCell(0, 0)
|
|
activated = []
|
|
table._on_confirm_callback = lambda _table, row, column: activated.append( # type: ignore[attr-defined]
|
|
(row, column)
|
|
)
|
|
manager = InputManager.__new__(InputManager)
|
|
monkeypatch.setattr(
|
|
input_buttons, "SoundManager", lambda: SimpleNamespace(play=lambda _sound: None)
|
|
)
|
|
confirm_button = next(iter(input_manager.BUTTONS["confirm"]))
|
|
|
|
assert manager._handle_table_button(table, confirm_button)
|
|
|
|
assert activated == [(0, 0)]
|
|
assert app is not None
|
|
|
|
|
|
def test_confirm_button_routes_line_edit_to_keyboard() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
shown_for = []
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(keyboard=SimpleNamespace(show_for_widget=shown_for.append)),
|
|
)
|
|
line_edit = QLineEdit()
|
|
confirm_button = next(iter(input_manager.BUTTONS["confirm"]))
|
|
|
|
assert manager._route_button_to_text_input(QWidget(), line_edit, confirm_button)
|
|
assert shown_for == [line_edit]
|
|
assert app is not None
|
|
|
|
|
|
def test_prev_dir_button_focuses_search_for_current_tab() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
window = QWidget()
|
|
search = QLineEdit(window)
|
|
window.show()
|
|
search.show()
|
|
app.processEvents()
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(
|
|
keyboard=None,
|
|
stackedWidget=SimpleNamespace(currentIndex=lambda: 0),
|
|
searchEdit=search,
|
|
),
|
|
)
|
|
prev_dir_button = next(iter(input_manager.BUTTONS["prev_dir"]))
|
|
|
|
assert manager._route_button_to_text_input(window, None, prev_dir_button)
|
|
assert search.hasFocus()
|
|
|
|
|
|
def test_system_quick_button_routes_add_game_and_sound(monkeypatch: MonkeyPatch) -> None:
|
|
actions = []
|
|
sounds = []
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(handleSystemGamepadAction=lambda action: actions.append(action) or True),
|
|
)
|
|
monkeypatch.setattr(input_manager, "SoundManager", lambda: SimpleNamespace(play=sounds.append))
|
|
monkeypatch.setattr(input_buttons, "SoundManager", lambda: SimpleNamespace(play=sounds.append))
|
|
add_button = next(iter(input_manager.BUTTONS["add_game"]))
|
|
|
|
assert manager._handle_system_quick_button(add_button)
|
|
assert actions == ["add_game"]
|
|
assert sounds == ["open"]
|
|
|
|
|
|
def test_standard_confirm_activates_focused_widget(monkeypatch: MonkeyPatch) -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
activations = []
|
|
sounds = []
|
|
focused = QWidget()
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(activateFocusedWidget=lambda: activations.append(True)),
|
|
)
|
|
monkeypatch.setattr(
|
|
input_manager,
|
|
"SoundManager",
|
|
lambda: SimpleNamespace(play_widget_sound=sounds.append),
|
|
)
|
|
monkeypatch.setattr(
|
|
input_buttons,
|
|
"SoundManager",
|
|
lambda: SimpleNamespace(play_widget_sound=sounds.append),
|
|
)
|
|
confirm_button = next(iter(input_manager.BUTTONS["confirm"]))
|
|
|
|
manager._handle_standard_button(focused, confirm_button, 1)
|
|
|
|
assert activations == []
|
|
app.processEvents()
|
|
assert activations == [True]
|
|
assert sounds == [focused]
|
|
|
|
|
|
def test_guide_select_combination_refreshes_games() -> None:
|
|
timer_events: list[str | int] = []
|
|
refreshes: list[bool] = []
|
|
manager: Any = InputManager.__new__(InputManager)
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(refreshGames=lambda: refreshes.append(True)),
|
|
)
|
|
manager.guide_timer = SimpleNamespace(
|
|
start=lambda timeout: timer_events.append(timeout),
|
|
stop=lambda: timer_events.append("stop"),
|
|
)
|
|
manager.guide_combination_timeout = 0.3
|
|
manager.guide_held = False
|
|
manager.guide_pressed_time = 0
|
|
manager.select_pressed_time = 0
|
|
manager.in_guide_combination_attempt = False
|
|
guide_button = next(iter(input_manager.BUTTONS["guide"]))
|
|
menu_button = next(iter(input_manager.BUTTONS["menu"]))
|
|
|
|
assert manager._handle_guide_combination(guide_button, 1.0)
|
|
assert manager._handle_guide_combination(menu_button, 1.2)
|
|
|
|
assert timer_events == [300, "stop"]
|
|
assert refreshes == [True]
|
|
assert manager.guide_held is False
|
|
|
|
|
|
def test_dialog_surface_receives_connected_input_signals() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
button_events: list[tuple[int, int]] = []
|
|
dpad_events: list[tuple[int, int, float]] = []
|
|
default_events: list[tuple[int, int]] = []
|
|
manager: Any = InputManager.__new__(InputManager)
|
|
QObject.__init__(manager)
|
|
manager._input_surfaces = []
|
|
manager._input_surface_base_state = None
|
|
manager._gamepad_handling_enabled = False
|
|
manager.dpad_timer = SimpleNamespace(stop=lambda: None)
|
|
manager.current_dpad_code = None
|
|
manager.current_dpad_value = 0
|
|
manager._handle_default_button = lambda code, value: default_events.append((code, value))
|
|
manager.button_event.connect(manager.handle_button_slot)
|
|
manager.dpad_moved.connect(manager.handle_dpad_slot)
|
|
|
|
manager._setup_mode_handlers(
|
|
object(),
|
|
lambda code, value: button_events.append((code, value)),
|
|
lambda code, value, now: dpad_events.append((code, value, now)),
|
|
"settings_dialog",
|
|
)
|
|
manager.button_event.emit(1, 1)
|
|
manager.dpad_moved.emit(PAD_DPAD_Y, 1, 2.0)
|
|
|
|
assert button_events == [(1, 1)]
|
|
assert dpad_events == [(PAD_DPAD_Y, 1, 2.0)]
|
|
assert default_events == []
|
|
manager._restore_original_handlers("settings_dialog")
|
|
manager.button_event.emit(2, 1)
|
|
assert default_events == [(2, 1)]
|
|
assert app is not None
|
|
|
|
|
|
def test_gamepad_ui_events_are_queued_after_polling() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
events: list[tuple[int, int]] = []
|
|
manager: Any = InputManager.__new__(InputManager)
|
|
QObject.__init__(manager)
|
|
manager._input_surfaces = []
|
|
manager._handle_default_button = lambda code, value: events.append((code, value))
|
|
manager.button_event.connect(
|
|
manager.handle_button_slot,
|
|
Qt.ConnectionType.QueuedConnection,
|
|
)
|
|
|
|
manager.button_event.emit(1, 1)
|
|
|
|
assert events == []
|
|
app.processEvents()
|
|
assert events == [(1, 1)]
|
|
|
|
|
|
def test_dialog_surface_disconnects_owned_callbacks() -> None:
|
|
callback_events: list[tuple[int, ...]] = []
|
|
manager: Any = InputManager.__new__(InputManager)
|
|
QObject.__init__(manager)
|
|
manager._input_surfaces = []
|
|
manager._input_surface_base_state = None
|
|
manager._gamepad_handling_enabled = False
|
|
manager.dpad_timer = SimpleNamespace(stop=lambda: None)
|
|
manager.current_dpad_code = None
|
|
manager.current_dpad_value = 0
|
|
manager._setup_mode_handlers(object(), lambda *_args: None, lambda *_args: None, "dialog")
|
|
manager.connect_surface_updates("dialog", lambda *args: callback_events.append(args))
|
|
|
|
manager.button_event.emit(1, 1)
|
|
manager._restore_original_handlers("dialog")
|
|
manager.button_event.emit(2, 1)
|
|
manager.dpad_moved.emit(PAD_DPAD_Y, 1, 2.0)
|
|
|
|
assert callback_events == [(1, 1)]
|
|
|
|
|
|
def test_nested_input_surfaces_restore_base_state() -> None:
|
|
manager: Any = InputManager.__new__(InputManager)
|
|
manager._input_surfaces = []
|
|
manager._input_surface_base_state = None
|
|
manager._gamepad_handling_enabled = False
|
|
manager.dpad_timer = SimpleNamespace(stop=lambda: None)
|
|
manager.current_dpad_code = None
|
|
manager.current_dpad_value = 0
|
|
first_events: list[int] = []
|
|
second_events: list[int] = []
|
|
|
|
manager._setup_mode_handlers(
|
|
object(), lambda code, _value: first_events.append(code), lambda *_args: None,
|
|
"settings_dialog",
|
|
)
|
|
manager._setup_mode_handlers(
|
|
object(), lambda code, _value: second_events.append(code), lambda *_args: None,
|
|
"file_explorer",
|
|
)
|
|
manager._restore_original_handlers("settings_dialog")
|
|
assert manager._route_surface_button(1, 1)
|
|
assert first_events == []
|
|
assert second_events == [1]
|
|
assert manager._gamepad_handling_enabled is True
|
|
|
|
manager._restore_original_handlers("file_explorer")
|
|
assert manager._gamepad_handling_enabled is False
|
|
assert not manager._route_surface_button(2, 1)
|
|
|
|
|
|
def test_gamepad_polling_uses_qt_event_loop() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
checks: list[bool] = []
|
|
manager: Any = InputManager.__new__(InputManager)
|
|
QObject.__init__(manager)
|
|
manager.check_gamepad = lambda: checks.append(True)
|
|
manager.gamepad_hotplug.connect(lambda _action: None)
|
|
|
|
manager.init_gamepad()
|
|
|
|
assert checks == [True]
|
|
assert manager.gamepad_poll_timer.isActive()
|
|
assert manager.gamepad_poll_timer.interval() == 10
|
|
assert manager.gamepad_poll_timer.thread() is manager.thread()
|
|
manager.gamepad_poll_timer.stop()
|
|
assert app is not None
|
|
|
|
|
|
def test_gamepad_poll_reports_disconnected_device() -> None:
|
|
actions: list[str] = []
|
|
updates: list[bool] = []
|
|
manager: Any = InputManager.__new__(InputManager)
|
|
QObject.__init__(manager)
|
|
manager.running = True
|
|
manager._gamepad_polling_suspended = False
|
|
manager.gamepad = SimpleNamespace(
|
|
update=lambda: updates.append(True),
|
|
connected=lambda: False,
|
|
)
|
|
manager.gamepad_hotplug.connect(actions.append)
|
|
|
|
manager._poll_gamepad()
|
|
|
|
assert updates == [True]
|
|
assert actions == ["remove"]
|
|
|
|
|
|
def test_gamepad_poll_refreshes_type_when_active_device_changes(
|
|
monkeypatch: MonkeyPatch,
|
|
) -> None:
|
|
refreshed: list[bool] = []
|
|
manager: Any = InputManager.__new__(InputManager)
|
|
manager.running = True
|
|
manager._gamepad_polling_suspended = False
|
|
manager.gamepad = SimpleNamespace(
|
|
update=lambda: True,
|
|
connected=lambda: True,
|
|
active_instance_id=7,
|
|
sdl_type=SDL_GAMEPAD_TYPE_PS5,
|
|
)
|
|
manager._reset_input_state = lambda: setattr(
|
|
manager, "gamepad_type", GamepadType.UNKNOWN,
|
|
)
|
|
manager._refresh_gamepad_ui = lambda: refreshed.append(True)
|
|
manager._poll_button_events = lambda *_args: None
|
|
manager._handle_pending_menu_fullscreen = lambda *_args: None
|
|
manager._poll_hat_events = lambda *_args: None
|
|
manager._poll_axis_events = lambda *_args: None
|
|
manager.last_update = 0.0
|
|
manager.update_interval = float("inf")
|
|
monkeypatch.setattr(input_runtime.gamepad_config, "get_gamepad_type", lambda: "auto")
|
|
|
|
manager._poll_gamepad()
|
|
|
|
assert manager.gamepad_type == GamepadType.PLAYSTATION
|
|
assert refreshed == [True]
|
|
|
|
|
|
def test_suspend_gamepad_polling_sets_runtime_guard() -> None:
|
|
manager: Any = InputManager.__new__(InputManager)
|
|
manager._gamepad_polling_suspended = False
|
|
manager._gamepad_handling_enabled = True
|
|
manager.dpad_timer = SimpleNamespace(stop=lambda: None)
|
|
manager.nav_timer = SimpleNamespace(stop=lambda: None)
|
|
|
|
manager.suspend_gamepad_polling()
|
|
|
|
assert manager._gamepad_polling_suspended is True
|
|
assert manager._gamepad_handling_enabled is False
|
|
|
|
|
|
def test_dialog_dpad_moves_focus_forward() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
dialog = QDialog()
|
|
first_button = QPushButton(dialog)
|
|
second_button = QPushButton(dialog)
|
|
first_button.move(0, 0)
|
|
second_button.move(0, 30)
|
|
dialog.show()
|
|
first_button.show()
|
|
second_button.show()
|
|
app.processEvents()
|
|
first_button.setFocus(Qt.FocusReason.OtherFocusReason)
|
|
manager = InputManager.__new__(InputManager)
|
|
|
|
assert manager._handle_dialog_dpad(dialog, PAD_DPAD_Y, 1)
|
|
assert QApplication.focusWidget() is second_button
|
|
|
|
|
|
def test_list_dpad_moves_current_row() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
view = QListView()
|
|
model = QStringListModel(["First", "Second"])
|
|
view.setModel(model)
|
|
view.setCurrentIndex(model.index(0, 0))
|
|
manager = InputManager.__new__(InputManager)
|
|
|
|
assert manager._handle_list_dpad(view, PAD_DPAD_Y, 1)
|
|
assert view.currentIndex().row() == 1
|
|
assert app is not None
|
|
|
|
|
|
def test_first_card_row_moves_focus_to_toolbar(monkeypatch: MonkeyPatch) -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
container = QWidget()
|
|
container.show()
|
|
card = DummyCard(container, FIRST_CARD_X)
|
|
toolbar_button = QWidget(container)
|
|
toolbar_button.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
|
|
toolbar_button.move(0, 30)
|
|
toolbar_button.show()
|
|
card.show()
|
|
app.processEvents()
|
|
card.setFocus(Qt.FocusReason.OtherFocusReason)
|
|
monkeypatch.setattr(input_manager, "AnimatedCard", DummyCard)
|
|
monkeypatch.setattr(input_dpad, "AnimatedCard", DummyCard)
|
|
parent = SimpleNamespace(
|
|
stackedWidget=SimpleNamespace(currentIndex=lambda: 0),
|
|
gamesListWidget=container,
|
|
)
|
|
manager: Any = InputManager.__new__(InputManager)
|
|
manager._parent = cast(MainWindowProtocol, parent)
|
|
manager._get_library_toolbar_widgets = lambda: [toolbar_button]
|
|
|
|
assert manager._focus_toolbar_from_first_card(PAD_DPAD_Y, -1)
|
|
assert QApplication.focusWidget() is toolbar_button
|
|
|
|
|
|
def test_system_section_horizontal_focuses_selected_button() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
window = QWidget()
|
|
section_stack = QStackedWidget(window)
|
|
section_stack.addWidget(QWidget())
|
|
section_stack.addWidget(QWidget())
|
|
section_buttons = [QPushButton(window), QPushButton(window)]
|
|
section_buttons[1].move(0, 30)
|
|
window.show()
|
|
section_buttons[0].show()
|
|
section_buttons[1].show()
|
|
app.processEvents()
|
|
switched: list[int] = []
|
|
|
|
def switch_relative(step: int) -> bool:
|
|
switched.append(step)
|
|
section_stack.setCurrentIndex(1)
|
|
return True
|
|
|
|
parent = SimpleNamespace(
|
|
stackedWidget=SimpleNamespace(currentIndex=lambda: 3),
|
|
system_tab_index=3,
|
|
switchSystemSectionRelative=switch_relative,
|
|
systemSectionStack=section_stack,
|
|
systemSectionButtons=section_buttons,
|
|
)
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(MainWindowProtocol, parent)
|
|
|
|
assert manager._handle_system_section_horizontal(PAD_DPAD_X, 1, True)
|
|
assert switched == [1]
|
|
assert section_buttons[1].hasFocus()
|
|
assert app is not None
|
|
|
|
|
|
def test_detail_page_dpad_uses_visual_button_rows(monkeypatch: MonkeyPatch) -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
page = QWidget()
|
|
buttons = [QPushButton(page) for _index in range(3)]
|
|
buttons[0].setGeometry(0, 0, 20, 20)
|
|
buttons[1].setGeometry(40, 0, 20, 20)
|
|
buttons[2].setGeometry(0, 40, 20, 20)
|
|
page.show()
|
|
for button in buttons:
|
|
button.show()
|
|
app.processEvents()
|
|
buttons[1].setFocus(Qt.FocusReason.OtherFocusReason)
|
|
monkeypatch.setattr(input_dpad, "AutoSizeButton", QPushButton)
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(
|
|
stackedWidget=SimpleNamespace(currentWidget=lambda: page),
|
|
currentDetailPage=page,
|
|
),
|
|
)
|
|
|
|
assert manager._handle_detail_page_dpad(PAD_DPAD_Y, 1)
|
|
assert QApplication.focusWidget() is buttons[2]
|
|
|
|
|
|
def test_page_vertical_dpad_moves_focus_forward() -> None:
|
|
app = QApplication.instance() or QApplication([])
|
|
page = QWidget()
|
|
first = QPushButton(page)
|
|
second = QPushButton(page)
|
|
second.move(0, 30)
|
|
page.show()
|
|
first.show()
|
|
second.show()
|
|
app.processEvents()
|
|
first.setFocus(Qt.FocusReason.OtherFocusReason)
|
|
manager = InputManager.__new__(InputManager)
|
|
manager._parent = cast(
|
|
MainWindowProtocol,
|
|
SimpleNamespace(stackedWidget=SimpleNamespace(currentWidget=lambda: page)),
|
|
)
|
|
|
|
assert manager._handle_page_vertical_dpad(PAD_DPAD_Y, 1)
|
|
assert QApplication.focusWidget() is second
|
|
|
|
|
|
def test_settings_grid_vertical_navigation_does_not_wrap_columns() -> None:
|
|
_app = QApplication.instance() or QApplication([])
|
|
dialog = QWidget()
|
|
checkboxes: list[QWidget] = [QCheckBox(dialog) for _index in range(4)]
|
|
for checkbox, position in zip(
|
|
checkboxes, ((0, 0), (100, 0), (0, 40), (100, 40)), strict=True
|
|
):
|
|
checkbox.move(*position)
|
|
manager = InputManager.__new__(InputManager)
|
|
manager.settings_dialog = dialog
|
|
|
|
assert manager._find_mangohud_vertical_grid_target(
|
|
checkboxes[0], 1, checkboxes
|
|
) is checkboxes[2]
|
|
assert manager._find_mangohud_vertical_grid_target(
|
|
checkboxes[2], 1, checkboxes
|
|
) is None
|
|
assert manager._find_mangohud_vertical_grid_target(
|
|
checkboxes[1], -1, checkboxes
|
|
) is None
|