busio¶

import pytest
from collections import deque
from circuitpython_mocks import busio, board
from circuitpython_mocks.busio.operations import I2CTransfer


@pytest.mark.parametrize(
    argnames=["board_i2c", "busio_i2c"],
    argvalues=[
        (board.I2C(), busio.I2C(board.SCL, board.SDA)),
        (board.STEMMA_I2C(), busio.I2C(board.SCL1, board.SDA1)),
    ],
    ids=["primary_bus", "secondary_bus"],
)
def test_singleton(board_i2c: busio.I2C, busio_i2c: busio.I2C):
    address = 0x42

    assert hasattr(board_i2c, "expectations")
    assert isinstance(board_i2c.expectations, deque)
    assert board_i2c == busio_i2c

    board_i2c.expectations.append(I2CTransfer(address, bytearray(1), bytearray(1)))
    assert busio_i2c.expectations == board_i2c.expectations
    buffer = bytearray(1)
    assert board_i2c.try_lock()
    assert not busio_i2c.try_lock()
    board_i2c.writeto_then_readfrom(address, buffer, buffer)
    board_i2c.unlock()
    busio_i2c.unlock()  # for coverage measurement only

    # assert all expectations were used
    board_i2c.done()
    assert board_i2c.expectations == busio_i2c.expectations

import pytest
from collections import deque
from circuitpython_mocks import board, busio
from circuitpython_mocks.busio.operations import SPITransfer


@pytest.mark.parametrize(
    argnames=["board_spi", "busio_spi"],
    argvalues=[
        (board.SPI(), busio.SPI(board.SCK, board.MOSI, board.MISO)),
        (board.SPI1(), busio.SPI(board.SCK_1, board.MOSI_1, board.MISO_1)),
    ],
    ids=["primary_bus", "secondary_bus"],
)
def test_singleton(board_spi: busio.SPI, busio_spi: busio.SPI):
    assert hasattr(board_spi, "expectations")
    assert isinstance(busio_spi.expectations, deque)
    assert board_spi == busio_spi

    board_spi.expectations.append(SPITransfer(bytearray(1), bytearray(1)))
    assert busio_spi.expectations == board_spi.expectations
    buffer = bytearray(1)
    assert board_spi.try_lock()
    assert not busio_spi.try_lock()
    board_spi.write_readinto(buffer, buffer)
    board_spi.unlock()
    busio_spi.unlock()  # for coverage measurement only

    # assert all expectations were used
    board_spi.done()
    assert busio_spi.expectations == board_spi.expectations

from collections import deque
from circuitpython_mocks import board, busio
from circuitpython_mocks.busio.operations import UARTRead, UARTWrite, UARTFlush


def test_singleton():
    board_uart = board.UART()
    assert hasattr(board_uart, "expectations")
    assert isinstance(board_uart.expectations, deque)
    busio_uart = busio.UART(board.TX, board.RX)
    assert board_uart == busio_uart
    board_uart.timeout = 0.5
    assert 0.5 == busio_uart.timeout
    busio_uart.baudrate = 115200
    assert 115200 == board_uart.baudrate

    board_uart.expectations.append(UARTRead(bytearray(1)))
    assert busio_uart.expectations == board_uart.expectations
    buffer = bytearray(1)
    assert 1 == board_uart.in_waiting
    board_uart.readinto(buffer)
    assert not busio_uart.expectations

    busio_uart.expectations.append(UARTWrite(bytearray(1)))
    assert busio_uart.expectations == board_uart.expectations
    assert not busio_uart.in_waiting
    busio_uart.write(bytearray(1))

    busio_uart.expectations.append(UARTFlush())
    assert busio_uart.expectations == board_uart.expectations
    busio_uart.reset_input_buffer()

    # assert all expectations were used
    board_uart.done()
    assert busio_uart.expectations == board_uart.expectations