something-x-dev 1.6.0.dev13__tar.gz → 1.7.0.dev14__tar.gz

{something_x_dev-1.6.0.dev13/something_x_dev.egg-info → something_x_dev-1.7.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: something-x-dev
-Version: 1.6.0.dev13
+Version: 1.7.0.dev14
 Summary: Something X device manager for Omarchy / Linux
 Author: Raphael
 License: MIT
@@ -16,9 +16,10 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyGObject>=3.42
-Requires-Dist: dbus-python>=1.3
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
 Dynamic: license-file
 
 <div align="center">
@@ -32,6 +33,8 @@ Built for [Omarchy](https://omarchy.org) · GTK4 · Pure black · JetBrains Mono
 [![AUR](https://img.shields.io/aur/version/something-x?color=red)](https://aur.archlinux.org/packages/something-x)
 [![License: MIT](https://img.shields.io/badge/license-MIT-red.svg)](LICENSE)
 [![Platform](https://img.shields.io/badge/platform-Linux-lightgrey)](https://github.com/SoaOaoS/something-x)
+[![CI](https://github.com/SoaOaoS/something-x/actions/workflows/ci.yml/badge.svg)](https://github.com/SoaOaoS/something-x/actions/workflows/ci.yml)
+[![Coverage](https://img.shields.io/badge/coverage-tracked-red)](https://github.com/SoaOaoS/something-x/actions/workflows/ci.yml)
 
 </div>
 

{something_x_dev-1.6.0.dev13 → something_x_dev-1.7.0.dev14}/README.md

@@ -9,6 +9,8 @@ Built for [Omarchy](https://omarchy.org) · GTK4 · Pure black · JetBrains Mono
 [![AUR](https://img.shields.io/aur/version/something-x?color=red)](https://aur.archlinux.org/packages/something-x)
 [![License: MIT](https://img.shields.io/badge/license-MIT-red.svg)](LICENSE)
 [![Platform](https://img.shields.io/badge/platform-Linux-lightgrey)](https://github.com/SoaOaoS/something-x)
+[![CI](https://github.com/SoaOaoS/something-x/actions/workflows/ci.yml/badge.svg)](https://github.com/SoaOaoS/something-x/actions/workflows/ci.yml)
+[![Coverage](https://img.shields.io/badge/coverage-tracked-red)](https://github.com/SoaOaoS/something-x/actions/workflows/ci.yml)
 
 </div>
 

something_x_dev-1.7.0.dev14/nothing_app/bluetooth.py

@@ -0,0 +1,384 @@
+from gi.repository import Gio, GLib, GObject
+
+BLUEZ_SERVICE = "org.bluez"
+ADAPTER_IFACE = "org.bluez.Adapter1"
+DEVICE_IFACE = "org.bluez.Device1"
+BATTERY_IFACE = "org.bluez.Battery1"
+OBJ_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
+PROPERTIES_IFACE = "org.freedesktop.DBus.Properties"
+
+NOTHING_PATTERNS = (
+    "nothing ear",
+    "ear (1)",
+    "ear (2)",
+    "ear (a)",
+    "ear (stick)",
+    "cmf buds",
+    "cmf earphone",
+    "nothing phone",
+)
+
+# Lightweight proxy flags: no property caching, no auto-signal wiring.
+# Used for proxies that only need to call methods.
+_FLAGS_METHOD = Gio.DBusProxyFlags.DO_NOT_LOAD_PROPERTIES | Gio.DBusProxyFlags.DO_NOT_CONNECT_SIGNALS
+
+
+class BluetoothDevice:
+    def __init__(self, path: str, props: dict):
+        self.path = path
+        self.address: str = str(props.get("Address", ""))
+        self.name: str = str(props.get("Name", props.get("Alias", "Unknown Device")))
+        self.connected: bool = bool(props.get("Connected", False))
+        self.paired: bool = bool(props.get("Paired", False))
+        self.battery: int | None = None
+        self.icon: str = str(props.get("Icon", "audio-headphones"))
+        self.is_nothing: bool = any(p in self.name.lower() for p in NOTHING_PATTERNS)
+
+    def update(self, changed: dict):
+        if "Connected" in changed:
+            self.connected = bool(changed["Connected"])
+        if "Name" in changed:
+            self.name = str(changed["Name"])
+        if "Alias" in changed and not self.name:
+            self.name = str(changed["Alias"])
+
+    def __repr__(self):
+        return f"<BTDevice {self.name!r} {'●' if self.connected else '○'}>"
+
+
+# BlueZ Device1.Icon → GTK symbolic icon name
+_BLUEZ_ICON_MAP: dict[str, str] = {
+    "audio-headphones": "audio-headphones-symbolic",
+    "audio-headset": "audio-headset-symbolic",
+    "audio-card": "audio-card-symbolic",
+    "input-mouse": "input-mouse-symbolic",
+    "input-keyboard": "input-keyboard-symbolic",
+    "input-gaming": "input-gaming-symbolic",
+    "input-tablet": "input-tablet-symbolic",
+    "phone": "phone-symbolic",
+    "computer": "computer-symbolic",
+    "printer": "printer-symbolic",
+}
+
+_WATCH_NAME_PATTERNS = ("watch", "band", "gear", "amazfit", "fenix", "vivoactive", "galaxy fit")
+
+
+def device_icon_name(device: "BluetoothDevice | None") -> str:
+    """Return a GTK symbolic icon name for a Bluetooth device."""
+    if device is None:
+        return "audio-headphones-symbolic"
+    name_lower = device.name.lower()
+    if any(p in name_lower for p in _WATCH_NAME_PATTERNS):
+        return "alarm-symbolic"
+    if "ear (stick)" in name_lower:
+        return "audio-input-microphone-symbolic"
+    mapped = _BLUEZ_ICON_MAP.get(device.icon)
+    if mapped:
+        return mapped
+    if "phone" in name_lower:
+        return "phone-symbolic"
+    return "audio-headphones-symbolic"
+
+
+class BluetoothManager(GObject.Object):
+    __gsignals__ = {
+        "devices-changed": (GObject.SignalFlags.RUN_FIRST, None, ()),
+        "device-connected": (GObject.SignalFlags.RUN_FIRST, None, (str,)),
+        "device-disconnected": (GObject.SignalFlags.RUN_FIRST, None, (str,)),
+    }
+
+    def __init__(self):
+        super().__init__()
+        self.devices: dict[str, BluetoothDevice] = {}
+        self._connection: Gio.DBusConnection | None = None
+        self._adapter_path: str | None = None
+        self._subs: list[int] = []
+        self._available = False
+        self._init_dbus()
+
+    def _init_dbus(self):
+        try:
+            self._connection = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
+            mgr = Gio.DBusProxy.new_sync(
+                self._connection,
+                _FLAGS_METHOD,
+                None,
+                BLUEZ_SERVICE,
+                "/",
+                OBJ_MANAGER_IFACE,
+                None,
+            )
+            # Non-blocking: populates devices and emits devices-changed when ready
+            mgr.call(
+                "GetManagedObjects",
+                None,
+                Gio.DBusCallFlags.NONE,
+                -1,
+                None,
+                self._on_managed_objects,
+                None,
+            )
+            self._subscribe()
+        except Exception as exc:
+            print(f"[bluetooth] D-Bus init failed: {exc}")
+
+    def _on_managed_objects(self, proxy, result, _user_data):
+        try:
+            variant = proxy.call_finish(result)
+            objects = variant.unpack()[0]
+            self._populate(objects)
+            self._available = True
+            GLib.idle_add(self.emit, "devices-changed")
+        except Exception as exc:
+            print(f"[bluetooth] GetManagedObjects failed: {exc}")
+
+    def _populate(self, objects: dict):
+        self.devices = {}
+        self._adapter_path = None
+        for path, ifaces in objects.items():
+            if ADAPTER_IFACE in ifaces and self._adapter_path is None:
+                self._adapter_path = path
+            if DEVICE_IFACE not in ifaces:
+                continue
+            props = dict(ifaces[DEVICE_IFACE])
+            dev = BluetoothDevice(path, props)
+            if BATTERY_IFACE in ifaces:
+                dev.battery = int(ifaces[BATTERY_IFACE].get("Percentage", 0))
+            self.devices[path] = dev
+
+    def _subscribe(self):
+        if not self._connection:
+            return
+        try:
+            self._subs.append(
+                self._connection.signal_subscribe(
+                    BLUEZ_SERVICE,
+                    PROPERTIES_IFACE,
+                    "PropertiesChanged",
+                    None,
+                    None,
+                    Gio.DBusSignalFlags.NONE,
+                    self._on_props_changed,
+                    None,
+                )
+            )
+            self._subs.append(
+                self._connection.signal_subscribe(
+                    BLUEZ_SERVICE,
+                    OBJ_MANAGER_IFACE,
+                    "InterfacesAdded",
+                    None,
+                    None,
+                    Gio.DBusSignalFlags.NONE,
+                    self._on_ifaces_added,
+                    None,
+                )
+            )
+            self._subs.append(
+                self._connection.signal_subscribe(
+                    BLUEZ_SERVICE,
+                    OBJ_MANAGER_IFACE,
+                    "InterfacesRemoved",
+                    None,
+                    None,
+                    Gio.DBusSignalFlags.NONE,
+                    self._on_ifaces_removed,
+                    None,
+                )
+            )
+        except Exception as exc:
+            print(f"[bluetooth] Signal subscribe failed: {exc}")
+
+    def _on_props_changed(self, _conn, _sender, path, _iface, _signal, params, _user_data):
+        iface_name, changed, _invalidated = params.unpack()
+        if iface_name != DEVICE_IFACE:
+            return
+        if path not in self.devices:
+            return
+        dev = self.devices[path]
+        old_connected = dev.connected
+        dev.update(dict(changed))
+        if dev.connected != old_connected:
+            sig = "device-connected" if dev.connected else "device-disconnected"
+            GLib.idle_add(self.emit, sig, path)
+        GLib.idle_add(self.emit, "devices-changed")
+
+    def _on_ifaces_added(self, _conn, _sender, _path, _iface, _signal, params, _user_data):
+        obj_path, ifaces = params.unpack()
+        if ADAPTER_IFACE in ifaces and self._adapter_path is None:
+            self._adapter_path = obj_path
+        if DEVICE_IFACE not in ifaces:
+            return
+        props = dict(ifaces[DEVICE_IFACE])
+        dev = BluetoothDevice(obj_path, props)
+        if BATTERY_IFACE in ifaces:
+            dev.battery = int(ifaces[BATTERY_IFACE].get("Percentage", 0))
+        self.devices[obj_path] = dev
+        GLib.idle_add(self.emit, "devices-changed")
+
+    def _on_ifaces_removed(self, _conn, _sender, _path, _iface, _signal, params, _user_data):
+        obj_path, ifaces = params.unpack()
+        if DEVICE_IFACE in ifaces and obj_path in self.devices:
+            del self.devices[obj_path]
+            GLib.idle_add(self.emit, "devices-changed")
+
+    @property
+    def available(self) -> bool:
+        return self._available
+
+    def get_all(self) -> list[BluetoothDevice]:
+        return sorted(self.devices.values(), key=lambda d: (not d.connected, d.name))
+
+    def get_nothing_devices(self) -> list[BluetoothDevice]:
+        return [d for d in self.get_all() if d.is_nothing]
+
+    def refresh(self):
+        if not self._connection:
+            return
+        try:
+            mgr = Gio.DBusProxy.new_sync(
+                self._connection,
+                _FLAGS_METHOD,
+                None,
+                BLUEZ_SERVICE,
+                "/",
+                OBJ_MANAGER_IFACE,
+                None,
+            )
+            mgr.call(
+                "GetManagedObjects",
+                None,
+                Gio.DBusCallFlags.NONE,
+                -1,
+                None,
+                self._on_managed_objects,
+                None,
+            )
+        except Exception as exc:
+            print(f"[bluetooth] refresh: {exc}")
+
+    def connect_device(self, path: str, on_error=None):
+        if not self._connection:
+            return
+        Gio.DBusProxy.new(
+            self._connection,
+            _FLAGS_METHOD,
+            None,
+            BLUEZ_SERVICE,
+            path,
+            DEVICE_IFACE,
+            None,
+            self._on_connect_proxy_ready,
+            on_error,
+        )
+
+    def _on_connect_proxy_ready(self, _source, result, on_error):
+        try:
+            proxy = Gio.DBusProxy.new_finish(result)
+            proxy.call(
+                "Connect",
+                None,
+                Gio.DBusCallFlags.NONE,
+                -1,
+                None,
+                self._on_connect_done,
+                on_error,
+            )
+        except Exception as exc:
+            print(f"[bluetooth] connect proxy failed: {exc}")
+            if on_error:
+                GLib.idle_add(on_error)
+
+    def _on_connect_done(self, proxy, result, on_error):
+        try:
+            proxy.call_finish(result)
+        except Exception as exc:
+            print(f"[BT] connect error: {exc}")
+            if on_error:
+                GLib.idle_add(on_error)
+
+    def disconnect_device(self, path: str):
+        if not self._connection:
+            return
+        Gio.DBusProxy.new(
+            self._connection,
+            _FLAGS_METHOD,
+            None,
+            BLUEZ_SERVICE,
+            path,
+            DEVICE_IFACE,
+            None,
+            self._on_disconnect_proxy_ready,
+            None,
+        )
+
+    def _on_disconnect_proxy_ready(self, _source, result, _user_data):
+        try:
+            proxy = Gio.DBusProxy.new_finish(result)
+            proxy.call(
+                "Disconnect",
+                None,
+                Gio.DBusCallFlags.NONE,
+                -1,
+                None,
+                self._on_disconnect_done,
+                None,
+            )
+        except Exception as exc:
+            print(f"[bluetooth] disconnect proxy failed: {exc}")
+
+    def _on_disconnect_done(self, proxy, result, _user_data):
+        try:
+            proxy.call_finish(result)
+        except Exception as exc:
+            print(f"[BT] disconnect error: {exc}")
+
+    def start_discovery(self):
+        if not self._connection or not self._adapter_path:
+            return
+        try:
+            proxy = Gio.DBusProxy.new_sync(
+                self._connection,
+                _FLAGS_METHOD,
+                None,
+                BLUEZ_SERVICE,
+                self._adapter_path,
+                ADAPTER_IFACE,
+                None,
+            )
+            proxy.call(
+                "StartDiscovery",
+                None,
+                Gio.DBusCallFlags.NONE,
+                -1,
+                None,
+                self._on_start_discovery_done,
+                None,
+            )
+        except Exception as exc:
+            print(f"[bluetooth] discovery start: {exc}")
+
+    def _on_start_discovery_done(self, proxy, result, _user_data):
+        try:
+            proxy.call_finish(result)
+            GLib.timeout_add_seconds(30, self._stop_discovery)
+        except Exception as exc:
+            print(f"[bluetooth] start discovery error: {exc}")
+
+    def _stop_discovery(self):
+        if not self._connection or not self._adapter_path:
+            return False
+        try:
+            proxy = Gio.DBusProxy.new_sync(
+                self._connection,
+                _FLAGS_METHOD,
+                None,
+                BLUEZ_SERVICE,
+                self._adapter_path,
+                ADAPTER_IFACE,
+                None,
+            )
+            proxy.call_sync("StopDiscovery", None, Gio.DBusCallFlags.NONE, -1, None)
+        except Exception:
+            pass
+        return False

{something_x_dev-1.6.0.dev13 → something_x_dev-1.7.0.dev14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name            = "something-x-dev"
-version = "1.6.0.dev13"
+version = "1.7.0.dev14"
 description     = "Something X device manager for Omarchy / Linux"
 readme          = "README.md"
 license         = { text = "MIT" }
@@ -27,7 +27,6 @@ classifiers = [
 
 dependencies = [
     "PyGObject>=3.42",
-    "dbus-python>=1.3",
 ]
 
 [project.scripts]
@@ -41,7 +40,10 @@ include = ["nothing_app*"]
 nothing_app = ["data/*.css", "data/*.desktop"]
 
 [project.optional-dependencies]
-dev = ["ruff"]
+dev = ["ruff", "pytest", "pytest-cov"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
 
 [tool.ruff]
 line-length = 110

{something_x_dev-1.6.0.dev13 → something_x_dev-1.7.0.dev14/something_x_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: something-x-dev
-Version: 1.6.0.dev13
+Version: 1.7.0.dev14
 Summary: Something X device manager for Omarchy / Linux
 Author: Raphael
 License: MIT
@@ -16,9 +16,10 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyGObject>=3.42
-Requires-Dist: dbus-python>=1.3
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
 Dynamic: license-file
 
 <div align="center">
@@ -32,6 +33,8 @@ Built for [Omarchy](https://omarchy.org) · GTK4 · Pure black · JetBrains Mono
 [![AUR](https://img.shields.io/aur/version/something-x?color=red)](https://aur.archlinux.org/packages/something-x)
 [![License: MIT](https://img.shields.io/badge/license-MIT-red.svg)](LICENSE)
 [![Platform](https://img.shields.io/badge/platform-Linux-lightgrey)](https://github.com/SoaOaoS/something-x)
+[![CI](https://github.com/SoaOaoS/something-x/actions/workflows/ci.yml/badge.svg)](https://github.com/SoaOaoS/something-x/actions/workflows/ci.yml)
+[![Coverage](https://img.shields.io/badge/coverage-tracked-red)](https://github.com/SoaOaoS/something-x/actions/workflows/ci.yml)
 
 </div>
 

{something_x_dev-1.6.0.dev13 → something_x_dev-1.7.0.dev14}/something_x_dev.egg-info/SOURCES.txt

@@ -20,4 +20,8 @@ something_x_dev.egg-info/SOURCES.txt
 something_x_dev.egg-info/dependency_links.txt
 something_x_dev.egg-info/entry_points.txt
 something_x_dev.egg-info/requires.txt
-something_x_dev.egg-info/top_level.txt
+something_x_dev.egg-info/top_level.txt
+tests/test_bluetooth.py
+tests/test_crc.py
+tests/test_profiles.py
+tests/test_protocol.py

{something_x_dev-1.6.0.dev13 → something_x_dev-1.7.0.dev14}/something_x_dev.egg-info/requires.txt

@@ -1,5 +1,6 @@
 PyGObject>=3.42
-dbus-python>=1.3
 
 [dev]
 ruff
+pytest
+pytest-cov

something_x_dev-1.7.0.dev14/tests/test_bluetooth.py

@@ -0,0 +1,136 @@
+"""Tests for BluetoothDevice data class and device_icon_name helper."""
+
+import pytest
+
+from nothing_app.bluetooth import BluetoothDevice, device_icon_name
+
+
+def make_device(name="Nothing Ear (2)", icon="audio-headphones", connected=False):
+    return BluetoothDevice(
+        "/org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF",
+        {
+            "Address": "AA:BB:CC:DD:EE:FF",
+            "Name": name,
+            "Icon": icon,
+            "Connected": connected,
+            "Paired": True,
+        },
+    )
+
+
+# ── BluetoothDevice construction ──────────────────────────────────────────────
+
+
+def test_address_stored():
+    dev = make_device()
+    assert dev.address == "AA:BB:CC:DD:EE:FF"
+
+
+def test_name_stored():
+    dev = make_device(name="CMF Buds Pro 2")
+    assert dev.name == "CMF Buds Pro 2"
+
+
+def test_connected_flag():
+    assert make_device(connected=True).connected is True
+    assert make_device(connected=False).connected is False
+
+
+def test_is_nothing_true_for_known_patterns():
+    for name in [
+        "Nothing Ear (2)",
+        "Nothing Ear (1)",
+        "Nothing Ear (A)",
+        "Ear (Stick)",
+        "CMF Buds Pro 2",
+        "CMF Earphone 1",
+        "Nothing Phone (2)",
+    ]:
+        assert make_device(name=name).is_nothing is True, f"{name!r} should be recognised"
+
+
+def test_is_nothing_false_for_unknown():
+    for name in ["AirPods Pro", "Galaxy Buds2", "Sony WH-1000XM5", "Jabra Elite 7"]:
+        assert make_device(name=name).is_nothing is False
+
+
+def test_battery_default_none():
+    assert make_device().battery is None
+
+
+def test_repr_connected():
+    dev = make_device(connected=True)
+    assert "●" in repr(dev)
+
+
+def test_repr_disconnected():
+    dev = make_device(connected=False)
+    assert "○" in repr(dev)
+
+
+# ── BluetoothDevice.update ────────────────────────────────────────────────────
+
+
+def test_update_connected():
+    dev = make_device(connected=False)
+    dev.update({"Connected": True})
+    assert dev.connected is True
+
+
+def test_update_name():
+    dev = make_device(name="Old Name")
+    dev.update({"Name": "New Name"})
+    assert dev.name == "New Name"
+
+
+def test_update_ignores_unknown_keys():
+    dev = make_device()
+    dev.update({"UnknownKey": "value"})  # should not raise
+
+
+def test_update_alias_only_when_name_empty():
+    dev = BluetoothDevice("/path", {"Address": "AA:BB:CC:DD:EE:FF", "Name": "", "Alias": "My Device"})
+    dev.update({"Alias": "Better Name"})
+    assert dev.name == "Better Name"
+
+    dev2 = make_device(name="Existing")
+    dev2.update({"Alias": "Should Not Replace"})
+    assert dev2.name == "Existing"
+
+
+# ── device_icon_name ──────────────────────────────────────────────────────────
+
+
+def test_none_device_returns_default():
+    assert device_icon_name(None) == "audio-headphones-symbolic"
+
+
+def test_headphones_icon_mapped():
+    dev = make_device(icon="audio-headphones")
+    assert device_icon_name(dev) == "audio-headphones-symbolic"
+
+
+def test_headset_icon_mapped():
+    dev = make_device(icon="audio-headset")
+    assert device_icon_name(dev) == "audio-headset-symbolic"
+
+
+def test_watch_name_returns_alarm():
+    for name in ["Galaxy Watch 5", "Amazfit GTR", "Fenix 7"]:
+        dev = make_device(name=name)
+        assert device_icon_name(dev) == "alarm-symbolic", f"expected alarm for {name!r}"
+
+
+def test_ear_stick_returns_microphone():
+    dev = make_device(name="Nothing Ear (Stick)")
+    assert device_icon_name(dev) == "audio-input-microphone-symbolic"
+
+
+def test_phone_name_returns_phone():
+    dev = make_device(name="Nothing Phone (2)", icon="unknown-icon")
+    assert device_icon_name(dev) == "phone-symbolic"
+
+
+def test_unknown_icon_falls_back_to_headphones():
+    dev = make_device(name="Random Gadget", icon="unknown-xyz")
+    assert device_icon_name(dev) == "audio-headphones-symbolic"

something_x_dev-1.7.0.dev14/tests/test_crc.py

@@ -0,0 +1,48 @@
+import struct
+
+from nothing_app.protocol import _CMD_PROTO_VERSION, _CTRL_HOST_CRC, _SOF, _crc16
+
+
+def test_returns_uint16():
+    for data in [b"", b"\x00", b"\xff", b"\x55" * 8, b"hello world"]:
+        result = _crc16(data)
+        assert isinstance(result, int)
+        assert 0 <= result <= 0xFFFF
+
+
+def test_deterministic():
+    data = b"\x55\x60\x01\x01\xc0\x00\x00\x01"
+    assert _crc16(data) == _crc16(data)
+
+
+def test_empty_is_init_value():
+    # With no bytes processed the accumulator stays at the init value 0xFFFF.
+    assert _crc16(b"") == 0xFFFF
+
+
+def test_single_bit_flip_detected():
+    data = b"\x55\x60\x01\x01\xc0\x00\x00\x01\x42\xab"
+    flipped = bytes([data[0] ^ 0x01]) + data[1:]
+    assert _crc16(data) != _crc16(flipped)
+
+
+def test_different_inputs_differ():
+    assert _crc16(b"\x00\x00") != _crc16(b"\x00\x01")
+    assert _crc16(b"\x55\x60\x01") != _crc16(b"\x55\x60\x02")
+    assert _crc16(b"\xaa") != _crc16(b"\xab")
+
+
+def test_probe_frame_crc_is_stable():
+    # The probe frame sent during channel discovery must always produce the same CRC.
+    header = struct.pack("<BHHH", _SOF, _CTRL_HOST_CRC, _CMD_PROTO_VERSION, 0) + bytes([0x01])
+    crc1 = _crc16(header)
+    crc2 = _crc16(header)
+    assert crc1 == crc2
+    assert 0 <= crc1 <= 0xFFFF
+
+
+def test_payload_changes_crc():
+    header = struct.pack("<BHHH", _SOF, _CTRL_HOST_CRC, _CMD_PROTO_VERSION, 3) + bytes([0x01])
+    crc_a = _crc16(header + b"\x01\x02\x03")
+    crc_b = _crc16(header + b"\x01\x02\x04")
+    assert crc_a != crc_b