@desklink/host 0.1.0

package/engine/vendor/inputtino/bindings/python/tests/test_pentablet.py

@@ -0,0 +1,198 @@
+"""Tests for pentablet.py."""
+
+import math
+import time
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from inputtino._core import PenTablet as CorePenTablet
+from inputtino.pentablet import (
+    DEFAULT_PEN_TABLET,
+    DeviceDefinition,
+    PenButtonType,
+    PenTablet,
+    PenToolType,
+)
+from tests.helpers import mark_practical
+
+
+@pytest.fixture
+def mock_core_tablet():
+    """Create a mock for CorePenTablet with basic functionality."""
+    with patch("inputtino._core.PenTablet") as mock_tablet_cls:
+        mock_instance = MagicMock(spec=CorePenTablet)
+        mock_tablet_cls.create.return_value = mock_instance
+        yield mock_instance
+
+
+def test_pen_tablet_creation_with_default_device():
+    """Test creating a pen tablet with default device definition."""
+    with patch("inputtino._core.PenTablet") as mock_tablet_cls:
+        PenTablet()
+
+        mock_tablet_cls.create.assert_called_once()
+        created_def = mock_tablet_cls.create.call_args[0][0]
+        assert created_def.name == DEFAULT_PEN_TABLET.name
+        assert created_def.vendor_id == DEFAULT_PEN_TABLET.vendor_id
+        assert created_def.product_id == DEFAULT_PEN_TABLET.product_id
+        assert created_def.version == DEFAULT_PEN_TABLET.version
+
+
+def test_pen_tablet_creation_with_custom_device():
+    """Test creating a pen tablet with custom device definition."""
+    custom_def = DeviceDefinition(
+        name="Custom Pen Tablet",
+        vendor_id=0x1234,
+        product_id=0x5678,
+        version=0x0001,
+        device_phys="/dev/input/test",
+        device_uniq="unique_id",
+    )
+
+    with patch("inputtino._core.PenTablet") as mock_tablet_cls:
+        PenTablet(custom_def)
+
+        mock_tablet_cls.create.assert_called_once()
+        created_def = mock_tablet_cls.create.call_args[0][0]
+        assert created_def.name == custom_def.name
+        assert created_def.vendor_id == custom_def.vendor_id
+        assert created_def.product_id == custom_def.product_id
+        assert created_def.version == custom_def.version
+        assert created_def.device_phys == custom_def.device_phys
+        assert created_def.device_uniq == custom_def.device_uniq
+
+
+def test_pen_tablet_place_tool(mock_core_tablet):
+    """Test placing a tool on the tablet surface."""
+    tablet = PenTablet()
+    tablet.place_tool(
+        PenToolType.PEN,
+        x=0.5,
+        y=0.5,
+        pressure=1.0,
+        distance=0.0,
+        tilt_x=45.0,
+        tilt_y=-45.0,
+    )
+
+    mock_core_tablet.place_tool.assert_called_once_with(
+        PenToolType.PEN, 0.5, 0.5, 1.0, 0.0, 45.0, -45.0
+    )
+
+
+def test_pen_tablet_set_button(mock_core_tablet):
+    """Test setting pen button states."""
+    tablet = PenTablet()
+
+    for button in [
+        PenButtonType.PRIMARY,
+        PenButtonType.SECONDARY,
+        PenButtonType.TERTIARY,
+    ]:
+        for pressed in (True, False):
+            tablet.set_button(button, pressed)
+            mock_core_tablet.set_btn.assert_called_with(button, pressed)
+
+
+def test_pen_tablet_nodes(mock_core_tablet):
+    """Test getting pen tablet device nodes."""
+    expected_nodes = ["/dev/input/event0", "/dev/input/pen0"]
+    mock_core_tablet.get_nodes.return_value = expected_nodes
+
+    tablet = PenTablet()
+    assert tablet.nodes == expected_nodes
+    mock_core_tablet.get_nodes.assert_called_once()
+
+
+def test_pen_tablet_creation_failure():
+    """Test handling of pen tablet creation failure."""
+    with patch("inputtino._core.PenTablet") as mock_tablet_cls:
+        mock_tablet_cls.create.side_effect = RuntimeError(
+            "Failed to create pen tablet device"
+        )
+
+        with pytest.raises(RuntimeError, match="Failed to create pen tablet device"):
+            PenTablet()
+
+
+@mark_practical
+def test_practical_pen_draw_circle():
+    """Test drawing a circle pattern with the pen tablet.
+
+    This practical test demonstrates:
+    1. Drawing a circle using the pen tool
+    2. Varying pressure based on position
+    3. Adding tilt effects
+
+    Note:
+        This test requires actual device access (/dev/uinput)
+        and may fail if run without proper permissions.
+    """
+    tablet = PenTablet()
+
+    # Ensure we have valid device nodes
+    assert len(tablet.nodes) > 0, "No pen tablet device nodes created"
+
+    # Give system time to register the device
+    time.sleep(0.1)
+
+    # Draw circle pattern
+    radius = 0.3  # 30% of tablet width
+    center_x = 0.5
+    center_y = 0.5
+    steps = 50
+    try:
+        for i in range(steps + 1):
+            angle = 2 * math.pi * i / steps
+            x = center_x + radius * math.cos(angle)
+            y = center_y + radius * math.sin(angle)
+
+            # Vary pressure based on position (higher on right side)
+            pressure = 0.5 + 0.5 * math.cos(angle)
+
+            # Add tilt effect (tilt towards center)
+            tilt_x = -30 * math.cos(angle)  # -30 to 30 degrees
+            tilt_y = -30 * math.sin(angle)  # -30 to 30 degrees
+
+            tablet.place_tool(
+                PenToolType.PEN,
+                x=x,
+                y=y,
+                pressure=pressure,
+                distance=0.0,  # Pen is touching surface
+                tilt_x=tilt_x,
+                tilt_y=tilt_y,
+            )
+            time.sleep(0.02)  # Small delay for smooth movement
+
+        # Test button presses at cardinal points
+        for angle in [0, math.pi / 2, math.pi, 3 * math.pi / 2]:
+            x = center_x + radius * math.cos(angle)
+            y = center_y + radius * math.sin(angle)
+
+            tablet.place_tool(
+                PenToolType.PEN,
+                x=x,
+                y=y,
+                pressure=1.0,
+                distance=0.0,
+                tilt_x=0,
+                tilt_y=0,
+            )
+            tablet.set_button(PenButtonType.PRIMARY, True)
+            time.sleep(0.1)
+            tablet.set_button(PenButtonType.PRIMARY, False)
+            time.sleep(0.1)
+
+    finally:
+        # Place tool at distance to indicate release
+        tablet.place_tool(
+            PenToolType.SAME_AS_BEFORE,
+            x=center_x,
+            y=center_y,
+            pressure=0.0,
+            distance=1.0,  # Pen is far from surface
+            tilt_x=0,
+            tilt_y=0,
+        )

package/engine/vendor/inputtino/bindings/python/tests/test_touchscreen.py

@@ -0,0 +1,144 @@
+"""Tests for touchscreen.py."""
+
+import time
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from inputtino._core import TouchScreen as CoreTouchScreen
+from inputtino.touchscreen import DeviceDefinition, TouchScreen
+from tests.helpers import mark_practical
+
+
+@pytest.fixture
+def mock_core_touchscreen():
+    """Create a mock for CoreTouchScreen with basic functionality."""
+    with patch("inputtino._core.TouchScreen") as mock_touchscreen_cls:
+        mock_instance = MagicMock(spec=CoreTouchScreen)
+        mock_touchscreen_cls.create.return_value = mock_instance
+        yield mock_instance
+
+
+def test_touchscreen_creation_with_default_device():
+    """Test creating a touchscreen with default device definition."""
+    with patch("inputtino._core.TouchScreen") as mock_touchscreen_cls:
+        TouchScreen()
+
+        mock_touchscreen_cls.create.assert_called_once()
+        created_def = mock_touchscreen_cls.create.call_args[0][0]
+        assert created_def.name == "Wolf (virtual) touchscreen"
+        assert created_def.vendor_id == 0xAB00
+        assert created_def.product_id == 0xAB03
+        assert created_def.version == 0xAB00
+
+
+def test_touchscreen_creation_with_custom_device():
+    """Test creating a touchscreen with custom device definition."""
+    custom_def = DeviceDefinition(
+        name="Custom TouchScreen",
+        vendor_id=0x1234,
+        product_id=0x5678,
+        version=0x0001,
+        device_phys="/dev/input/test",
+        device_uniq="unique_id",
+    )
+
+    with patch("inputtino._core.TouchScreen") as mock_touchscreen_cls:
+        TouchScreen(custom_def)
+
+        mock_touchscreen_cls.create.assert_called_once()
+        created_def = mock_touchscreen_cls.create.call_args[0][0]
+        assert created_def.name == custom_def.name
+        assert created_def.vendor_id == custom_def.vendor_id
+        assert created_def.product_id == custom_def.product_id
+        assert created_def.version == custom_def.version
+        assert created_def.device_phys == custom_def.device_phys
+        assert created_def.device_uniq == custom_def.device_uniq
+
+
+def test_touchscreen_finger_placement(mock_core_touchscreen):
+    """Test finger placement on touchscreen."""
+    touchscreen = TouchScreen()
+
+    # Test placing a finger with default pressure and orientation
+    touchscreen.place_finger(0, 0.5, 0.5)
+    mock_core_touchscreen.place_finger.assert_called_with(0, 0.5, 0.5, 1.0, 0)
+
+    # Test placing a finger with custom pressure and orientation
+    touchscreen.place_finger(1, 0.75, 0.25, 0.8, 45)
+    mock_core_touchscreen.place_finger.assert_called_with(1, 0.75, 0.25, 0.8, 45)
+
+
+def test_touchscreen_finger_release(mock_core_touchscreen):
+    """Test finger release from touchscreen."""
+    touchscreen = TouchScreen()
+    touchscreen.release_finger(0)
+    mock_core_touchscreen.release_finger.assert_called_with(0)
+
+
+def test_touchscreen_nodes(mock_core_touchscreen):
+    """Test getting touchscreen device nodes."""
+    expected_nodes = ["/dev/input/event0"]
+    mock_core_touchscreen.get_nodes.return_value = expected_nodes
+
+    touchscreen = TouchScreen()
+    assert touchscreen.nodes == expected_nodes
+    mock_core_touchscreen.get_nodes.assert_called_once()
+
+
+def test_touchscreen_creation_failure():
+    """Test handling of touchscreen creation failure."""
+    with patch("inputtino._core.TouchScreen") as mock_touchscreen_cls:
+        mock_touchscreen_cls.create.side_effect = RuntimeError(
+            "Failed to create touchscreen device"
+        )
+
+        with pytest.raises(RuntimeError, match="Failed to create touchscreen device"):
+            TouchScreen()
+
+
+@mark_practical
+def test_practical_touchscreen_draw_circle():
+    """Test drawing a circle pattern with touch input.
+
+    This practical test demonstrates drawing a circle by:
+    1. Moving a single touch point in a circular pattern
+    2. Using normalized coordinates
+    3. Creating a smooth touch movement pattern
+
+    Note:
+        This test requires actual device access (/dev/uinput)
+        and may fail if run without proper permissions.
+    """
+    touchscreen = TouchScreen()
+
+    # Ensure we have valid device nodes
+    assert len(touchscreen.nodes) > 0, "No touchscreen device nodes created"
+
+    # Give system time to register the device
+    time.sleep(0.1)
+
+    # Draw a circle using touch inputs
+    from math import cos, pi, sin
+
+    center_x, center_y = 0.5, 0.5  # Center of the screen
+    radius = 0.2  # Circle radius in normalized coordinates
+    steps = 36  # Number of points to create the circle
+
+    try:
+        # Draw circle pattern
+        for i in range(steps + 1):
+            angle = 2 * pi * i / steps
+            x = center_x + radius * cos(angle)
+            y = center_y + radius * sin(angle)
+
+            # Ensure coordinates stay within bounds
+            x = max(0.0, min(1.0, x))
+            y = max(0.0, min(1.0, y))
+
+            touchscreen.place_finger(0, x, y)
+            time.sleep(0.02)  # Small delay for smooth movement
+
+    finally:
+        # Ensure we always release the finger
+        touchscreen.release_finger(0)

package/engine/vendor/inputtino/bindings/python/tests/test_trackpad.py

@@ -0,0 +1,146 @@
+"""Tests for trackpad.py."""
+
+import time
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from inputtino._core import Trackpad as CoreTrackpad
+from inputtino.trackpad import DeviceDefinition, Trackpad
+from tests.helpers import mark_practical
+
+
+@pytest.fixture
+def mock_core_trackpad():
+    """Create a mock for CoreTrackpad with basic functionality."""
+    with patch("inputtino._core.Trackpad") as mock_trackpad_cls:
+        mock_instance = MagicMock(spec=CoreTrackpad)
+        mock_trackpad_cls.create.return_value = mock_instance
+        yield mock_instance
+
+
+def test_trackpad_creation_with_default_device():
+    """Test creating a trackpad with default device definition."""
+    with patch("inputtino._core.Trackpad") as mock_trackpad_cls:
+        Trackpad()
+
+        mock_trackpad_cls.create.assert_called_once()
+        created_def = mock_trackpad_cls.create.call_args[0][0]
+        assert created_def.name == "Wolf (virtual) touchpad"
+        assert created_def.vendor_id == 0xAB00
+        assert created_def.product_id == 0xAB02
+        assert created_def.version == 0xAB00
+
+
+def test_trackpad_creation_with_custom_device():
+    """Test creating a trackpad with custom device definition."""
+    custom_def = DeviceDefinition(
+        name="Custom Trackpad",
+        vendor_id=0x1234,
+        product_id=0x5678,
+        version=0x0001,
+        device_phys="/dev/input/test",
+        device_uniq="unique_id",
+    )
+
+    with patch("inputtino._core.Trackpad") as mock_trackpad_cls:
+        Trackpad(custom_def)
+
+        mock_trackpad_cls.create.assert_called_once()
+        created_def = mock_trackpad_cls.create.call_args[0][0]
+        assert created_def.name == custom_def.name
+        assert created_def.vendor_id == custom_def.vendor_id
+        assert created_def.product_id == custom_def.product_id
+        assert created_def.version == custom_def.version
+        assert created_def.device_phys == custom_def.device_phys
+        assert created_def.device_uniq == custom_def.device_uniq
+
+
+def test_trackpad_finger_operations(mock_core_trackpad):
+    """Test trackpad finger placement and release operations."""
+    trackpad = Trackpad()
+
+    # Test finger placement
+    trackpad.place_finger(0, 0.5, 0.5, 0.8, 45)
+    mock_core_trackpad.place_finger.assert_called_once_with(0, 0.5, 0.5, 0.8, 45)
+
+    # Test finger release
+    trackpad.release_finger(0)
+    mock_core_trackpad.release_finger.assert_called_once_with(0)
+
+
+def test_trackpad_button_operations(mock_core_trackpad):
+    """Test trackpad button operations."""
+    trackpad = Trackpad()
+
+    # Test button press
+    trackpad.set_left_button(True)
+    mock_core_trackpad.set_left_btn.assert_called_once_with(True)
+
+    # Test button release
+    mock_core_trackpad.set_left_btn.reset_mock()
+    trackpad.set_left_button(False)
+    mock_core_trackpad.set_left_btn.assert_called_once_with(False)
+
+
+def test_trackpad_nodes(mock_core_trackpad):
+    """Test getting trackpad device nodes."""
+    expected_nodes = ["/dev/input/event1"]
+    mock_core_trackpad.get_nodes.return_value = expected_nodes
+
+    trackpad = Trackpad()
+    assert trackpad.nodes == expected_nodes
+    mock_core_trackpad.get_nodes.assert_called_once()
+
+
+def test_trackpad_creation_failure():
+    """Test handling of trackpad creation failure."""
+    with patch("inputtino._core.Trackpad") as mock_trackpad_cls:
+        mock_trackpad_cls.create.side_effect = RuntimeError(
+            "Failed to create trackpad device"
+        )
+
+        with pytest.raises(RuntimeError, match="Failed to create trackpad device"):
+            Trackpad()
+
+
+@mark_practical
+def test_practical_trackpad_gestures():
+    """Test practical trackpad gestures.
+
+    This practical test demonstrates basic trackpad functionality by:
+    1. Simulating single finger tap
+    2. Simulating two-finger scroll
+    3. Testing button click
+
+    Note:
+        This test requires actual device access (/dev/uinput)
+        and may fail if run without proper permissions.
+    """
+    trackpad = Trackpad()
+
+    # Ensure we have valid device nodes
+    assert len(trackpad.nodes) > 0, "No trackpad device nodes created"
+
+    # Give system time to register the device
+    time.sleep(0.1)
+
+    # Single finger tap
+    trackpad.place_finger(0, 0.5, 0.5, 1.0, 0)
+    time.sleep(0.1)
+    trackpad.release_finger(0)
+
+    # Two-finger scroll (vertical)
+    trackpad.place_finger(0, 0.5, 0.3, 1.0, 0)
+    trackpad.place_finger(1, 0.5, 0.4, 1.0, 0)
+    for y in range(3, 8):
+        trackpad.place_finger(0, 0.5, y / 10, 1.0, 0)
+        trackpad.place_finger(1, 0.5, (y + 1) / 10, 1.0, 0)
+        time.sleep(0.05)
+    trackpad.release_finger(0)
+    trackpad.release_finger(1)
+
+    # Button click
+    trackpad.set_left_button(True)
+    time.sleep(0.1)
+    trackpad.set_left_button(False)