예제 #1
0
 def _make_dead_filter() -> FilterConfiguration:
     fmt = FrameFormat.BASE
     return FilterConfiguration(0, 2**int(fmt) - 1, fmt)
예제 #2
0
async def _unittest_can_mock_media() -> None:
    peers: typing.Set[MockMedia] = set()

    me = MockMedia(peers, 64, 3)
    assert len(peers) == 1 and me in peers
    assert me.mtu == 64
    assert me.number_of_acceptance_filters == 3
    assert not me.automatic_retransmission_enabled
    assert str(me) == f"MockMedia('mock@{id(peers):08x}', mtu=64)"

    me_collector = FrameCollector()
    me.start(me_collector.give, False)
    assert me.automatic_retransmission_enabled

    # Will drop the loopback because of the acceptance filters
    await me.send(
        [
            Envelope(DataFrame(FrameFormat.EXTENDED, 123, bytearray(b"abc")),
                     loopback=False),
            Envelope(DataFrame(FrameFormat.EXTENDED, 123, bytearray(b"def")),
                     loopback=True),
        ],
        asyncio.get_event_loop().time() + 1.0,
    )
    assert me_collector.empty

    me.configure_acceptance_filters([FilterConfiguration.new_promiscuous()])
    # Now the loopback will be accepted because we have reconfigured the filters
    await me.send(
        [
            Envelope(DataFrame(FrameFormat.EXTENDED, 123, bytearray(b"abc")),
                     loopback=False),
            Envelope(DataFrame(FrameFormat.EXTENDED, 123, bytearray(b"def")),
                     loopback=True),
        ],
        asyncio.get_event_loop().time() + 1.0,
    )
    assert me_collector.pop()[1].frame == DataFrame(FrameFormat.EXTENDED, 123,
                                                    bytearray(b"def"))
    assert me_collector.empty

    pe = MockMedia(peers, 8, 1)
    assert peers == {me, pe}

    pe_collector = FrameCollector()
    pe.start(pe_collector.give, False)

    me.raise_on_send_once(RuntimeError("Hello world!"))
    with pytest.raises(RuntimeError, match="Hello world!"):
        await me.send([], asyncio.get_event_loop().time() + 1.0)

    await me.send(
        [
            Envelope(DataFrame(FrameFormat.EXTENDED, 123, bytearray(b"abc")),
                     loopback=False),
            Envelope(DataFrame(FrameFormat.EXTENDED, 123, bytearray(b"def")),
                     loopback=True),
        ],
        asyncio.get_event_loop().time() + 1.0,
    )
    assert pe_collector.empty

    pe.configure_acceptance_filters([FilterConfiguration(123, 127, None)])
    await me.send(
        [
            Envelope(DataFrame(FrameFormat.EXTENDED, 123, bytearray(b"abc")),
                     loopback=False),
            Envelope(DataFrame(FrameFormat.EXTENDED, 123, bytearray(b"def")),
                     loopback=True),
        ],
        asyncio.get_event_loop().time() + 1.0,
    )
    await me.send(
        [
            Envelope(DataFrame(FrameFormat.EXTENDED, 456, bytearray(b"ghi")),
                     loopback=False),  # Dropped by the filters
        ],
        asyncio.get_event_loop().time() + 1.0,
    )
    assert pe_collector.pop()[1].frame == DataFrame(FrameFormat.EXTENDED, 123,
                                                    bytearray(b"abc"))
    assert pe_collector.pop()[1].frame == DataFrame(FrameFormat.EXTENDED, 123,
                                                    bytearray(b"def"))
    assert pe_collector.empty

    me.close()
    me.close()  # Idempotency.
    assert peers == {pe}
    with pytest.raises(pyuavcan.transport.ResourceClosedError):
        await me.send([], asyncio.get_event_loop().time() + 1.0)
    with pytest.raises(pyuavcan.transport.ResourceClosedError):
        me.configure_acceptance_filters([])
    await asyncio.sleep(
        1
    )  # Let all pending tasks finalize properly to avoid stack traces in the output.
예제 #3
0
async def _unittest_can_mock_media() -> None:
    import asyncio
    from pyuavcan.transport.can.media import DataFrame, FrameFormat, FilterConfiguration

    peers: typing.Set[MockMedia] = set()

    me = MockMedia(peers, 64, 3)
    assert len(peers) == 1 and me in peers
    assert me.mtu == 64
    assert me.number_of_acceptance_filters == 3
    assert not me.automatic_retransmission_enabled
    assert str(me) == f"MockMedia(interface_name='mock@{id(peers):08x}', mtu=64)"

    me_collector = FrameCollector()
    me.start(me_collector.give, False)
    assert me.automatic_retransmission_enabled

    # Will drop the loopback because of the acceptance filters
    await me.send_until([
        DataFrame(123, bytearray(b'abc'), FrameFormat.EXTENDED, loopback=False),
        DataFrame(123, bytearray(b'def'), FrameFormat.EXTENDED, loopback=True),
    ], asyncio.get_event_loop().time() + 1.0)
    assert me_collector.empty

    me.configure_acceptance_filters([FilterConfiguration.new_promiscuous()])
    # Now the loopback will be accepted because we have reconfigured the filters
    await me.send_until([
        DataFrame(123, bytearray(b'abc'), FrameFormat.EXTENDED, loopback=False),
        DataFrame(123, bytearray(b'def'), FrameFormat.EXTENDED, loopback=True),
    ], asyncio.get_event_loop().time() + 1.0)
    assert me_collector.pop().is_same_manifestation(
        DataFrame(123, bytearray(b'def'), FrameFormat.EXTENDED, loopback=True))
    assert me_collector.empty

    pe = MockMedia(peers, 8, 1)
    assert peers == {me, pe}

    pe_collector = FrameCollector()
    pe.start(pe_collector.give, False)

    me.raise_on_send_once(RuntimeError('Hello world!'))
    with pytest.raises(RuntimeError, match='Hello world!'):
        await me.send_until([], asyncio.get_event_loop().time() + 1.0)

    await me.send_until([
        DataFrame(123, bytearray(b'abc'), FrameFormat.EXTENDED, loopback=False),
        DataFrame(123, bytearray(b'def'), FrameFormat.EXTENDED, loopback=True),
    ], asyncio.get_event_loop().time() + 1.0)
    assert pe_collector.empty

    pe.configure_acceptance_filters([FilterConfiguration(123, 127, None)])
    await me.send_until([
        DataFrame(123, bytearray(b'abc'), FrameFormat.EXTENDED, loopback=False),
        DataFrame(123, bytearray(b'def'), FrameFormat.EXTENDED, loopback=True),
    ], asyncio.get_event_loop().time() + 1.0)
    await me.send_until([
        DataFrame(456, bytearray(b'ghi'), FrameFormat.EXTENDED, loopback=False),    # Dropped by the filters
    ], asyncio.get_event_loop().time() + 1.0)
    assert pe_collector.pop().is_same_manifestation(
        DataFrame(123, bytearray(b'abc'), FrameFormat.EXTENDED, loopback=False))
    assert pe_collector.pop().is_same_manifestation(
        DataFrame(123, bytearray(b'def'), FrameFormat.EXTENDED, loopback=False))
    assert pe_collector.empty

    me.close()
    assert peers == {pe}
    with pytest.raises(pyuavcan.transport.ResourceClosedError):
        await me.send_until([], asyncio.get_event_loop().time() + 1.0)
    with pytest.raises(pyuavcan.transport.ResourceClosedError):
        me.configure_acceptance_filters([])
    with pytest.raises(pyuavcan.transport.ResourceClosedError):
        me.close()