sockcan 0.1.0__tar.gz

sockcan-0.1.0/.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,51 @@
+name: Publish sockan to PyPi
+
+on: push
+
+jobs:
+  build:
+    name: Build distribution 📦
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Install pypa/build
+        run: >-
+          python3 -m
+          pip install
+          build
+          --user
+      - name: Build a binary wheel and a source tarball
+        run: python3 -m build
+      - name: Store the distribution packages
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish-to-pypi:
+    name: >-
+      Publish Python 🐍 distribution 📦 to PyPI
+    if: startsWith(github.ref, 'refs/tags/') # only publish to PyPI on tag pushes
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/sockan
+    permissions:
+      id-token: write # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish distribution 📦 to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

sockcan-0.1.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: sockcan
+Version: 0.1.0
+Summary: Provides a socketcan-alike interface other arbitrary CAN drivers
+Project-URL: Homepage, https://github.com/Hedwyn/sockcan
+Author: Baptiste Pestourie
+Requires-Python: >=3.12
+Requires-Dist: click
+Provides-Extra: test
+Requires-Dist: hypothesis; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: python-can; extra == 'test'
+Description-Content-Type: text/markdown
+
+# sockcan
+
+Provides a socketcan-alike interface other arbitrary CAN drivers.
+
+## Running benchmarks
+
+Benchmarks can be run with `python -m sockcan.benchmarks`:
+
+```shell
+python -m sockcan.benchmarks --help
+Usage: python -m sockcan.benchmarks [OPTIONS]
+
+  Runs the benchmarks interactively
+
+Options:
+  -r, --rounds INTEGER
+  -b, --batch-size INTEGER
+  -v, --verbose
+  --help                    Show this message and exit.
+```
+
+## Running tests
+
+Tests are based on `pytest` and `hypothesis`. Make sure to install this package with `test` extra (`pip install .\[test\`).<br>
+You can show hypothesis stats with `--hypothesis-show-statistics`:
+
+```shell
+python -m pytest -vv --hypothesis-show-statistics
+```

sockcan-0.1.0/README.md

@@ -0,0 +1,29 @@
+# sockcan
+
+Provides a socketcan-alike interface other arbitrary CAN drivers.
+
+## Running benchmarks
+
+Benchmarks can be run with `python -m sockcan.benchmarks`:
+
+```shell
+python -m sockcan.benchmarks --help
+Usage: python -m sockcan.benchmarks [OPTIONS]
+
+  Runs the benchmarks interactively
+
+Options:
+  -r, --rounds INTEGER
+  -b, --batch-size INTEGER
+  -v, --verbose
+  --help                    Show this message and exit.
+```
+
+## Running tests
+
+Tests are based on `pytest` and `hypothesis`. Make sure to install this package with `test` extra (`pip install .\[test\`).<br>
+You can show hypothesis stats with `--hypothesis-show-statistics`:
+
+```shell
+python -m pytest -vv --hypothesis-show-statistics
+```

sockcan-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sockcan"
+# setting version to VCS so hatch will automatically use tags for versioning
+dynamic = ["version"]
+description = "Provides a socketcan-alike interface other arbitrary CAN drivers"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [{ name = "Baptiste Pestourie" }]
+dependencies = ["click"]
+
+[project.optional-dependencies]
+test = ["hypothesis", "pytest", "python-can"]
+
+[project.urls]
+Homepage = "https://github.com/Hedwyn/sockcan"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sockcan"]

sockcan-0.1.0/src/sockcan/__init__.py

@@ -0,0 +1,26 @@
+"""
+Centralizes imports.
+
+@date: 19.03.2026
+@author: Baptiste Pestourie
+"""
+
+from __future__ import annotations
+
+from ._protocol import (
+    RecvFn,
+    SocketcanConfig,
+    SocketcanFd,
+    build_recv_func,
+    build_send_func,
+    connect_to_socketcan,
+)
+
+__all__ = [
+    "RecvFn",
+    "SocketcanConfig",
+    "SocketcanFd",
+    "build_recv_func",
+    "build_send_func",
+    "connect_to_socketcan",
+]

sockcan-0.1.0/src/sockcan/_protocol.py

@@ -0,0 +1,234 @@
+"""
+Implements the binary protoco defined by socketcan.
+
+@date: 19.03.2026
+@author: Baptiste Pestourie
+"""
+
+from __future__ import annotations
+
+import socket
+import struct
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import Enum, auto
+from functools import lru_cache, partial
+from typing import Any, NamedTuple, NewType, Protocol, cast
+
+SocketcanFd = NewType("SocketcanFd", socket.socket)
+
+RECEIVED_TIMESTAMP_STRUCT = struct.Struct("@ll")
+
+
+@dataclass(slots=True)
+class CanMessage:
+    """
+    Container for CAN message data that matches field naming
+    use by python-can's Message.
+    """
+
+    arbitration_id: int
+    data: bytes
+    is_extended_id: bool
+    timestamp: float
+
+
+def get_received_ancillary_buf_size() -> int:
+    """
+    Ancillary data size is platform dependant
+    """
+    try:
+        from socket import CMSG_SPACE  # noqa: PLC0415
+
+        return CMSG_SPACE(RECEIVED_TIMESTAMP_STRUCT.size)
+    except ImportError:
+        return 0
+
+
+class LoopbackMode(Enum):
+    """
+    Whether we receive our own messages.
+
+    If using .FOR_OTHER_SOCKS: others sockets on the same physical CAN device
+    will receive our TX messages, but not us.
+    If .ON: the socket will receive its own message.
+    """
+
+    OFF = auto()
+    FOR_OTHER_SOCKS = auto()
+    ON = auto()
+
+
+class LazyCanMessage(NamedTuple):
+    arbitration_id: int
+    data: bytes
+    raw_link_data: bytes
+
+
+# --- Constants --- #
+CANFD_MTU = 72
+PF_CAN = 29
+CAN_RAW = 1
+SOL_CAN_BASE = 100
+SOL_CAN_RAW = SOL_CAN_BASE + CAN_RAW
+CAN_RAW_RECV_OWN_MSGS = 4
+
+SO_TIMESTAMPNS = 35
+CAN_EFF_FLAG = 0x80000000
+CAN_RAW_LOOPBACK = 3
+CAN_FRAME_HEADER_STRUCT = struct.Struct("=IBB2x")
+CAN_EXTENSION_MASK = 0x07FFF800
+
+
+@dataclass(slots=True, frozen=True)
+class SocketcanConfig:
+    """
+    Options to configure the socketcan connection.
+    """
+
+    channel: str = "can0"
+    loopback: LoopbackMode = LoopbackMode.FOR_OTHER_SOCKS
+
+
+def connect_to_socketcan(config: SocketcanConfig) -> SocketcanFd:
+    """
+    Creates a socketcan socket according to `config`.
+    """
+    sock = socket.socket(PF_CAN, socket.SOCK_RAW, CAN_RAW)
+    sock.setsockopt(
+        SOL_CAN_RAW,
+        CAN_RAW_RECV_OWN_MSGS,
+        1 if config.loopback == LoopbackMode.ON else 0,
+    )
+    sock.setsockopt(
+        SOL_CAN_RAW,
+        CAN_RAW_LOOPBACK,
+        1 if config.loopback == LoopbackMode.FOR_OTHER_SOCKS else 0,
+    )
+    sock.setsockopt(socket.SOL_SOCKET, SO_TIMESTAMPNS, 1)
+    sock.bind((config.channel,))
+    return cast("SocketcanFd", sock)
+
+
+type _CMSG = tuple[int, int, bytes]
+
+
+class RecvMsgFn(Protocol):
+    """
+    Any recv function which signatures complies with `recvmsg` method of sockets.
+    """
+
+    def __call__(
+        self,
+        bufsize: int,
+        ancbufsize: int = 0,
+        flags: int = 0,
+        /,
+    ) -> tuple[bytes, list[_CMSG], int, Any]: ...
+
+
+type HeaderUnpack = Callable[[bytes], tuple[int, int, int]]
+type TimestampUnpack = Callable[[bytes], tuple[int, int]]
+
+type HeaderPack = Callable[[int, int, int], bytes]
+
+
+def _socketcan_recv(
+    recv_fn: RecvMsgFn,
+    custom_mask: int = 0xFFFF_FFFF,
+    exc_class: type[Exception] = OSError,
+    # Note: all parameters below are injected as default arguments so they are accessed faster
+    # they are not meants to be overriden, hence the prefix '__'
+    _ancillary_data_size: int = get_received_ancillary_buf_size(),
+    # Warning: these defaulted parameters are mainly there
+    # to inject the constants in local scope and speed up their access.
+    _header_unpack: HeaderUnpack = CAN_FRAME_HEADER_STRUCT.unpack_from,
+    _timestamp_unpack: TimestampUnpack = RECEIVED_TIMESTAMP_STRUCT.unpack_from,
+    _canfd_mtu: int = CANFD_MTU,
+    _can_eff_flag: int = CAN_EFF_FLAG,
+) -> CanMessage:
+    """
+    Captures a message from the CAN bus and runs partial decoding.
+    Unpacks the data, arbitration ID and timestamp andf leaves all the other metadata undecoded.
+    Metadata will only be decoded on access.
+    """
+    # Fetching the Arb ID, DLC and Data
+    try:
+        cf, ancillary_data, *_ = recv_fn(_canfd_mtu, _ancillary_data_size)
+    except OSError as error:
+        msg = f"Error receiving: {error.strerror}"
+        raise exc_class(msg) from error
+
+    can_id, can_dlc, _ = _header_unpack(cf)
+    # is_extended = bool(can_id & _can_eff_flag)
+    # Note: `'not not' is faster than bool
+    is_extended = not not (can_id & _can_eff_flag)  # noqa: SIM208
+    can_id = can_id & 0x1FFFFFFF
+
+    data = cf[8 : 8 + can_dlc]
+    can_id = can_id & custom_mask
+
+    assert ancillary_data, "ancillary data was not enabled on the socket"
+    cmsg_data = ancillary_data[0][2]
+
+    seconds, nanoseconds = _timestamp_unpack(cmsg_data)
+    timestamp = seconds + nanoseconds * 1e-9
+    # updating data
+    return CanMessage(can_id, data, is_extended, timestamp)
+
+
+type RecvFn = Callable[[], CanMessage]
+
+
+def build_recv_func(fd: SocketcanFd) -> RecvFn:
+    """
+    Builds the receive function for socketcan socket `fd`.
+    """
+    return partial(_socketcan_recv, fd.recvmsg)
+
+
+@lru_cache(maxsize=1024)
+def build_tx_header(
+    can_id: int,
+    dlc: int,
+    *,
+    is_extended_id: bool = False,
+    _header_pack: HeaderPack = CAN_FRAME_HEADER_STRUCT.pack,
+    _can_eff_flag: int = CAN_EFF_FLAG,
+    _can_extension_mask: int = CAN_EXTENSION_MASK,
+) -> bytes:
+    """
+    Encodes the CAN header bytes for a given ID and DLC
+    """
+    if is_extended_id or (can_id & _can_extension_mask) > 0:
+        can_id |= _can_eff_flag
+
+    return _header_pack(can_id, dlc, 0)
+
+
+class SendMsgFn(Protocol):
+    def __call__(self, data: bytes, flags: int = 0, /) -> int: ...
+
+
+def send_can_message(
+    send_fn: SendMsgFn,
+    arbitration_id: int,
+    data: bytes,
+    is_extended: bool = False,  # noqa: FBT001, FBT002
+) -> None:
+    """
+    Sends a can message specified with `data` and `arbitration_id`
+    using the socket send function `send_fn`
+    """
+    header = build_tx_header(arbitration_id, data.__len__(), is_extended_id=is_extended)
+    send_fn(header + data.ljust(8, b"\0"))
+
+
+type SendFn = Callable[[int, bytes, bool], None]
+
+
+def build_send_func(fd: SocketcanFd) -> SendFn:
+    """
+    Builds the send function for socketcan socket `fd`.
+    """
+    return partial(send_can_message, fd.send)

sockcan-0.1.0/src/sockcan/benchmarks/__init__.py

@@ -0,0 +1,12 @@
+"""
+Centralizes imports.
+
+@date: 19.03.2026
+@author: Baptiste Pestourie
+"""
+
+from __future__ import annotations
+
+from ._bench import bench
+
+__all__ = ["bench"]

sockcan-0.1.0/src/sockcan/benchmarks/__main__.py

@@ -0,0 +1,47 @@
+"""
+Runs benchmarks against python-can.
+
+@date: 19.03.2026
+@author: Baptiste Pestourie
+"""
+
+from __future__ import annotations
+
+import pstats
+
+import click
+
+from sockcan._protocol import SocketcanConfig, build_recv_func, connect_to_socketcan
+from sockcan.fixtures import vcan_bus
+
+from ._bench import bench
+
+
+@click.command()
+@click.option("-r", "--rounds", default=200, type=int)
+@click.option("-b", "--batch-size", default=100, type=int)
+@click.option("-v", "--verbose", is_flag=True)
+def cli(*, rounds: int, batch_size: int, verbose: bool) -> None:
+    """
+    Runs the benchmarks interactively
+    """
+    with vcan_bus() as tx_bus, vcan_bus() as rx_bus:
+        python_can_profile = bench(rx_bus.recv, tx_bus, batch_size=batch_size, total_rounds=rounds)
+
+        if verbose:
+            python_can_profile.print_stats()
+
+        sockcan_sock = connect_to_socketcan(SocketcanConfig(channel="vcan0"))
+        recv_fn = build_recv_func(sockcan_sock)
+        sockcan_profile = bench(recv_fn, tx_bus, batch_size=batch_size, total_rounds=rounds)
+        if verbose:
+            sockcan_profile.print_stats()
+
+        python_can_stats = pstats.Stats(python_can_profile)
+        sockcan_stats = pstats.Stats(sockcan_profile)
+        ratio = python_can_stats.total_tt / sockcan_stats.total_tt  # type: ignore[attr-defined]
+        click.echo(f"Performed {ratio:.02f} x faster than python-can")
+
+
+if __name__ == "__main__":
+    cli()

sockcan-0.1.0/src/sockcan/benchmarks/_bench.py

@@ -0,0 +1,49 @@
+"""
+Implements benchmarks against python-can.
+
+@date: 19.03.2026
+@author: Baptiste Pestourie
+"""
+
+from __future__ import annotations
+
+import cProfile
+from cProfile import Profile
+from typing import TYPE_CHECKING
+
+import can
+from can import Message
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from sockcan import RecvFn
+    from sockcan.fixtures import SocketcanBus
+
+
+TEST_MSG = can.Message(arbitration_id=0x200, data=b"\x00\x01\x02\x03\x04\x05\x06\x07")
+
+
+def bench(
+    recv_fn: RecvFn | Callable[..., object],
+    tx_bus: SocketcanBus,
+    test_msg: Message = TEST_MSG,
+    batch_size: int = 100,
+    total_rounds: int = 100,
+) -> Profile:
+    """
+    Profiles the receiver from this project against python-can.
+    `batch_size` should be small enough to fit in the receiver buffer,
+    as they will be sent at once without consuming them.
+    Total messages sent is equal to batch_size * total_rounds.
+    """
+    profile = cProfile.Profile()
+    for _ in range(total_rounds):
+        for _ in range(batch_size):
+            tx_bus.send(test_msg)
+
+        profile.enable()
+        for _ in range(batch_size):
+            recv_fn()
+        profile.disable()
+    return profile

sockcan-0.1.0/src/sockcan/fixtures/__init__.py

@@ -0,0 +1,23 @@
+"""
+All fixtures from this package avaiable for testing.
+
+@date: 19.03.2026
+@author: Baptiste Pestourie
+"""
+
+from __future__ import annotations
+
+from can.interfaces.socketcan import SocketcanBus
+
+from ._bus import has_vcan, rx_can_bus, skip_if_no_vcan, tx_can_bus, vcan_bus
+from ._messages import can_messages
+
+__all__ = [
+    "SocketcanBus",
+    "can_messages",
+    "has_vcan",
+    "rx_can_bus",
+    "skip_if_no_vcan",
+    "tx_can_bus",
+    "vcan_bus",
+]

sockcan-0.1.0/src/sockcan/fixtures/_bus.py

@@ -0,0 +1,69 @@
+"""
+Small fixtures around VCAN bus.
+
+@date: 19.03.2026
+@author: Baptiste Pestourie
+"""
+
+from __future__ import annotations
+
+import contextlib
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+import can
+import pytest
+from can.interfaces.socketcan import SocketcanBus
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+
+@contextlib.contextmanager
+def vcan_bus(channel: str = "vcan0") -> Generator[SocketcanBus, None, None]:
+    """
+    A context manager around a virtual can bus.
+    """
+    with can.Bus(interface="socketcan", channel=channel) as bus:
+        assert isinstance(bus, SocketcanBus)
+        yield bus
+
+
+def has_vcan(channel: str = "vcan0") -> bool:
+    """
+    Whether vcan0 is available on the system.
+    """
+    try:
+        with vcan_bus(channel=channel):
+            return True
+
+    except OSError:
+        return False
+
+
+def skip_if_no_vcan[T: Callable[..., None]]() -> Callable[[T], T]:
+    """
+    A pytest mark that skips the test if no vcan is available.
+    """
+    return pytest.mark.skipif(
+        not has_vcan(),
+        reason="VCAN channel (vcan0) needs to be available for testing",
+    )
+
+
+@pytest.fixture
+def tx_can_bus() -> Generator[SocketcanBus, None, None]:
+    """
+    Bus fixture for testing
+    """
+    with vcan_bus() as bus:
+        yield bus
+
+
+@pytest.fixture
+def rx_can_bus() -> Generator[SocketcanBus, None, None]:
+    """
+    Bus fixture for testing
+    """
+    with vcan_bus() as bus:
+        yield bus

sockcan-0.1.0/src/sockcan/fixtures/_messages.py

@@ -0,0 +1,34 @@
+"""
+Implementss CAN messages random generation strategies using hypothesis.
+
+@date: 19.03.2026
+@author: Baptiste Pestourie
+"""
+
+from __future__ import annotations
+
+import can
+from hypothesis import strategies as st
+
+CAN_11BIT_ID_MASK = 0x3FF
+CAN_29BIT_ID_MASK = 0x1FFF_FFFF
+
+
+@st.composite
+def can_messages(draw: st.DrawFn) -> can.Message:
+    """
+    A composite strategy generating random CAN messages.
+    """
+    is_extended = draw(st.booleans())
+    id_bytes = draw(st.binary(min_size=0, max_size=4))
+    data = draw(st.binary(min_size=0, max_size=8))
+    dlc = len(data)
+    can_id_mask = CAN_29BIT_ID_MASK if is_extended else CAN_11BIT_ID_MASK
+    normalized_id = int.from_bytes(id_bytes) & can_id_mask
+
+    return can.Message(
+        arbitration_id=normalized_id,
+        is_extended_id=is_extended,
+        dlc=dlc,
+        data=data,
+    )

sockcan-0.1.0/tests/test_fixtures.py

@@ -0,0 +1,43 @@
+"""
+Sanity checks for the tests fixtures.
+
+@date: 18.03.2026
+@author; Baptiste Pestourie
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hypothesis import HealthCheck, given, settings
+
+from sockcan.fixtures import SocketcanBus, can_messages, rx_can_bus, skip_if_no_vcan, tx_can_bus
+
+if TYPE_CHECKING:
+    from can import Message
+
+
+# fixtures
+_ = rx_can_bus
+_ = tx_can_bus
+
+
+@given(can_message=can_messages())
+@settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+@skip_if_no_vcan()
+def test_random_message_sanity(
+    can_message: Message,
+    rx_can_bus: SocketcanBus,
+    tx_can_bus: SocketcanBus,
+) -> None:
+    """
+    Verifies that the auto-generated messages are received on the other side
+    as expected.
+    """
+    tx_can_bus.send(can_message)
+    obtained = rx_can_bus.recv()
+    assert obtained is not None
+    assert obtained.arbitration_id == can_message.arbitration_id
+    assert obtained.data == can_message.data
+    assert obtained.dlc == can_message.dlc
+    assert obtained.is_extended_id is can_message.is_extended_id

sockcan-0.1.0/tests/test_protocol.py

@@ -0,0 +1,120 @@
+"""
+Verifies the implementation of socketcan protocol.
+
+@date: 19.03.2026
+@author: Baptiste Pestourie
+"""
+
+from __future__ import annotations
+
+import contextlib
+import socket
+from typing import TYPE_CHECKING, Literal, cast
+
+import pytest
+from hypothesis import HealthCheck, given, settings
+
+from sockcan import SocketcanConfig, SocketcanFd, build_recv_func, connect_to_socketcan
+from sockcan._protocol import build_send_func
+from sockcan.fixtures import can_messages, rx_can_bus, skip_if_no_vcan, tx_can_bus, vcan_bus
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from socket import socket as Socket  # noqa: N812
+
+    from can import Message as PyCanMessage
+    from can.interfaces.socketcan import SocketcanBus
+    from pytest import FixtureRequest  # noqa: PT013
+
+
+_ = tx_can_bus
+_ = rx_can_bus
+
+# Whether the socketcan socket should be created using python-can
+# or our own implementation
+SOCKET_PROVIDERS = ["python-can", "sockcan"]
+type SocketProvider = Literal["python-can", "sockcan"]
+
+
+@contextlib.contextmanager
+def get_socketcan_sock(
+    provider: SocketProvider = "python-can",
+) -> Generator[SocketcanFd, None, None]:
+    if provider == "python-can":
+        with vcan_bus() as bus:
+            yield cast("SocketcanFd", bus.socket)
+    else:  # sockcan
+        sock = connect_to_socketcan(SocketcanConfig(channel="vcan0"))
+        try:
+            yield sock
+        finally:
+            sock.close()
+
+
+@pytest.fixture
+def rx_sock(request: FixtureRequest) -> Generator[SocketcanFd, None, None]:
+    """
+    The socket that should be used to test message reception.
+    Built by default using python-can. If parametrizing provider as sockcan,
+    builds it using our implementation instead.
+    """
+    provider = cast("SocketProvider", getattr(request, "param", "python-can"))
+    with get_socketcan_sock(provider=provider) as sock:
+        yield sock
+
+
+@pytest.fixture
+def tx_sock(request: FixtureRequest) -> Generator[SocketcanFd, None, None]:
+    """
+    The socket that should be used to test message reception.
+    Built by default using python-can. If parametrizing provider as sockcan,
+    builds it using our implementation instead.
+    """
+    provider = cast("SocketProvider", getattr(request, "param", "python-can"))
+    with get_socketcan_sock(provider=provider) as sock:
+        yield sock
+
+
+@pytest.mark.parametrize("rx_sock", ["sockcan"], indirect=True)
+def test_sock_sanity(rx_sock: Socket) -> None:
+    assert isinstance(rx_sock, socket.socket)
+
+
+@given(can_message=can_messages())
+@settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+@pytest.mark.parametrize("rx_sock", SOCKET_PROVIDERS, indirect=True)
+@skip_if_no_vcan()
+def test_recv_message(
+    can_message: PyCanMessage,
+    tx_can_bus: SocketcanBus,
+    rx_sock: SocketcanFd,
+) -> None:
+    """
+    Sends a message using python-can and verifies that the implementation in this package
+    receives it properly.
+    """
+    recv_fn = build_recv_func(rx_sock)
+    tx_can_bus.send(can_message)
+    obtained = recv_fn()
+    assert obtained.arbitration_id == can_message.arbitration_id
+    assert obtained.is_extended_id == can_message.is_extended_id
+    assert obtained.data == can_message.data
+
+
+@given(can_message=can_messages())
+@settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+@pytest.mark.parametrize("tx_sock", SOCKET_PROVIDERS, indirect=True)
+@skip_if_no_vcan()
+def test_send_message(
+    can_message: PyCanMessage,
+    rx_can_bus: SocketcanBus,
+    tx_sock: SocketcanFd,
+) -> None:
+    send_fn = build_send_func(tx_sock)
+    send_fn(can_message.arbitration_id, can_message.data, can_message.is_extended_id)  # type: ignore[arg-type]
+    obtained = rx_can_bus.recv(timeout=0)
+    assert obtained is not None, "Message was not sent"
+
+    assert obtained.arbitration_id == can_message.arbitration_id
+    assert obtained.is_extended_id == can_message.is_extended_id
+    assert obtained.data == can_message.data